
// @from(Start 2019393, End 2040635)
byA = z((M18, vyA) => {
  function an9(A) {
    let B = A.COMMENT("--", "$"),
      Q = "[a-zA-Z_][a-zA-Z_0-9$]*",
      I = "\\$([a-zA-Z_]?|[a-zA-Z_][a-zA-Z_0-9]*)\\$",
      G = "<<\\s*[a-zA-Z_][a-zA-Z_0-9$]*\\s*>>",
      Z = "ABORT ALTER ANALYZE BEGIN CALL CHECKPOINT|10 CLOSE CLUSTER COMMENT COMMIT COPY CREATE DEALLOCATE DECLARE DELETE DISCARD DO DROP END EXECUTE EXPLAIN FETCH GRANT IMPORT INSERT LISTEN LOAD LOCK MOVE NOTIFY PREPARE REASSIGN|10 REFRESH REINDEX RELEASE RESET REVOKE ROLLBACK SAVEPOINT SECURITY SELECT SET SHOW START TRUNCATE UNLISTEN|10 UPDATE VACUUM|10 VALUES AGGREGATE COLLATION CONVERSION|10 DATABASE DEFAULT PRIVILEGES DOMAIN TRIGGER EXTENSION FOREIGN WRAPPER|10 TABLE FUNCTION GROUP LANGUAGE LARGE OBJECT MATERIALIZED VIEW OPERATOR CLASS FAMILY POLICY PUBLICATION|10 ROLE RULE SCHEMA SEQUENCE SERVER STATISTICS SUBSCRIPTION SYSTEM TABLESPACE CONFIGURATION DICTIONARY PARSER TEMPLATE TYPE USER MAPPING PREPARED ACCESS METHOD CAST AS TRANSFORM TRANSACTION OWNED TO INTO SESSION AUTHORIZATION INDEX PROCEDURE ASSERTION ALL ANALYSE AND ANY ARRAY ASC ASYMMETRIC|10 BOTH CASE CHECK COLLATE COLUMN CONCURRENTLY|10 CONSTRAINT CROSS DEFERRABLE RANGE DESC DISTINCT ELSE EXCEPT FOR FREEZE|10 FROM FULL HAVING ILIKE IN INITIALLY INNER INTERSECT IS ISNULL JOIN LATERAL LEADING LIKE LIMIT NATURAL NOT NOTNULL NULL OFFSET ON ONLY OR ORDER OUTER OVERLAPS PLACING PRIMARY REFERENCES RETURNING SIMILAR SOME SYMMETRIC TABLESAMPLE THEN TRAILING UNION UNIQUE USING VARIADIC|10 VERBOSE WHEN WHERE WINDOW WITH BY RETURNS INOUT OUT SETOF|10 IF STRICT CURRENT CONTINUE OWNER LOCATION OVER PARTITION WITHIN BETWEEN ESCAPE EXTERNAL INVOKER DEFINER WORK RENAME VERSION CONNECTION CONNECT TABLES TEMP TEMPORARY FUNCTIONS SEQUENCES TYPES SCHEMAS OPTION CASCADE RESTRICT ADD ADMIN EXISTS VALID VALIDATE ENABLE DISABLE REPLICA|10 ALWAYS PASSING COLUMNS PATH REF VALUE OVERRIDING IMMUTABLE STABLE VOLATILE BEFORE AFTER EACH ROW PROCEDURAL ROUTINE NO HANDLER VALIDATOR OPTIONS STORAGE OIDS|10 WITHOUT INHERIT DEPENDS CALLED INPUT LEAKPROOF|10 COST ROWS NOWAIT SEARCH UNTIL ENCRYPTED|10 PASSWORD CONFLICT|10 INSTEAD INHERITS CHARACTERISTICS WRITE CURSOR ALSO STATEMENT SHARE EXCLUSIVE INLINE ISOLATION REPEATABLE READ COMMITTED SERIALIZABLE UNCOMMITTED LOCAL GLOBAL SQL PROCEDURES RECURSIVE SNAPSHOT ROLLUP CUBE TRUSTED|10 INCLUDE FOLLOWING PRECEDING UNBOUNDED RANGE GROUPS UNENCRYPTED|10 SYSID FORMAT DELIMITER HEADER QUOTE ENCODING FILTER OFF FORCE_QUOTE FORCE_NOT_NULL FORCE_NULL COSTS BUFFERS TIMING SUMMARY DISABLE_PAGE_SKIPPING RESTART CYCLE GENERATED IDENTITY DEFERRED IMMEDIATE LEVEL LOGGED UNLOGGED OF NOTHING NONE EXCLUDE ATTRIBUTE USAGE ROUTINES TRUE FALSE NAN INFINITY ",
      D = "SUPERUSER NOSUPERUSER CREATEDB NOCREATEDB CREATEROLE NOCREATEROLE INHERIT NOINHERIT LOGIN NOLOGIN REPLICATION NOREPLICATION BYPASSRLS NOBYPASSRLS ",
      Y = "ALIAS BEGIN CONSTANT DECLARE END EXCEPTION RETURN PERFORM|10 RAISE GET DIAGNOSTICS STACKED|10 FOREACH LOOP ELSIF EXIT WHILE REVERSE SLICE DEBUG LOG INFO NOTICE WARNING ASSERT OPEN ",
      W = "BIGINT INT8 BIGSERIAL SERIAL8 BIT VARYING VARBIT BOOLEAN BOOL BOX BYTEA CHARACTER CHAR VARCHAR CIDR CIRCLE DATE DOUBLE PRECISION FLOAT8 FLOAT INET INTEGER INT INT4 INTERVAL JSON JSONB LINE LSEG|10 MACADDR MACADDR8 MONEY NUMERIC DEC DECIMAL PATH POINT POLYGON REAL FLOAT4 SMALLINT INT2 SMALLSERIAL|10 SERIAL2|10 SERIAL|10 SERIAL4|10 TEXT TIME ZONE TIMETZ|10 TIMESTAMP TIMESTAMPTZ|10 TSQUERY|10 TSVECTOR|10 TXID_SNAPSHOT|10 UUID XML NATIONAL NCHAR INT4RANGE|10 INT8RANGE|10 NUMRANGE|10 TSRANGE|10 TSTZRANGE|10 DATERANGE|10 ANYELEMENT ANYARRAY ANYNONARRAY ANYENUM ANYRANGE CSTRING INTERNAL RECORD PG_DDL_COMMAND VOID UNKNOWN OPAQUE REFCURSOR NAME OID REGPROC|10 REGPROCEDURE|10 REGOPER|10 REGOPERATOR|10 REGCLASS|10 REGTYPE|10 REGROLE|10 REGNAMESPACE|10 REGCONFIG|10 REGDICTIONARY|10 ",
      J = W.trim().split(" ").map(function(E) {
        return E.split("|")[0]
      }).join("|"),
      F = "CURRENT_TIME CURRENT_TIMESTAMP CURRENT_USER CURRENT_CATALOG|10 CURRENT_DATE LOCALTIME LOCALTIMESTAMP CURRENT_ROLE|10 CURRENT_SCHEMA|10 SESSION_USER PUBLIC ",
      X = "FOUND NEW OLD TG_NAME|10 TG_WHEN|10 TG_LEVEL|10 TG_OP|10 TG_RELID|10 TG_RELNAME|10 TG_TABLE_NAME|10 TG_TABLE_SCHEMA|10 TG_NARGS|10 TG_ARGV|10 TG_EVENT|10 TG_TAG|10 ROW_COUNT RESULT_OID|10 PG_CONTEXT|10 RETURNED_SQLSTATE COLUMN_NAME CONSTRAINT_NAME PG_DATATYPE_NAME|10 MESSAGE_TEXT TABLE_NAME SCHEMA_NAME PG_EXCEPTION_DETAIL|10 PG_EXCEPTION_HINT|10 PG_EXCEPTION_CONTEXT|10 ",
      V = "SQLSTATE SQLERRM|10 SUCCESSFUL_COMPLETION WARNING DYNAMIC_RESULT_SETS_RETURNED IMPLICIT_ZERO_BIT_PADDING NULL_VALUE_ELIMINATED_IN_SET_FUNCTION PRIVILEGE_NOT_GRANTED PRIVILEGE_NOT_REVOKED STRING_DATA_RIGHT_TRUNCATION DEPRECATED_FEATURE NO_DATA NO_ADDITIONAL_DYNAMIC_RESULT_SETS_RETURNED SQL_STATEMENT_NOT_YET_COMPLETE CONNECTION_EXCEPTION CONNECTION_DOES_NOT_EXIST CONNECTION_FAILURE SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION SQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION TRANSACTION_RESOLUTION_UNKNOWN PROTOCOL_VIOLATION TRIGGERED_ACTION_EXCEPTION FEATURE_NOT_SUPPORTED INVALID_TRANSACTION_INITIATION LOCATOR_EXCEPTION INVALID_LOCATOR_SPECIFICATION INVALID_GRANTOR INVALID_GRANT_OPERATION INVALID_ROLE_SPECIFICATION DIAGNOSTICS_EXCEPTION STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER CASE_NOT_FOUND CARDINALITY_VIOLATION DATA_EXCEPTION ARRAY_SUBSCRIPT_ERROR CHARACTER_NOT_IN_REPERTOIRE DATETIME_FIELD_OVERFLOW DIVISION_BY_ZERO ERROR_IN_ASSIGNMENT ESCAPE_CHARACTER_CONFLICT INDICATOR_OVERFLOW INTERVAL_FIELD_OVERFLOW INVALID_ARGUMENT_FOR_LOGARITHM INVALID_ARGUMENT_FOR_NTILE_FUNCTION INVALID_ARGUMENT_FOR_NTH_VALUE_FUNCTION INVALID_ARGUMENT_FOR_POWER_FUNCTION INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION INVALID_CHARACTER_VALUE_FOR_CAST INVALID_DATETIME_FORMAT INVALID_ESCAPE_CHARACTER INVALID_ESCAPE_OCTET INVALID_ESCAPE_SEQUENCE NONSTANDARD_USE_OF_ESCAPE_CHARACTER INVALID_INDICATOR_PARAMETER_VALUE INVALID_PARAMETER_VALUE INVALID_REGULAR_EXPRESSION INVALID_ROW_COUNT_IN_LIMIT_CLAUSE INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE INVALID_TABLESAMPLE_ARGUMENT INVALID_TABLESAMPLE_REPEAT INVALID_TIME_ZONE_DISPLACEMENT_VALUE INVALID_USE_OF_ESCAPE_CHARACTER MOST_SPECIFIC_TYPE_MISMATCH NULL_VALUE_NOT_ALLOWED NULL_VALUE_NO_INDICATOR_PARAMETER NUMERIC_VALUE_OUT_OF_RANGE SEQUENCE_GENERATOR_LIMIT_EXCEEDED STRING_DATA_LENGTH_MISMATCH STRING_DATA_RIGHT_TRUNCATION SUBSTRING_ERROR TRIM_ERROR UNTERMINATED_C_STRING ZERO_LENGTH_CHARACTER_STRING FLOATING_POINT_EXCEPTION INVALID_TEXT_REPRESENTATION INVALID_BINARY_REPRESENTATION BAD_COPY_FILE_FORMAT UNTRANSLATABLE_CHARACTER NOT_AN_XML_DOCUMENT INVALID_XML_DOCUMENT INVALID_XML_CONTENT INVALID_XML_COMMENT INVALID_XML_PROCESSING_INSTRUCTION INTEGRITY_CONSTRAINT_VIOLATION RESTRICT_VIOLATION NOT_NULL_VIOLATION FOREIGN_KEY_VIOLATION UNIQUE_VIOLATION CHECK_VIOLATION EXCLUSION_VIOLATION INVALID_CURSOR_STATE INVALID_TRANSACTION_STATE ACTIVE_SQL_TRANSACTION BRANCH_TRANSACTION_ALREADY_ACTIVE HELD_CURSOR_REQUIRES_SAME_ISOLATION_LEVEL INAPPROPRIATE_ACCESS_MODE_FOR_BRANCH_TRANSACTION INAPPROPRIATE_ISOLATION_LEVEL_FOR_BRANCH_TRANSACTION NO_ACTIVE_SQL_TRANSACTION_FOR_BRANCH_TRANSACTION READ_ONLY_SQL_TRANSACTION SCHEMA_AND_DATA_STATEMENT_MIXING_NOT_SUPPORTED NO_ACTIVE_SQL_TRANSACTION IN_FAILED_SQL_TRANSACTION IDLE_IN_TRANSACTION_SESSION_TIMEOUT INVALID_SQL_STATEMENT_NAME TRIGGERED_DATA_CHANGE_VIOLATION INVALID_AUTHORIZATION_SPECIFICATION INVALID_PASSWORD DEPENDENT_PRIVILEGE_DESCRIPTORS_STILL_EXIST DEPENDENT_OBJECTS_STILL_EXIST INVALID_TRANSACTION_TERMINATION SQL_ROUTINE_EXCEPTION FUNCTION_EXECUTED_NO_RETURN_STATEMENT MODIFYING_SQL_DATA_NOT_PERMITTED PROHIBITED_SQL_STATEMENT_ATTEMPTED READING_SQL_DATA_NOT_PERMITTED INVALID_CURSOR_NAME EXTERNAL_ROUTINE_EXCEPTION CONTAINING_SQL_NOT_PERMITTED MODIFYING_SQL_DATA_NOT_PERMITTED PROHIBITED_SQL_STATEMENT_ATTEMPTED READING_SQL_DATA_NOT_PERMITTED EXTERNAL_ROUTINE_INVOCATION_EXCEPTION INVALID_SQLSTATE_RETURNED NULL_VALUE_NOT_ALLOWED TRIGGER_PROTOCOL_VIOLATED SRF_PROTOCOL_VIOLATED EVENT_TRIGGER_PROTOCOL_VIOLATED SAVEPOINT_EXCEPTION INVALID_SAVEPOINT_SPECIFICATION INVALID_CATALOG_NAME INVALID_SCHEMA_NAME TRANSACTION_ROLLBACK TRANSACTION_INTEGRITY_CONSTRAINT_VIOLATION SERIALIZATION_FAILURE STATEMENT_COMPLETION_UNKNOWN DEADLOCK_DETECTED SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION SYNTAX_ERROR INSUFFICIENT_PRIVILEGE CANNOT_COERCE GROUPING_ERROR WINDOWING_ERROR INVALID_RECURSION INVALID_FOREIGN_KEY INVALID_NAME NAME_TOO_LONG RESERVED_NAME DATATYPE_MISMATCH INDETERMINATE_DATATYPE COLLATION_MISMATCH INDETERMINATE_COLLATION WRONG_OBJECT_TYPE GENERATED_ALWAYS UNDEFINED_COLUMN UNDEFINED_FUNCTION UNDEFINED_TABLE UNDEFINED_PARAMETER UNDEFINED_OBJECT DUPLICATE_COLUMN DUPLICATE_CURSOR DUPLICATE_DATABASE DUPLICATE_FUNCTION DUPLICATE_PREPARED_STATEMENT DUPLICATE_SCHEMA DUPLICATE_TABLE DUPLICATE_ALIAS DUPLICATE_OBJECT AMBIGUOUS_COLUMN AMBIGUOUS_FUNCTION AMBIGUOUS_PARAMETER AMBIGUOUS_ALIAS INVALID_COLUMN_REFERENCE INVALID_COLUMN_DEFINITION INVALID_CURSOR_DEFINITION INVALID_DATABASE_DEFINITION INVALID_FUNCTION_DEFINITION INVALID_PREPARED_STATEMENT_DEFINITION INVALID_SCHEMA_DEFINITION INVALID_TABLE_DEFINITION INVALID_OBJECT_DEFINITION WITH_CHECK_OPTION_VIOLATION INSUFFICIENT_RESOURCES DISK_FULL OUT_OF_MEMORY TOO_MANY_CONNECTIONS CONFIGURATION_LIMIT_EXCEEDED PROGRAM_LIMIT_EXCEEDED STATEMENT_TOO_COMPLEX TOO_MANY_COLUMNS TOO_MANY_ARGUMENTS OBJECT_NOT_IN_PREREQUISITE_STATE OBJECT_IN_USE CANT_CHANGE_RUNTIME_PARAM LOCK_NOT_AVAILABLE OPERATOR_INTERVENTION QUERY_CANCELED ADMIN_SHUTDOWN CRASH_SHUTDOWN CANNOT_CONNECT_NOW DATABASE_DROPPED SYSTEM_ERROR IO_ERROR UNDEFINED_FILE DUPLICATE_FILE SNAPSHOT_TOO_OLD CONFIG_FILE_ERROR LOCK_FILE_EXISTS FDW_ERROR FDW_COLUMN_NAME_NOT_FOUND FDW_DYNAMIC_PARAMETER_VALUE_NEEDED FDW_FUNCTION_SEQUENCE_ERROR FDW_INCONSISTENT_DESCRIPTOR_INFORMATION FDW_INVALID_ATTRIBUTE_VALUE FDW_INVALID_COLUMN_NAME FDW_INVALID_COLUMN_NUMBER FDW_INVALID_DATA_TYPE FDW_INVALID_DATA_TYPE_DESCRIPTORS FDW_INVALID_DESCRIPTOR_FIELD_IDENTIFIER FDW_INVALID_HANDLE FDW_INVALID_OPTION_INDEX FDW_INVALID_OPTION_NAME FDW_INVALID_STRING_LENGTH_OR_BUFFER_LENGTH FDW_INVALID_STRING_FORMAT FDW_INVALID_USE_OF_NULL_POINTER FDW_TOO_MANY_HANDLES FDW_OUT_OF_MEMORY FDW_NO_SCHEMAS FDW_OPTION_NAME_NOT_FOUND FDW_REPLY_HANDLE FDW_SCHEMA_NOT_FOUND FDW_TABLE_NOT_FOUND FDW_UNABLE_TO_CREATE_EXECUTION FDW_UNABLE_TO_CREATE_REPLY FDW_UNABLE_TO_ESTABLISH_CONNECTION PLPGSQL_ERROR RAISE_EXCEPTION NO_DATA_FOUND TOO_MANY_ROWS ASSERT_FAILURE INTERNAL_ERROR DATA_CORRUPTED INDEX_CORRUPTED ",
      K = "ARRAY_AGG AVG BIT_AND BIT_OR BOOL_AND BOOL_OR COUNT EVERY JSON_AGG JSONB_AGG JSON_OBJECT_AGG JSONB_OBJECT_AGG MAX MIN MODE STRING_AGG SUM XMLAGG CORR COVAR_POP COVAR_SAMP REGR_AVGX REGR_AVGY REGR_COUNT REGR_INTERCEPT REGR_R2 REGR_SLOPE REGR_SXX REGR_SXY REGR_SYY STDDEV STDDEV_POP STDDEV_SAMP VARIANCE VAR_POP VAR_SAMP PERCENTILE_CONT PERCENTILE_DISC ROW_NUMBER RANK DENSE_RANK PERCENT_RANK CUME_DIST NTILE LAG LEAD FIRST_VALUE LAST_VALUE NTH_VALUE NUM_NONNULLS NUM_NULLS ABS CBRT CEIL CEILING DEGREES DIV EXP FLOOR LN LOG MOD PI POWER RADIANS ROUND SCALE SIGN SQRT TRUNC WIDTH_BUCKET RANDOM SETSEED ACOS ACOSD ASIN ASIND ATAN ATAND ATAN2 ATAN2D COS COSD COT COTD SIN SIND TAN TAND BIT_LENGTH CHAR_LENGTH CHARACTER_LENGTH LOWER OCTET_LENGTH OVERLAY POSITION SUBSTRING TREAT TRIM UPPER ASCII BTRIM CHR CONCAT CONCAT_WS CONVERT CONVERT_FROM CONVERT_TO DECODE ENCODE INITCAP LEFT LENGTH LPAD LTRIM MD5 PARSE_IDENT PG_CLIENT_ENCODING QUOTE_IDENT|10 QUOTE_LITERAL|10 QUOTE_NULLABLE|10 REGEXP_MATCH REGEXP_MATCHES REGEXP_REPLACE REGEXP_SPLIT_TO_ARRAY REGEXP_SPLIT_TO_TABLE REPEAT REPLACE REVERSE RIGHT RPAD RTRIM SPLIT_PART STRPOS SUBSTR TO_ASCII TO_HEX TRANSLATE OCTET_LENGTH GET_BIT GET_BYTE SET_BIT SET_BYTE TO_CHAR TO_DATE TO_NUMBER TO_TIMESTAMP AGE CLOCK_TIMESTAMP|10 DATE_PART DATE_TRUNC ISFINITE JUSTIFY_DAYS JUSTIFY_HOURS JUSTIFY_INTERVAL MAKE_DATE MAKE_INTERVAL|10 MAKE_TIME MAKE_TIMESTAMP|10 MAKE_TIMESTAMPTZ|10 NOW STATEMENT_TIMESTAMP|10 TIMEOFDAY TRANSACTION_TIMESTAMP|10 ENUM_FIRST ENUM_LAST ENUM_RANGE AREA CENTER DIAMETER HEIGHT ISCLOSED ISOPEN NPOINTS PCLOSE POPEN RADIUS WIDTH BOX BOUND_BOX CIRCLE LINE LSEG PATH POLYGON ABBREV BROADCAST HOST HOSTMASK MASKLEN NETMASK NETWORK SET_MASKLEN TEXT INET_SAME_FAMILY INET_MERGE MACADDR8_SET7BIT ARRAY_TO_TSVECTOR GET_CURRENT_TS_CONFIG NUMNODE PLAINTO_TSQUERY PHRASETO_TSQUERY WEBSEARCH_TO_TSQUERY QUERYTREE SETWEIGHT STRIP TO_TSQUERY TO_TSVECTOR JSON_TO_TSVECTOR JSONB_TO_TSVECTOR TS_DELETE TS_FILTER TS_HEADLINE TS_RANK TS_RANK_CD TS_REWRITE TSQUERY_PHRASE TSVECTOR_TO_ARRAY TSVECTOR_UPDATE_TRIGGER TSVECTOR_UPDATE_TRIGGER_COLUMN XMLCOMMENT XMLCONCAT XMLELEMENT XMLFOREST XMLPI XMLROOT XMLEXISTS XML_IS_WELL_FORMED XML_IS_WELL_FORMED_DOCUMENT XML_IS_WELL_FORMED_CONTENT XPATH XPATH_EXISTS XMLTABLE XMLNAMESPACES TABLE_TO_XML TABLE_TO_XMLSCHEMA TABLE_TO_XML_AND_XMLSCHEMA QUERY_TO_XML QUERY_TO_XMLSCHEMA QUERY_TO_XML_AND_XMLSCHEMA CURSOR_TO_XML CURSOR_TO_XMLSCHEMA SCHEMA_TO_XML SCHEMA_TO_XMLSCHEMA SCHEMA_TO_XML_AND_XMLSCHEMA DATABASE_TO_XML DATABASE_TO_XMLSCHEMA DATABASE_TO_XML_AND_XMLSCHEMA XMLATTRIBUTES TO_JSON TO_JSONB ARRAY_TO_JSON ROW_TO_JSON JSON_BUILD_ARRAY JSONB_BUILD_ARRAY JSON_BUILD_OBJECT JSONB_BUILD_OBJECT JSON_OBJECT JSONB_OBJECT JSON_ARRAY_LENGTH JSONB_ARRAY_LENGTH JSON_EACH JSONB_EACH JSON_EACH_TEXT JSONB_EACH_TEXT JSON_EXTRACT_PATH JSONB_EXTRACT_PATH JSON_OBJECT_KEYS JSONB_OBJECT_KEYS JSON_POPULATE_RECORD JSONB_POPULATE_RECORD JSON_POPULATE_RECORDSET JSONB_POPULATE_RECORDSET JSON_ARRAY_ELEMENTS JSONB_ARRAY_ELEMENTS JSON_ARRAY_ELEMENTS_TEXT JSONB_ARRAY_ELEMENTS_TEXT JSON_TYPEOF JSONB_TYPEOF JSON_TO_RECORD JSONB_TO_RECORD JSON_TO_RECORDSET JSONB_TO_RECORDSET JSON_STRIP_NULLS JSONB_STRIP_NULLS JSONB_SET JSONB_INSERT JSONB_PRETTY CURRVAL LASTVAL NEXTVAL SETVAL COALESCE NULLIF GREATEST LEAST ARRAY_APPEND ARRAY_CAT ARRAY_NDIMS ARRAY_DIMS ARRAY_FILL ARRAY_LENGTH ARRAY_LOWER ARRAY_POSITION ARRAY_POSITIONS ARRAY_PREPEND ARRAY_REMOVE ARRAY_REPLACE ARRAY_TO_STRING ARRAY_UPPER CARDINALITY STRING_TO_ARRAY UNNEST ISEMPTY LOWER_INC UPPER_INC LOWER_INF UPPER_INF RANGE_MERGE GENERATE_SERIES GENERATE_SUBSCRIPTS CURRENT_DATABASE CURRENT_QUERY CURRENT_SCHEMA|10 CURRENT_SCHEMAS|10 INET_CLIENT_ADDR INET_CLIENT_PORT INET_SERVER_ADDR INET_SERVER_PORT ROW_SECURITY_ACTIVE FORMAT_TYPE TO_REGCLASS TO_REGPROC TO_REGPROCEDURE TO_REGOPER TO_REGOPERATOR TO_REGTYPE TO_REGNAMESPACE TO_REGROLE COL_DESCRIPTION OBJ_DESCRIPTION SHOBJ_DESCRIPTION TXID_CURRENT TXID_CURRENT_IF_ASSIGNED TXID_CURRENT_SNAPSHOT TXID_SNAPSHOT_XIP TXID_SNAPSHOT_XMAX TXID_SNAPSHOT_XMIN TXID_VISIBLE_IN_SNAPSHOT TXID_STATUS CURRENT_SETTING SET_CONFIG BRIN_SUMMARIZE_NEW_VALUES BRIN_SUMMARIZE_RANGE BRIN_DESUMMARIZE_RANGE GIN_CLEAN_PENDING_LIST SUPPRESS_REDUNDANT_UPDATES_TRIGGER LO_FROM_BYTEA LO_PUT LO_GET LO_CREAT LO_CREATE LO_UNLINK LO_IMPORT LO_EXPORT LOREAD LOWRITE GROUPING CAST ".trim().split(" ").map(function(E) {
        return E.split("|")[0]
      }).join("|");
    return {
      name: "PostgreSQL",
      aliases: ["postgres", "postgresql"],
      case_insensitive: !0,
      keywords: {
        keyword: Z + Y + D,
        built_in: F + X + V
      },
      illegal: /:==|\W\s*\(\*|(^|\s)\$[a-z]|\{\{|[a-z]:\s*$|\.\.\.|TO:|DO:/,
      contains: [{
        className: "keyword",
        variants: [{
          begin: /\bTEXT\s*SEARCH\b/
        }, {
          begin: /\b(PRIMARY|FOREIGN|FOR(\s+NO)?)\s+KEY\b/
        }, {
          begin: /\bPARALLEL\s+(UNSAFE|RESTRICTED|SAFE)\b/
        }, {
          begin: /\bSTORAGE\s+(PLAIN|EXTERNAL|EXTENDED|MAIN)\b/
        }, {
          begin: /\bMATCH\s+(FULL|PARTIAL|SIMPLE)\b/
        }, {
          begin: /\bNULLS\s+(FIRST|LAST)\b/
        }, {
          begin: /\bEVENT\s+TRIGGER\b/
        }, {
          begin: /\b(MAPPING|OR)\s+REPLACE\b/
        }, {
          begin: /\b(FROM|TO)\s+(PROGRAM|STDIN|STDOUT)\b/
        }, {
          begin: /\b(SHARE|EXCLUSIVE)\s+MODE\b/
        }, {
          begin: /\b(LEFT|RIGHT)\s+(OUTER\s+)?JOIN\b/
        }, {
          begin: /\b(FETCH|MOVE)\s+(NEXT|PRIOR|FIRST|LAST|ABSOLUTE|RELATIVE|FORWARD|BACKWARD)\b/
        }, {
          begin: /\bPRESERVE\s+ROWS\b/
        }, {
          begin: /\bDISCARD\s+PLANS\b/
        }, {
          begin: /\bREFERENCING\s+(OLD|NEW)\b/
        }, {
          begin: /\bSKIP\s+LOCKED\b/
        }, {
          begin: /\bGROUPING\s+SETS\b/
        }, {
          begin: /\b(BINARY|INSENSITIVE|SCROLL|NO\s+SCROLL)\s+(CURSOR|FOR)\b/
        }, {
          begin: /\b(WITH|WITHOUT)\s+HOLD\b/
        }, {
          begin: /\bWITH\s+(CASCADED|LOCAL)\s+CHECK\s+OPTION\b/
        }, {
          begin: /\bEXCLUDE\s+(TIES|NO\s+OTHERS)\b/
        }, {
          begin: /\bFORMAT\s+(TEXT|XML|JSON|YAML)\b/
        }, {
          begin: /\bSET\s+((SESSION|LOCAL)\s+)?NAMES\b/
        }, {
          begin: /\bIS\s+(NOT\s+)?UNKNOWN\b/
        }, {
          begin: /\bSECURITY\s+LABEL\b/
        }, {
          begin: /\bSTANDALONE\s+(YES|NO|NO\s+VALUE)\b/
        }, {
          begin: /\bWITH\s+(NO\s+)?DATA\b/
        }, {
          begin: /\b(FOREIGN|SET)\s+DATA\b/
        }, {
          begin: /\bSET\s+(CATALOG|CONSTRAINTS)\b/
        }, {
          begin: /\b(WITH|FOR)\s+ORDINALITY\b/
        }, {
          begin: /\bIS\s+(NOT\s+)?DOCUMENT\b/
        }, {
          begin: /\bXML\s+OPTION\s+(DOCUMENT|CONTENT)\b/
        }, {
          begin: /\b(STRIP|PRESERVE)\s+WHITESPACE\b/
        }, {
          begin: /\bNO\s+(ACTION|MAXVALUE|MINVALUE)\b/
        }, {
          begin: /\bPARTITION\s+BY\s+(RANGE|LIST|HASH)\b/
        }, {
          begin: /\bAT\s+TIME\s+ZONE\b/
        }, {
          begin: /\bGRANTED\s+BY\b/
        }, {
          begin: /\bRETURN\s+(QUERY|NEXT)\b/
        }, {
          begin: /\b(ATTACH|DETACH)\s+PARTITION\b/
        }, {
          begin: /\bFORCE\s+ROW\s+LEVEL\s+SECURITY\b/
        }, {
          begin: /\b(INCLUDING|EXCLUDING)\s+(COMMENTS|CONSTRAINTS|DEFAULTS|IDENTITY|INDEXES|STATISTICS|STORAGE|ALL)\b/
        }, {
          begin: /\bAS\s+(ASSIGNMENT|IMPLICIT|PERMISSIVE|RESTRICTIVE|ENUM|RANGE)\b/
        }]
      }, {
        begin: /\b(FORMAT|FAMILY|VERSION)\s*\(/
      }, {
        begin: /\bINCLUDE\s*\(/,
        keywords: "INCLUDE"
      }, {
        begin: /\bRANGE(?!\s*(BETWEEN|UNBOUNDED|CURRENT|[-0-9]+))/
      }, {
        begin: /\b(VERSION|OWNER|TEMPLATE|TABLESPACE|CONNECTION\s+LIMIT|PROCEDURE|RESTRICT|JOIN|PARSER|COPY|START|END|COLLATION|INPUT|ANALYZE|STORAGE|LIKE|DEFAULT|DELIMITER|ENCODING|COLUMN|CONSTRAINT|TABLE|SCHEMA)\s*=/
      }, {
        begin: /\b(PG_\w+?|HAS_[A-Z_]+_PRIVILEGE)\b/,
        relevance: 10
      }, {
        begin: /\bEXTRACT\s*\(/,
        end: /\bFROM\b/,
        returnEnd: !0,
        keywords: {
          type: "CENTURY DAY DECADE DOW DOY EPOCH HOUR ISODOW ISOYEAR MICROSECONDS MILLENNIUM MILLISECONDS MINUTE MONTH QUARTER SECOND TIMEZONE TIMEZONE_HOUR TIMEZONE_MINUTE WEEK YEAR"
        }
      }, {
        begin: /\b(XMLELEMENT|XMLPI)\s*\(\s*NAME/,
        keywords: {
          keyword: "NAME"
        }
      }, {
        begin: /\b(XMLPARSE|XMLSERIALIZE)\s*\(\s*(DOCUMENT|CONTENT)/,
        keywords: {
          keyword: "DOCUMENT CONTENT"
        }
      }, {
        beginKeywords: "CACHE INCREMENT MAXVALUE MINVALUE",
        end: A.C_NUMBER_RE,
        returnEnd: !0,
        keywords: "BY CACHE INCREMENT MAXVALUE MINVALUE"
      }, {
        className: "type",
        begin: /\b(WITH|WITHOUT)\s+TIME\s+ZONE\b/
      }, {
        className: "type",
        begin: /\bINTERVAL\s+(YEAR|MONTH|DAY|HOUR|MINUTE|SECOND)(\s+TO\s+(MONTH|HOUR|MINUTE|SECOND))?\b/
      }, {
        begin: /\bRETURNS\s+(LANGUAGE_HANDLER|TRIGGER|EVENT_TRIGGER|FDW_HANDLER|INDEX_AM_HANDLER|TSM_HANDLER)\b/,
        keywords: {
          keyword: "RETURNS",
          type: "LANGUAGE_HANDLER TRIGGER EVENT_TRIGGER FDW_HANDLER INDEX_AM_HANDLER TSM_HANDLER"
        }
      }, {
        begin: "\\b(" + K + ")\\s*\\("
      }, {
        begin: "\\.(" + J + ")\\b"
      }, {
        begin: "\\b(" + J + ")\\s+PATH\\b",
        keywords: {
          keyword: "PATH",
          type: W.replace("PATH ", "")
        }
      }, {
        className: "type",
        begin: "\\b(" + J + ")\\b"
      }, {
        className: "string",
        begin: "'",
        end: "'",
        contains: [{
          begin: "''"
        }]
      }, {
        className: "string",
        begin: "(e|E|u&|U&)'",
        end: "'",
        contains: [{
          begin: "\\\\."
        }],
        relevance: 10
      }, A.END_SAME_AS_BEGIN({
        begin: "\\$([a-zA-Z_]?|[a-zA-Z_][a-zA-Z_0-9]*)\\$",
        end: "\\$([a-zA-Z_]?|[a-zA-Z_][a-zA-Z_0-9]*)\\$",
        contains: [{
          subLanguage: ["pgsql", "perl", "python", "tcl", "r", "lua", "java", "php", "ruby", "bash", "scheme", "xml", "json"],
          endsWithParent: !0
        }]
      }), {
        begin: '"',
        end: '"',
        contains: [{
          begin: '""'
        }]
      }, A.C_NUMBER_MODE, A.C_BLOCK_COMMENT_MODE, B, {
        className: "meta",
        variants: [{
          begin: "%(ROW)?TYPE",
          relevance: 10
        }, {
          begin: "\\$\\d+"
        }, {
          begin: "^#\\w",
          end: "$"
        }]
      }, {
        className: "symbol",
        begin: G,
        relevance: 10
      }]
    }
  }
  vyA.exports = an9
})
// @from(Start 2040641, End 2046129)
hyA = z((L18, gyA) => {
  function sn9(A) {
    let B = {
        className: "variable",
        begin: "\\$+[a-zA-Z_-ÿ][a-zA-Z0-9_-ÿ]*" + "(?![A-Za-z0-9])(?![$])"
      },
      Q = {
        className: "meta",
        variants: [{
          begin: /<\?php/,
          relevance: 10
        }, {
          begin: /<\?[=]?/
        }, {
          begin: /\?>/
        }]
      },
      I = {
        className: "subst",
        variants: [{
          begin: /\$\w+/
        }, {
          begin: /\{\$/,
          end: /\}/
        }]
      },
      G = A.inherit(A.APOS_STRING_MODE, {
        illegal: null
      }),
      Z = A.inherit(A.QUOTE_STRING_MODE, {
        illegal: null,
        contains: A.QUOTE_STRING_MODE.contains.concat(I)
      }),
      D = A.END_SAME_AS_BEGIN({
        begin: /<<<[ \t]*(\w+)\n/,
        end: /[ \t]*(\w+)\b/,
        contains: A.QUOTE_STRING_MODE.contains.concat(I)
      }),
      Y = {
        className: "string",
        contains: [A.BACKSLASH_ESCAPE, Q],
        variants: [A.inherit(G, {
          begin: "b'",
          end: "'"
        }), A.inherit(Z, {
          begin: 'b"',
          end: '"'
        }), Z, G, D]
      },
      W = {
        className: "number",
        variants: [{
          begin: "\\b0b[01]+(?:_[01]+)*\\b"
        }, {
          begin: "\\b0o[0-7]+(?:_[0-7]+)*\\b"
        }, {
          begin: "\\b0x[\\da-f]+(?:_[\\da-f]+)*\\b"
        }, {
          begin: "(?:\\b\\d+(?:_\\d+)*(\\.(?:\\d+(?:_\\d+)*))?|\\B\\.\\d+)(?:e[+-]?\\d+)?"
        }],
        relevance: 0
      },
      J = {
        keyword: "__CLASS__ __DIR__ __FILE__ __FUNCTION__ __LINE__ __METHOD__ __NAMESPACE__ __TRAIT__ die echo exit include include_once print require require_once array abstract and as binary bool boolean break callable case catch class clone const continue declare default do double else elseif empty enddeclare endfor endforeach endif endswitch endwhile enum eval extends final finally float for foreach from global goto if implements instanceof insteadof int integer interface isset iterable list match|0 mixed new object or private protected public real return string switch throw trait try unset use var void while xor yield",
        literal: "false null true",
        built_in: "Error|0 AppendIterator ArgumentCountError ArithmeticError ArrayIterator ArrayObject AssertionError BadFunctionCallException BadMethodCallException CachingIterator CallbackFilterIterator CompileError Countable DirectoryIterator DivisionByZeroError DomainException EmptyIterator ErrorException Exception FilesystemIterator FilterIterator GlobIterator InfiniteIterator InvalidArgumentException IteratorIterator LengthException LimitIterator LogicException MultipleIterator NoRewindIterator OutOfBoundsException OutOfRangeException OuterIterator OverflowException ParentIterator ParseError RangeException RecursiveArrayIterator RecursiveCachingIterator RecursiveCallbackFilterIterator RecursiveDirectoryIterator RecursiveFilterIterator RecursiveIterator RecursiveIteratorIterator RecursiveRegexIterator RecursiveTreeIterator RegexIterator RuntimeException SeekableIterator SplDoublyLinkedList SplFileInfo SplFileObject SplFixedArray SplHeap SplMaxHeap SplMinHeap SplObjectStorage SplObserver SplObserver SplPriorityQueue SplQueue SplStack SplSubject SplSubject SplTempFileObject TypeError UnderflowException UnexpectedValueException UnhandledMatchError ArrayAccess Closure Generator Iterator IteratorAggregate Serializable Stringable Throwable Traversable WeakReference WeakMap Directory __PHP_Incomplete_Class parent php_user_filter self static stdClass"
      };
    return {
      aliases: ["php3", "php4", "php5", "php6", "php7", "php8"],
      case_insensitive: !0,
      keywords: J,
      contains: [A.HASH_COMMENT_MODE, A.COMMENT("//", "$", {
        contains: [Q]
      }), A.COMMENT("/\\*", "\\*/", {
        contains: [{
          className: "doctag",
          begin: "@[A-Za-z]+"
        }]
      }), A.COMMENT("__halt_compiler.+?;", !1, {
        endsWithParent: !0,
        keywords: "__halt_compiler"
      }), Q, {
        className: "keyword",
        begin: /\$this\b/
      }, B, {
        begin: /(::|->)+[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/
      }, {
        className: "function",
        relevance: 0,
        beginKeywords: "fn function",
        end: /[;{]/,
        excludeEnd: !0,
        illegal: "[$%\\[]",
        contains: [{
          beginKeywords: "use"
        }, A.UNDERSCORE_TITLE_MODE, {
          begin: "=>",
          endsParent: !0
        }, {
          className: "params",
          begin: "\\(",
          end: "\\)",
          excludeBegin: !0,
          excludeEnd: !0,
          keywords: J,
          contains: ["self", B, A.C_BLOCK_COMMENT_MODE, Y, W]
        }]
      }, {
        className: "class",
        variants: [{
          beginKeywords: "enum",
          illegal: /[($"]/
        }, {
          beginKeywords: "class interface trait",
          illegal: /[:($"]/
        }],
        relevance: 0,
        end: /\{/,
        excludeEnd: !0,
        contains: [{
          beginKeywords: "extends implements"
        }, A.UNDERSCORE_TITLE_MODE]
      }, {
        beginKeywords: "namespace",
        relevance: 0,
        end: ";",
        illegal: /[.']/,
        contains: [A.UNDERSCORE_TITLE_MODE]
      }, {
        beginKeywords: "use",
        relevance: 0,
        end: ";",
        contains: [A.UNDERSCORE_TITLE_MODE]
      }, Y, W]
    }
  }
  gyA.exports = sn9
})
// @from(Start 2046135, End 2046916)
dyA = z((R18, myA) => {
  function rn9(A) {
    return {
      name: "PHP template",
      subLanguage: "xml",
      contains: [{
        begin: /<\?(php|=)?/,
        end: /\?>/,
        subLanguage: "php",
        contains: [{
          begin: "/\\*",
          end: "\\*/",
          skip: !0
        }, {
          begin: 'b"',
          end: '"',
          skip: !0
        }, {
          begin: "b'",
          end: "'",
          skip: !0
        }, A.inherit(A.APOS_STRING_MODE, {
          illegal: null,
          className: null,
          contains: null,
          skip: !0
        }), A.inherit(A.QUOTE_STRING_MODE, {
          illegal: null,
          className: null,
          contains: null,
          skip: !0
        })]
      }]
    }
  }
  myA.exports = rn9
})
// @from(Start 2046922, End 2047097)
pyA = z((O18, uyA) => {
  function on9(A) {
    return {
      name: "Plain text",
      aliases: ["text", "txt"],
      disableAutodetect: !0
    }
  }
  uyA.exports = on9
})
// @from(Start 2047103, End 2048473)
lyA = z((T18, cyA) => {
  function tn9(A) {
    let B = {
        keyword: "actor addressof and as be break class compile_error compile_intrinsic consume continue delegate digestof do else elseif embed end error for fun if ifdef in interface is isnt lambda let match new not object or primitive recover repeat return struct then trait try type until use var where while with xor",
        meta: "iso val tag trn box ref",
        literal: "this false true"
      },
      Q = {
        className: "string",
        begin: '"""',
        end: '"""',
        relevance: 10
      },
      I = {
        className: "string",
        begin: '"',
        end: '"',
        contains: [A.BACKSLASH_ESCAPE]
      },
      G = {
        className: "string",
        begin: "'",
        end: "'",
        contains: [A.BACKSLASH_ESCAPE],
        relevance: 0
      },
      Z = {
        className: "type",
        begin: "\\b_?[A-Z][\\w]*",
        relevance: 0
      },
      D = {
        begin: A.IDENT_RE + "'",
        relevance: 0
      };
    return {
      name: "Pony",
      keywords: B,
      contains: [Z, Q, I, G, D, {
        className: "number",
        begin: "(-?)(\\b0[xX][a-fA-F0-9]+|\\b0[bB][01]+|(\\b\\d+(_\\d+)?(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",
        relevance: 0
      }, A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE]
    }
  }
  cyA.exports = tn9
})
// @from(Start 2048479, End 2054655)
nyA = z((P18, iyA) => {
  function en9(A) {
    let B = ["string", "char", "byte", "int", "long", "bool", "decimal", "single", "double", "DateTime", "xml", "array", "hashtable", "void"],
      Q = "Add|Clear|Close|Copy|Enter|Exit|Find|Format|Get|Hide|Join|Lock|Move|New|Open|Optimize|Pop|Push|Redo|Remove|Rename|Reset|Resize|Search|Select|Set|Show|Skip|Split|Step|Switch|Undo|Unlock|Watch|Backup|Checkpoint|Compare|Compress|Convert|ConvertFrom|ConvertTo|Dismount|Edit|Expand|Export|Group|Import|Initialize|Limit|Merge|Mount|Out|Publish|Restore|Save|Sync|Unpublish|Update|Approve|Assert|Build|Complete|Confirm|Deny|Deploy|Disable|Enable|Install|Invoke|Register|Request|Restart|Resume|Start|Stop|Submit|Suspend|Uninstall|Unregister|Wait|Debug|Measure|Ping|Repair|Resolve|Test|Trace|Connect|Disconnect|Read|Receive|Send|Write|Block|Grant|Protect|Revoke|Unblock|Unprotect|Use|ForEach|Sort|Tee|Where",
      I = "-and|-as|-band|-bnot|-bor|-bxor|-casesensitive|-ccontains|-ceq|-cge|-cgt|-cle|-clike|-clt|-cmatch|-cne|-cnotcontains|-cnotlike|-cnotmatch|-contains|-creplace|-csplit|-eq|-exact|-f|-file|-ge|-gt|-icontains|-ieq|-ige|-igt|-ile|-ilike|-ilt|-imatch|-in|-ine|-inotcontains|-inotlike|-inotmatch|-ireplace|-is|-isnot|-isplit|-join|-le|-like|-lt|-match|-ne|-not|-notcontains|-notin|-notlike|-notmatch|-or|-regex|-replace|-shl|-shr|-split|-wildcard|-xor",
      G = {
        $pattern: /-?[A-z\.\-]+\b/,
        keyword: "if else foreach return do while until elseif begin for trap data dynamicparam end break throw param continue finally in switch exit filter try process catch hidden static parameter",
        built_in: "ac asnp cat cd CFS chdir clc clear clhy cli clp cls clv cnsn compare copy cp cpi cpp curl cvpa dbp del diff dir dnsn ebp echo|0 epal epcsv epsn erase etsn exsn fc fhx fl ft fw gal gbp gc gcb gci gcm gcs gdr gerr ghy gi gin gjb gl gm gmo gp gps gpv group gsn gsnp gsv gtz gu gv gwmi h history icm iex ihy ii ipal ipcsv ipmo ipsn irm ise iwmi iwr kill lp ls man md measure mi mount move mp mv nal ndr ni nmo npssc nsn nv ogv oh popd ps pushd pwd r rbp rcjb rcsn rd rdr ren ri rjb rm rmdir rmo rni rnp rp rsn rsnp rujb rv rvpa rwmi sajb sal saps sasv sbp sc scb select set shcm si sl sleep sls sort sp spjb spps spsv start stz sujb sv swmi tee trcm type wget where wjb write"
      },
      Z = /\w[\w\d]*((-)[\w\d]+)*/,
      D = {
        begin: "`[\\s\\S]",
        relevance: 0
      },
      Y = {
        className: "variable",
        variants: [{
          begin: /\$\B/
        }, {
          className: "keyword",
          begin: /\$this/
        }, {
          begin: /\$[\w\d][\w\d_:]*/
        }]
      },
      W = {
        className: "literal",
        begin: /\$(null|true|false)\b/
      },
      J = {
        className: "string",
        variants: [{
          begin: /"/,
          end: /"/
        }, {
          begin: /@"/,
          end: /^"@/
        }],
        contains: [D, Y, {
          className: "variable",
          begin: /\$[A-z]/,
          end: /[^A-z]/
        }]
      },
      F = {
        className: "string",
        variants: [{
          begin: /'/,
          end: /'/
        }, {
          begin: /@'/,
          end: /^'@/
        }]
      },
      X = {
        className: "doctag",
        variants: [{
          begin: /\.(synopsis|description|example|inputs|outputs|notes|link|component|role|functionality)/
        }, {
          begin: /\.(parameter|forwardhelptargetname|forwardhelpcategory|remotehelprunspace|externalhelp)\s+\S+/
        }]
      },
      V = A.inherit(A.COMMENT(null, null), {
        variants: [{
          begin: /#/,
          end: /$/
        }, {
          begin: /<#/,
          end: /#>/
        }],
        contains: [X]
      }),
      C = {
        className: "built_in",
        variants: [{
          begin: "(".concat(Q, ")+(-)[\\w\\d]+")
        }]
      },
      K = {
        className: "class",
        beginKeywords: "class enum",
        end: /\s*[{]/,
        excludeEnd: !0,
        relevance: 0,
        contains: [A.TITLE_MODE]
      },
      E = {
        className: "function",
        begin: /function\s+/,
        end: /\s*\{|$/,
        excludeEnd: !0,
        returnBegin: !0,
        relevance: 0,
        contains: [{
          begin: "function",
          relevance: 0,
          className: "keyword"
        }, {
          className: "title",
          begin: Z,
          relevance: 0
        }, {
          begin: /\(/,
          end: /\)/,
          className: "params",
          relevance: 0,
          contains: [Y]
        }]
      },
      N = {
        begin: /using\s/,
        end: /$/,
        returnBegin: !0,
        contains: [J, F, {
          className: "keyword",
          begin: /(using|assembly|command|module|namespace|type)/
        }]
      },
      q = {
        variants: [{
          className: "operator",
          begin: "(".concat(I, ")\\b")
        }, {
          className: "literal",
          begin: /(-)[\w\d]+/,
          relevance: 0
        }]
      },
      O = {
        className: "selector-tag",
        begin: /@\B/,
        relevance: 0
      },
      R = {
        className: "function",
        begin: /\[.*\]\s*[\w]+[ ]??\(/,
        end: /$/,
        returnBegin: !0,
        relevance: 0,
        contains: [{
          className: "keyword",
          begin: "(".concat(G.keyword.toString().replace(/\s/g, "|"), ")\\b"),
          endsParent: !0,
          relevance: 0
        }, A.inherit(A.TITLE_MODE, {
          endsParent: !0
        })]
      },
      T = [R, V, D, A.NUMBER_MODE, J, F, C, Y, W, O],
      L = {
        begin: /\[/,
        end: /\]/,
        excludeBegin: !0,
        excludeEnd: !0,
        relevance: 0,
        contains: [].concat("self", T, {
          begin: "(" + B.join("|") + ")",
          className: "built_in",
          relevance: 0
        }, {
          className: "type",
          begin: /[\.\w\d]+/,
          relevance: 0
        })
      };
    return R.contains.unshift(L), {
      name: "PowerShell",
      aliases: ["ps", "ps1"],
      case_insensitive: !0,
      keywords: G,
      contains: T.concat(K, E, N, q, L)
    }
  }
  iyA.exports = en9
})
// @from(Start 2054661, End 2057871)
syA = z((S18, ayA) => {
  function Aa9(A) {
    return {
      name: "Processing",
      keywords: {
        keyword: "BufferedReader PVector PFont PImage PGraphics HashMap boolean byte char color double float int long String Array FloatDict FloatList IntDict IntList JSONArray JSONObject Object StringDict StringList Table TableRow XML false synchronized int abstract float private char boolean static null if const for true while long throw strictfp finally protected import native final return void enum else break transient new catch instanceof byte super volatile case assert short package default double public try this switch continue throws protected public private",
        literal: "P2D P3D HALF_PI PI QUARTER_PI TAU TWO_PI",
        title: "setup draw",
        built_in: "displayHeight displayWidth mouseY mouseX mousePressed pmouseX pmouseY key keyCode pixels focused frameCount frameRate height width size createGraphics beginDraw createShape loadShape PShape arc ellipse line point quad rect triangle bezier bezierDetail bezierPoint bezierTangent curve curveDetail curvePoint curveTangent curveTightness shape shapeMode beginContour beginShape bezierVertex curveVertex endContour endShape quadraticVertex vertex ellipseMode noSmooth rectMode smooth strokeCap strokeJoin strokeWeight mouseClicked mouseDragged mouseMoved mousePressed mouseReleased mouseWheel keyPressed keyPressedkeyReleased keyTyped print println save saveFrame day hour millis minute month second year background clear colorMode fill noFill noStroke stroke alpha blue brightness color green hue lerpColor red saturation modelX modelY modelZ screenX screenY screenZ ambient emissive shininess specular add createImage beginCamera camera endCamera frustum ortho perspective printCamera printProjection cursor frameRate noCursor exit loop noLoop popStyle pushStyle redraw binary boolean byte char float hex int str unbinary unhex join match matchAll nf nfc nfp nfs split splitTokens trim append arrayCopy concat expand reverse shorten sort splice subset box sphere sphereDetail createInput createReader loadBytes loadJSONArray loadJSONObject loadStrings loadTable loadXML open parseXML saveTable selectFolder selectInput beginRaw beginRecord createOutput createWriter endRaw endRecord PrintWritersaveBytes saveJSONArray saveJSONObject saveStream saveStrings saveXML selectOutput popMatrix printMatrix pushMatrix resetMatrix rotate rotateX rotateY rotateZ scale shearX shearY translate ambientLight directionalLight lightFalloff lights lightSpecular noLights normal pointLight spotLight image imageMode loadImage noTint requestImage tint texture textureMode textureWrap blend copy filter get loadPixels set updatePixels blendMode loadShader PShaderresetShader shader createFont loadFont text textFont textAlign textLeading textMode textSize textWidth textAscent textDescent abs ceil constrain dist exp floor lerp log mag map max min norm pow round sq sqrt acos asin atan atan2 cos degrees radians sin tan noise noiseDetail noiseSeed random randomGaussian randomSeed"
      },
      contains: [A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, A.APOS_STRING_MODE, A.QUOTE_STRING_MODE, A.C_NUMBER_MODE]
    }
  }
  ayA.exports = Aa9
})
// @from(Start 2057877, End 2058613)
oyA = z((_18, ryA) => {
  function Ba9(A) {
    return {
      name: "Python profiler",
      contains: [A.C_NUMBER_MODE, {
        begin: "[a-zA-Z_][\\da-zA-Z_]+\\.[\\da-zA-Z_]{1,3}",
        end: ":",
        excludeEnd: !0
      }, {
        begin: "(ncalls|tottime|cumtime)",
        end: "$",
        keywords: "ncalls tottime|10 cumtime|10 filename",
        relevance: 10
      }, {
        begin: "function calls",
        end: "$",
        contains: [A.C_NUMBER_MODE],
        relevance: 10
      }, A.APOS_STRING_MODE, A.QUOTE_STRING_MODE, {
        className: "string",
        begin: "\\(",
        end: "\\)$",
        excludeBegin: !0,
        excludeEnd: !0,
        relevance: 0
      }]
    }
  }
  ryA.exports = Ba9
})
// @from(Start 2058619, End 2059789)
eyA = z((j18, tyA) => {
  function Qa9(A) {
    let B = {
        begin: /[a-z][A-Za-z0-9_]*/,
        relevance: 0
      },
      Q = {
        className: "symbol",
        variants: [{
          begin: /[A-Z][a-zA-Z0-9_]*/
        }, {
          begin: /_[A-Za-z0-9_]*/
        }],
        relevance: 0
      },
      I = {
        begin: /\(/,
        end: /\)/,
        relevance: 0
      },
      G = {
        begin: /\[/,
        end: /\]/
      },
      Z = {
        className: "comment",
        begin: /%/,
        end: /$/,
        contains: [A.PHRASAL_WORDS_MODE]
      },
      D = {
        className: "string",
        begin: /`/,
        end: /`/,
        contains: [A.BACKSLASH_ESCAPE]
      },
      Y = {
        className: "string",
        begin: /0'(\\'|.)/
      },
      W = {
        className: "string",
        begin: /0'\\s/
      },
      F = [B, Q, I, {
        begin: /:-/
      }, G, Z, A.C_BLOCK_COMMENT_MODE, A.QUOTE_STRING_MODE, A.APOS_STRING_MODE, D, Y, W, A.C_NUMBER_MODE];
    return I.contains = F, G.contains = F, {
      name: "Prolog",
      contains: F.concat([{
        begin: /\.$/
      }])
    }
  }
  tyA.exports = Qa9
})
// @from(Start 2059795, End 2061130)
BkA = z((y18, AkA) => {
  function Ia9(A) {
    var B = "[ \\t\\f]*",
      Q = "[ \\t\\f]+",
      I = B + "[:=]" + B,
      G = Q,
      Z = "(" + I + "|" + G + ")",
      D = "([^\\\\\\W:= \\t\\f\\n]|\\\\.)+",
      Y = "([^\\\\:= \\t\\f\\n]|\\\\.)+",
      W = {
        end: Z,
        relevance: 0,
        starts: {
          className: "string",
          end: /$/,
          relevance: 0,
          contains: [{
            begin: "\\\\\\\\"
          }, {
            begin: "\\\\\\n"
          }]
        }
      };
    return {
      name: ".properties",
      case_insensitive: !0,
      illegal: /\S/,
      contains: [A.COMMENT("^\\s*[!#]", "$"), {
        returnBegin: !0,
        variants: [{
          begin: D + I,
          relevance: 1
        }, {
          begin: D + G,
          relevance: 0
        }],
        contains: [{
          className: "attr",
          begin: D,
          endsParent: !0,
          relevance: 0
        }],
        starts: W
      }, {
        begin: Y + Z,
        returnBegin: !0,
        relevance: 0,
        contains: [{
          className: "meta",
          begin: Y,
          endsParent: !0,
          relevance: 0
        }],
        starts: W
      }, {
        className: "attr",
        relevance: 0,
        begin: Y + B + "$"
      }]
    }
  }
  AkA.exports = Ia9
})
// @from(Start 2061136, End 2062102)
IkA = z((k18, QkA) => {
  function Ga9(A) {
    return {
      name: "Protocol Buffers",
      keywords: {
        keyword: "package import option optional required repeated group oneof",
        built_in: "double float int32 int64 uint32 uint64 sint32 sint64 fixed32 fixed64 sfixed32 sfixed64 bool string bytes",
        literal: "true false"
      },
      contains: [A.QUOTE_STRING_MODE, A.NUMBER_MODE, A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, {
        className: "class",
        beginKeywords: "message enum service",
        end: /\{/,
        illegal: /\n/,
        contains: [A.inherit(A.TITLE_MODE, {
          starts: {
            endsWithParent: !0,
            excludeEnd: !0
          }
        })]
      }, {
        className: "function",
        beginKeywords: "rpc",
        end: /[{;]/,
        excludeEnd: !0,
        keywords: "rpc returns"
      }, {
        begin: /^\s*[A-Z_]+(?=\s*=[^\n]+;$)/
      }]
    }
  }
  QkA.exports = Ga9
})
// @from(Start 2062108, End 2066986)
ZkA = z((x18, GkA) => {
  function Za9(A) {
    let B = {
        keyword: "and case default else elsif false if in import enherits node or true undef unless main settings $string ",
        literal: "alias audit before loglevel noop require subscribe tag owner ensure group mode name|0 changes context force incl lens load_path onlyif provider returns root show_diff type_check en_address ip_address realname command environment hour monute month monthday special target weekday creates cwd ogoutput refresh refreshonly tries try_sleep umask backup checksum content ctime force ignore links mtime purge recurse recurselimit replace selinux_ignore_defaults selrange selrole seltype seluser source souirce_permissions sourceselect validate_cmd validate_replacement allowdupe attribute_membership auth_membership forcelocal gid ia_load_module members system host_aliases ip allowed_trunk_vlans description device_url duplex encapsulation etherchannel native_vlan speed principals allow_root auth_class auth_type authenticate_user k_of_n mechanisms rule session_owner shared options device fstype enable hasrestart directory present absent link atboot blockdevice device dump pass remounts poller_tag use message withpath adminfile allow_virtual allowcdrom category configfiles flavor install_options instance package_settings platform responsefile status uninstall_options vendor unless_system_user unless_uid binary control flags hasstatus manifest pattern restart running start stop allowdupe auths expiry gid groups home iterations key_membership keys managehome membership password password_max_age password_min_age profile_membership profiles project purge_ssh_keys role_membership roles salt shell uid baseurl cost descr enabled enablegroups exclude failovermethod gpgcheck gpgkey http_caching include includepkgs keepalive metadata_expire metalink mirrorlist priority protect proxy proxy_password proxy_username repo_gpgcheck s3_enabled skip_if_unavailable sslcacert sslclientcert sslclientkey sslverify mounted",
        built_in: "architecture augeasversion blockdevices boardmanufacturer boardproductname boardserialnumber cfkey dhcp_servers domain ec2_ ec2_userdata facterversion filesystems ldom fqdn gid hardwareisa hardwaremodel hostname id|0 interfaces ipaddress ipaddress_ ipaddress6 ipaddress6_ iphostnumber is_virtual kernel kernelmajversion kernelrelease kernelversion kernelrelease kernelversion lsbdistcodename lsbdistdescription lsbdistid lsbdistrelease lsbmajdistrelease lsbminordistrelease lsbrelease macaddress macaddress_ macosx_buildversion macosx_productname macosx_productversion macosx_productverson_major macosx_productversion_minor manufacturer memoryfree memorysize netmask metmask_ network_ operatingsystem operatingsystemmajrelease operatingsystemrelease osfamily partitions path physicalprocessorcount processor processorcount productname ps puppetversion rubysitedir rubyversion selinux selinux_config_mode selinux_config_policy selinux_current_mode selinux_current_mode selinux_enforced selinux_policyversion serialnumber sp_ sshdsakey sshecdsakey sshrsakey swapencrypted swapfree swapsize timezone type uniqueid uptime uptime_days uptime_hours uptime_seconds uuid virtual vlans xendomains zfs_version zonenae zones zpool_version"
      },
      Q = A.COMMENT("#", "$"),
      I = "([A-Za-z_]|::)(\\w|::)*",
      G = A.inherit(A.TITLE_MODE, {
        begin: "([A-Za-z_]|::)(\\w|::)*"
      }),
      Z = {
        className: "variable",
        begin: "\\$([A-Za-z_]|::)(\\w|::)*"
      },
      D = {
        className: "string",
        contains: [A.BACKSLASH_ESCAPE, Z],
        variants: [{
          begin: /'/,
          end: /'/
        }, {
          begin: /"/,
          end: /"/
        }]
      };
    return {
      name: "Puppet",
      aliases: ["pp"],
      contains: [Q, Z, D, {
        beginKeywords: "class",
        end: "\\{|;",
        illegal: /=/,
        contains: [G, Q]
      }, {
        beginKeywords: "define",
        end: /\{/,
        contains: [{
          className: "section",
          begin: A.IDENT_RE,
          endsParent: !0
        }]
      }, {
        begin: A.IDENT_RE + "\\s+\\{",
        returnBegin: !0,
        end: /\S/,
        contains: [{
          className: "keyword",
          begin: A.IDENT_RE
        }, {
          begin: /\{/,
          end: /\}/,
          keywords: B,
          relevance: 0,
          contains: [D, Q, {
            begin: "[a-zA-Z_]+\\s*=>",
            returnBegin: !0,
            end: "=>",
            contains: [{
              className: "attr",
              begin: A.IDENT_RE
            }]
          }, {
            className: "number",
            begin: "(\\b0[0-7_]+)|(\\b0x[0-9a-fA-F_]+)|(\\b[1-9][0-9_]*(\\.[0-9_]+)?)|[0_]\\b",
            relevance: 0
          }, Z]
        }],
        relevance: 0
      }]
    }
  }
  GkA.exports = Za9
})
// @from(Start 2066992, End 2068905)
YkA = z((f18, DkA) => {
  function Da9(A) {
    let B = {
        className: "string",
        begin: '(~)?"',
        end: '"',
        illegal: "\\n"
      },
      Q = {
        className: "symbol",
        begin: "#[a-zA-Z_]\\w*\\$?"
      };
    return {
      name: "PureBASIC",
      aliases: ["pb", "pbi"],
      keywords: "Align And Array As Break CallDebugger Case CompilerCase CompilerDefault CompilerElse CompilerElseIf CompilerEndIf CompilerEndSelect CompilerError CompilerIf CompilerSelect CompilerWarning Continue Data DataSection Debug DebugLevel Declare DeclareC DeclareCDLL DeclareDLL DeclareModule Default Define Dim DisableASM DisableDebugger DisableExplicit Else ElseIf EnableASM EnableDebugger EnableExplicit End EndDataSection EndDeclareModule EndEnumeration EndIf EndImport EndInterface EndMacro EndModule EndProcedure EndSelect EndStructure EndStructureUnion EndWith Enumeration EnumerationBinary Extends FakeReturn For ForEach ForEver Global Gosub Goto If Import ImportC IncludeBinary IncludeFile IncludePath Interface List Macro MacroExpandedCount Map Module NewList NewMap Next Not Or Procedure ProcedureC ProcedureCDLL ProcedureDLL ProcedureReturn Protected Prototype PrototypeC ReDim Read Repeat Restore Return Runtime Select Shared Static Step Structure StructureUnion Swap Threaded To UndefineMacro Until Until  UnuseModule UseModule Wend While With XIncludeFile XOr",
      contains: [A.COMMENT(";", "$", {
        relevance: 0
      }), {
        className: "function",
        begin: "\\b(Procedure|Declare)(C|CDLL|DLL)?\\b",
        end: "\\(",
        excludeEnd: !0,
        returnBegin: !0,
        contains: [{
          className: "keyword",
          begin: "(Procedure|Declare)(C|CDLL|DLL)?",
          excludeEnd: !0
        }, {
          className: "type",
          begin: "\\.\\w*"
        }, A.UNDERSCORE_TITLE_MODE]
      }, B, Q]
    }
  }
  DkA.exports = Da9
})
// @from(Start 2068911, End 2074258)
JkA = z((v18, WkA) => {
  function Ya9(A) {
    if (!A) return null;
    if (typeof A === "string") return A;
    return A.source
  }

  function Wa9(A) {
    return Ja9("(?=", A, ")")
  }

  function Ja9(...A) {
    return A.map((Q) => Ya9(Q)).join("")
  }

  function Fa9(A) {
    let Z = {
        $pattern: /[A-Za-z]\w+|__\w+__/,
        keyword: ["and", "as", "assert", "async", "await", "break", "class", "continue", "def", "del", "elif", "else", "except", "finally", "for", "from", "global", "if", "import", "in", "is", "lambda", "nonlocal|10", "not", "or", "pass", "raise", "return", "try", "while", "with", "yield"],
        built_in: ["__import__", "abs", "all", "any", "ascii", "bin", "bool", "breakpoint", "bytearray", "bytes", "callable", "chr", "classmethod", "compile", "complex", "delattr", "dict", "dir", "divmod", "enumerate", "eval", "exec", "filter", "float", "format", "frozenset", "getattr", "globals", "hasattr", "hash", "help", "hex", "id", "input", "int", "isinstance", "issubclass", "iter", "len", "list", "locals", "map", "max", "memoryview", "min", "next", "object", "oct", "open", "ord", "pow", "print", "property", "range", "repr", "reversed", "round", "set", "setattr", "slice", "sorted", "staticmethod", "str", "sum", "super", "tuple", "type", "vars", "zip"],
        literal: ["__debug__", "Ellipsis", "False", "None", "NotImplemented", "True"],
        type: ["Any", "Callable", "Coroutine", "Dict", "List", "Literal", "Generic", "Optional", "Sequence", "Set", "Tuple", "Type", "Union"]
      },
      D = {
        className: "meta",
        begin: /^(>>>|\.\.\.) /
      },
      Y = {
        className: "subst",
        begin: /\{/,
        end: /\}/,
        keywords: Z,
        illegal: /#/
      },
      W = {
        begin: /\{\{/,
        relevance: 0
      },
      J = {
        className: "string",
        contains: [A.BACKSLASH_ESCAPE],
        variants: [{
          begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,
          end: /'''/,
          contains: [A.BACKSLASH_ESCAPE, D],
          relevance: 10
        }, {
          begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,
          end: /"""/,
          contains: [A.BACKSLASH_ESCAPE, D],
          relevance: 10
        }, {
          begin: /([fF][rR]|[rR][fF]|[fF])'''/,
          end: /'''/,
          contains: [A.BACKSLASH_ESCAPE, D, W, Y]
        }, {
          begin: /([fF][rR]|[rR][fF]|[fF])"""/,
          end: /"""/,
          contains: [A.BACKSLASH_ESCAPE, D, W, Y]
        }, {
          begin: /([uU]|[rR])'/,
          end: /'/,
          relevance: 10
        }, {
          begin: /([uU]|[rR])"/,
          end: /"/,
          relevance: 10
        }, {
          begin: /([bB]|[bB][rR]|[rR][bB])'/,
          end: /'/
        }, {
          begin: /([bB]|[bB][rR]|[rR][bB])"/,
          end: /"/
        }, {
          begin: /([fF][rR]|[rR][fF]|[fF])'/,
          end: /'/,
          contains: [A.BACKSLASH_ESCAPE, W, Y]
        }, {
          begin: /([fF][rR]|[rR][fF]|[fF])"/,
          end: /"/,
          contains: [A.BACKSLASH_ESCAPE, W, Y]
        }, A.APOS_STRING_MODE, A.QUOTE_STRING_MODE]
      },
      F = "[0-9](_?[0-9])*",
      X = "(\\b([0-9](_?[0-9])*))?\\.([0-9](_?[0-9])*)|\\b([0-9](_?[0-9])*)\\.",
      V = {
        className: "number",
        relevance: 0,
        variants: [{
          begin: "(\\b([0-9](_?[0-9])*)|((\\b([0-9](_?[0-9])*))?\\.([0-9](_?[0-9])*)|\\b([0-9](_?[0-9])*)\\.))[eE][+-]?([0-9](_?[0-9])*)[jJ]?\\b"
        }, {
          begin: "((\\b([0-9](_?[0-9])*))?\\.([0-9](_?[0-9])*)|\\b([0-9](_?[0-9])*)\\.)[jJ]?"
        }, {
          begin: "\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?\\b"
        }, {
          begin: "\\b0[bB](_?[01])+[lL]?\\b"
        }, {
          begin: "\\b0[oO](_?[0-7])+[lL]?\\b"
        }, {
          begin: "\\b0[xX](_?[0-9a-fA-F])+[lL]?\\b"
        }, {
          begin: "\\b([0-9](_?[0-9])*)[jJ]\\b"
        }]
      },
      C = {
        className: "comment",
        begin: Wa9(/# type:/),
        end: /$/,
        keywords: Z,
        contains: [{
          begin: /# type:/
        }, {
          begin: /#/,
          end: /\b\B/,
          endsWithParent: !0
        }]
      },
      K = {
        className: "params",
        variants: [{
          className: "",
          begin: /\(\s*\)/,
          skip: !0
        }, {
          begin: /\(/,
          end: /\)/,
          excludeBegin: !0,
          excludeEnd: !0,
          keywords: Z,
          contains: ["self", D, V, J, A.HASH_COMMENT_MODE]
        }]
      };
    return Y.contains = [J, V, D], {
      name: "Python",
      aliases: ["py", "gyp", "ipython"],
      keywords: Z,
      illegal: /(<\/|->|\?)|=>/,
      contains: [D, V, {
        begin: /\bself\b/
      }, {
        beginKeywords: "if",
        relevance: 0
      }, J, C, A.HASH_COMMENT_MODE, {
        variants: [{
          className: "function",
          beginKeywords: "def"
        }, {
          className: "class",
          beginKeywords: "class"
        }],
        end: /:/,
        illegal: /[${=;\n,]/,
        contains: [A.UNDERSCORE_TITLE_MODE, K, {
          begin: /->/,
          endsWithParent: !0,
          keywords: Z
        }]
      }, {
        className: "meta",
        begin: /^[\t ]*@/,
        end: /(?=#)|$/,
        contains: [V, K, J]
      }]
    }
  }
  WkA.exports = Fa9
})
// @from(Start 2074264, End 2074687)
XkA = z((b18, FkA) => {
  function Xa9(A) {
    return {
      aliases: ["pycon"],
      contains: [{
        className: "meta",
        starts: {
          end: / |$/,
          starts: {
            end: "$",
            subLanguage: "python"
          }
        },
        variants: [{
          begin: /^>>>(?=[ ]|$)/
        }, {
          begin: /^\.\.\.(?=[ ]|$)/
        }]
      }]
    }
  }
  FkA.exports = Xa9
})
// @from(Start 2074693, End 2075957)
CkA = z((g18, VkA) => {
  function Va9(A) {
    return {
      name: "Q",
      aliases: ["k", "kdb"],
      keywords: {
        $pattern: /(`?)[A-Za-z0-9_]+\b/,
        keyword: "do while select delete by update from",
        literal: "0b 1b",
        built_in: "neg not null string reciprocal floor ceiling signum mod xbar xlog and or each scan over prior mmu lsq inv md5 ltime gtime count first var dev med cov cor all any rand sums prds mins maxs fills deltas ratios avgs differ prev next rank reverse iasc idesc asc desc msum mcount mavg mdev xrank mmin mmax xprev rotate distinct group where flip type key til get value attr cut set upsert raze union inter except cross sv vs sublist enlist read0 read1 hopen hclose hdel hsym hcount peach system ltrim rtrim trim lower upper ssr view tables views cols xcols keys xkey xcol xasc xdesc fkeys meta lj aj aj0 ij pj asof uj ww wj wj1 fby xgroup ungroup ej save load rsave rload show csv parse eval min max avg wavg wsum sin cos tan sum",
        type: "`float `double int `timestamp `timespan `datetime `time `boolean `symbol `char `byte `short `long `real `month `date `minute `second `guid"
      },
      contains: [A.C_LINE_COMMENT_MODE, A.QUOTE_STRING_MODE, A.C_NUMBER_MODE]
    }
  }
  VkA.exports = Va9
})
// @from(Start 2075963, End 2080103)
HkA = z((h18, KkA) => {
  function Ca9(A) {
    if (!A) return null;
    if (typeof A === "string") return A;
    return A.source
  }

  function Ka9(...A) {
    return A.map((Q) => Ca9(Q)).join("")
  }

  function Ha9(A) {
    let B = {
        keyword: "in of on if for while finally var new function do return void else break catch instanceof with throw case default try this switch continue typeof delete let yield const export super debugger as async await import",
        literal: "true false null undefined NaN Infinity",
        built_in: "eval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Error EvalError InternalError RangeError ReferenceError StopIteration SyntaxError TypeError URIError Number Math Date String RegExp Array Float32Array Float64Array Int16Array Int32Array Int8Array Uint16Array Uint32Array Uint8Array Uint8ClampedArray ArrayBuffer DataView JSON Intl arguments require module console window document Symbol Set Map WeakSet WeakMap Proxy Reflect Behavior bool color coordinate date double enumeration font geocircle georectangle geoshape int list matrix4x4 parent point quaternion real rect size string url variant vector2d vector3d vector4d Promise"
      },
      Q = "[a-zA-Z_][a-zA-Z0-9\\._]*",
      I = {
        className: "keyword",
        begin: "\\bproperty\\b",
        starts: {
          className: "string",
          end: "(:|=|;|,|//|/\\*|$)",
          returnEnd: !0
        }
      },
      G = {
        className: "keyword",
        begin: "\\bsignal\\b",
        starts: {
          className: "string",
          end: "(\\(|:|=|;|,|//|/\\*|$)",
          returnEnd: !0
        }
      },
      Z = {
        className: "attribute",
        begin: "\\bid\\s*:",
        starts: {
          className: "string",
          end: "[a-zA-Z_][a-zA-Z0-9\\._]*",
          returnEnd: !1
        }
      },
      D = {
        begin: "[a-zA-Z_][a-zA-Z0-9\\._]*\\s*:",
        returnBegin: !0,
        contains: [{
          className: "attribute",
          begin: "[a-zA-Z_][a-zA-Z0-9\\._]*",
          end: "\\s*:",
          excludeEnd: !0,
          relevance: 0
        }],
        relevance: 0
      },
      Y = {
        begin: Ka9("[a-zA-Z_][a-zA-Z0-9\\._]*", /\s*\{/),
        end: /\{/,
        returnBegin: !0,
        relevance: 0,
        contains: [A.inherit(A.TITLE_MODE, {
          begin: "[a-zA-Z_][a-zA-Z0-9\\._]*"
        })]
      };
    return {
      name: "QML",
      aliases: ["qt"],
      case_insensitive: !1,
      keywords: B,
      contains: [{
        className: "meta",
        begin: /^\s*['"]use (strict|asm)['"]/
      }, A.APOS_STRING_MODE, A.QUOTE_STRING_MODE, {
        className: "string",
        begin: "`",
        end: "`",
        contains: [A.BACKSLASH_ESCAPE, {
          className: "subst",
          begin: "\\$\\{",
          end: "\\}"
        }]
      }, A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, {
        className: "number",
        variants: [{
          begin: "\\b(0[bB][01]+)"
        }, {
          begin: "\\b(0[oO][0-7]+)"
        }, {
          begin: A.C_NUMBER_RE
        }],
        relevance: 0
      }, {
        begin: "(" + A.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
        keywords: "return throw case",
        contains: [A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, A.REGEXP_MODE, {
          begin: /</,
          end: />\s*[);\]]/,
          relevance: 0,
          subLanguage: "xml"
        }],
        relevance: 0
      }, G, I, {
        className: "function",
        beginKeywords: "function",
        end: /\{/,
        excludeEnd: !0,
        contains: [A.inherit(A.TITLE_MODE, {
          begin: /[A-Za-z$_][0-9A-Za-z$_]*/
        }), {
          className: "params",
          begin: /\(/,
          end: /\)/,
          excludeBegin: !0,
          excludeEnd: !0,
          contains: [A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE]
        }],
        illegal: /\[|%/
      }, {
        begin: "\\." + A.IDENT_RE,
        relevance: 0
      }, Z, D, Y],
      illegal: /#/
    }
  }
  KkA.exports = Ha9
})
// @from(Start 2080109, End 2084603)
wkA = z((m18, zkA) => {
  function za9(A) {
    if (!A) return null;
    if (typeof A === "string") return A;
    return A.source
  }

  function wa9(A) {
    return uT1("(?=", A, ")")
  }

  function uT1(...A) {
    return A.map((Q) => za9(Q)).join("")
  }

  function Ea9(A) {
    let B = /(?:(?:[a-zA-Z]|\.[._a-zA-Z])[._a-zA-Z0-9]*)|\.(?!\d)/,
      Q = /[a-zA-Z][a-zA-Z_0-9]*/;
    return {
      name: "R",
      illegal: /->/,
      keywords: {
        $pattern: B,
        keyword: "function if in break next repeat else for while",
        literal: "NULL NA TRUE FALSE Inf NaN NA_integer_|10 NA_real_|10 NA_character_|10 NA_complex_|10",
        built_in: "LETTERS letters month.abb month.name pi T F abs acos acosh all any anyNA Arg as.call as.character as.complex as.double as.environment as.integer as.logical as.null.default as.numeric as.raw asin asinh atan atanh attr attributes baseenv browser c call ceiling class Conj cos cosh cospi cummax cummin cumprod cumsum digamma dim dimnames emptyenv exp expression floor forceAndCall gamma gc.time globalenv Im interactive invisible is.array is.atomic is.call is.character is.complex is.double is.environment is.expression is.finite is.function is.infinite is.integer is.language is.list is.logical is.matrix is.na is.name is.nan is.null is.numeric is.object is.pairlist is.raw is.recursive is.single is.symbol lazyLoadDBfetch length lgamma list log max min missing Mod names nargs nzchar oldClass on.exit pos.to.env proc.time prod quote range Re rep retracemem return round seq_along seq_len seq.int sign signif sin sinh sinpi sqrt standardGeneric substitute sum switch tan tanh tanpi tracemem trigamma trunc unclass untracemem UseMethod xtfrm"
      },
      compilerExtensions: [(I, G) => {
        if (!I.beforeMatch) return;
        if (I.starts) throw new Error("beforeMatch cannot be used with starts");
        let Z = Object.assign({}, I);
        Object.keys(I).forEach((D) => {
          delete I[D]
        }), I.begin = uT1(Z.beforeMatch, wa9(Z.begin)), I.starts = {
          relevance: 0,
          contains: [Object.assign(Z, {
            endsParent: !0
          })]
        }, I.relevance = 0, delete Z.beforeMatch
      }],
      contains: [A.COMMENT(/#'/, /$/, {
        contains: [{
          className: "doctag",
          begin: "@examples",
          starts: {
            contains: [{
              begin: /\n/
            }, {
              begin: /#'\s*(?=@[a-zA-Z]+)/,
              endsParent: !0
            }, {
              begin: /#'/,
              end: /$/,
              excludeBegin: !0
            }]
          }
        }, {
          className: "doctag",
          begin: "@param",
          end: /$/,
          contains: [{
            className: "variable",
            variants: [{
              begin: B
            }, {
              begin: /`(?:\\.|[^`\\])+`/
            }],
            endsParent: !0
          }]
        }, {
          className: "doctag",
          begin: /@[a-zA-Z]+/
        }, {
          className: "meta-keyword",
          begin: /\\[a-zA-Z]+/
        }]
      }), A.HASH_COMMENT_MODE, {
        className: "string",
        contains: [A.BACKSLASH_ESCAPE],
        variants: [A.END_SAME_AS_BEGIN({
          begin: /[rR]"(-*)\(/,
          end: /\)(-*)"/
        }), A.END_SAME_AS_BEGIN({
          begin: /[rR]"(-*)\{/,
          end: /\}(-*)"/
        }), A.END_SAME_AS_BEGIN({
          begin: /[rR]"(-*)\[/,
          end: /\](-*)"/
        }), A.END_SAME_AS_BEGIN({
          begin: /[rR]'(-*)\(/,
          end: /\)(-*)'/
        }), A.END_SAME_AS_BEGIN({
          begin: /[rR]'(-*)\{/,
          end: /\}(-*)'/
        }), A.END_SAME_AS_BEGIN({
          begin: /[rR]'(-*)\[/,
          end: /\](-*)'/
        }), {
          begin: '"',
          end: '"',
          relevance: 0
        }, {
          begin: "'",
          end: "'",
          relevance: 0
        }]
      }, {
        className: "number",
        relevance: 0,
        beforeMatch: /([^a-zA-Z0-9._])/,
        variants: [{
          match: /0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*[pP][+-]?\d+i?/
        }, {
          match: /0[xX][0-9a-fA-F]+([pP][+-]?\d+)?[Li]?/
        }, {
          match: /(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?[Li]?/
        }]
      }, {
        begin: "%",
        end: "%"
      }, {
        begin: uT1(Q, "\\s+<-\\s+")
      }, {
        begin: "`",
        end: "`",
        contains: [{
          begin: /\\./
        }]
      }]
    }
  }
  zkA.exports = Ea9
})
// @from(Start 2084609, End 2090068)
UkA = z((d18, EkA) => {
  function Ua9(A) {
    function B(L) {
      return L.map(function(_) {
        return _.split("").map(function(k) {
          return "\\" + k
        }).join("")
      }).join("|")
    }
    let Q = "~?[a-z$_][0-9a-zA-Z$_]*",
      I = "`?[A-Z$_][0-9a-zA-Z$_]*",
      G = "'?[a-z$_][0-9a-z$_]*",
      Z = "\\s*:\\s*[a-z$_][0-9a-z$_]*(\\(\\s*(" + G + "\\s*(," + G + "\\s*)*)?\\))?",
      D = Q + "(" + Z + "){0,2}",
      Y = "(" + B(["||", "++", "**", "+.", "*", "/", "*.", "/.", "..."]) + "|\\|>|&&|==|===)",
      W = "\\s+" + Y + "\\s+",
      J = {
        keyword: "and as asr assert begin class constraint do done downto else end exception external for fun function functor if in include inherit initializer land lazy let lor lsl lsr lxor match method mod module mutable new nonrec object of open or private rec sig struct then to try type val virtual when while with",
        built_in: "array bool bytes char exn|5 float int int32 int64 list lazy_t|5 nativeint|5 ref string unit ",
        literal: "true false"
      },
      F = "\\b(0[xX][a-fA-F0-9_]+[Lln]?|0[oO][0-7_]+[Lln]?|0[bB][01_]+[Lln]?|[0-9][0-9_]*([Lln]|(\\.[0-9_]*)?([eE][-+]?[0-9_]+)?)?)",
      X = {
        className: "number",
        relevance: 0,
        variants: [{
          begin: F
        }, {
          begin: "\\(-" + F + "\\)"
        }]
      },
      V = {
        className: "operator",
        relevance: 0,
        begin: Y
      },
      C = [{
        className: "identifier",
        relevance: 0,
        begin: Q
      }, V, X],
      K = [A.QUOTE_STRING_MODE, V, {
        className: "module",
        begin: "\\b" + I,
        returnBegin: !0,
        end: ".",
        contains: [{
          className: "identifier",
          begin: I,
          relevance: 0
        }]
      }],
      E = [{
        className: "module",
        begin: "\\b" + I,
        returnBegin: !0,
        end: ".",
        relevance: 0,
        contains: [{
          className: "identifier",
          begin: I,
          relevance: 0
        }]
      }],
      N = {
        begin: Q,
        end: "(,|\\n|\\))",
        relevance: 0,
        contains: [V, {
          className: "typing",
          begin: ":",
          end: "(,|\\n)",
          returnBegin: !0,
          relevance: 0,
          contains: E
        }]
      },
      q = {
        className: "function",
        relevance: 0,
        keywords: J,
        variants: [{
          begin: "\\s(\\(\\.?.*?\\)|" + Q + ")\\s*=>",
          end: "\\s*=>",
          returnBegin: !0,
          relevance: 0,
          contains: [{
            className: "params",
            variants: [{
              begin: Q
            }, {
              begin: D
            }, {
              begin: /\(\s*\)/
            }]
          }]
        }, {
          begin: "\\s\\(\\.?[^;\\|]*\\)\\s*=>",
          end: "\\s=>",
          returnBegin: !0,
          relevance: 0,
          contains: [{
            className: "params",
            relevance: 0,
            variants: [N]
          }]
        }, {
          begin: "\\(\\.\\s" + Q + "\\)\\s*=>"
        }]
      };
    K.push(q);
    let O = {
        className: "constructor",
        begin: I + "\\(",
        end: "\\)",
        illegal: "\\n",
        keywords: J,
        contains: [A.QUOTE_STRING_MODE, V, {
          className: "params",
          begin: "\\b" + Q
        }]
      },
      R = {
        className: "pattern-match",
        begin: "\\|",
        returnBegin: !0,
        keywords: J,
        end: "=>",
        relevance: 0,
        contains: [O, V, {
          relevance: 0,
          className: "constructor",
          begin: I
        }]
      },
      T = {
        className: "module-access",
        keywords: J,
        returnBegin: !0,
        variants: [{
          begin: "\\b(" + I + "\\.)+" + Q
        }, {
          begin: "\\b(" + I + "\\.)+\\(",
          end: "\\)",
          returnBegin: !0,
          contains: [q, {
            begin: "\\(",
            end: "\\)",
            skip: !0
          }].concat(K)
        }, {
          begin: "\\b(" + I + "\\.)+\\{",
          end: /\}/
        }],
        contains: K
      };
    return E.push(T), {
      name: "ReasonML",
      aliases: ["re"],
      keywords: J,
      illegal: "(:-|:=|\\$\\{|\\+=)",
      contains: [A.COMMENT("/\\*", "\\*/", {
        illegal: "^(#,\\/\\/)"
      }), {
        className: "character",
        begin: "'(\\\\[^']+|[^'])'",
        illegal: "\\n",
        relevance: 0
      }, A.QUOTE_STRING_MODE, {
        className: "literal",
        begin: "\\(\\)",
        relevance: 0
      }, {
        className: "literal",
        begin: "\\[\\|",
        end: "\\|\\]",
        relevance: 0,
        contains: C
      }, {
        className: "literal",
        begin: "\\[",
        end: "\\]",
        relevance: 0,
        contains: C
      }, O, {
        className: "operator",
        begin: W,
        illegal: "-->",
        relevance: 0
      }, X, A.C_LINE_COMMENT_MODE, R, q, {
        className: "module-def",
        begin: "\\bmodule\\s+" + Q + "\\s+" + I + "\\s+=\\s+\\{",
        end: /\}/,
        returnBegin: !0,
        keywords: J,
        relevance: 0,
        contains: [{
          className: "module",
          relevance: 0,
          begin: I
        }, {
          begin: /\{/,
          end: /\}/,
          skip: !0
        }].concat(K)
      }, T]
    }
  }
  EkA.exports = Ua9
})
// @from(Start 2090074, End 2091432)
$kA = z((u18, NkA) => {
  function Na9(A) {
    return {
      name: "RenderMan RIB",
      keywords: "ArchiveRecord AreaLightSource Atmosphere Attribute AttributeBegin AttributeEnd Basis Begin Blobby Bound Clipping ClippingPlane Color ColorSamples ConcatTransform Cone CoordinateSystem CoordSysTransform CropWindow Curves Cylinder DepthOfField Detail DetailRange Disk Displacement Display End ErrorHandler Exposure Exterior Format FrameAspectRatio FrameBegin FrameEnd GeneralPolygon GeometricApproximation Geometry Hider Hyperboloid Identity Illuminate Imager Interior LightSource MakeCubeFaceEnvironment MakeLatLongEnvironment MakeShadow MakeTexture Matte MotionBegin MotionEnd NuPatch ObjectBegin ObjectEnd ObjectInstance Opacity Option Orientation Paraboloid Patch PatchMesh Perspective PixelFilter PixelSamples PixelVariance Points PointsGeneralPolygons PointsPolygons Polygon Procedural Projection Quantize ReadArchive RelativeDetail ReverseOrientation Rotate Scale ScreenWindow ShadingInterpolation ShadingRate Shutter Sides Skew SolidBegin SolidEnd Sphere SubdivisionMesh Surface TextureCoordinates Torus Transform TransformBegin TransformEnd TransformPoints Translate TrimCurve WorldBegin WorldEnd",
      illegal: "</",
      contains: [A.HASH_COMMENT_MODE, A.C_NUMBER_MODE, A.APOS_STRING_MODE, A.QUOTE_STRING_MODE]
    }
  }
  NkA.exports = Na9
})
// @from(Start 2091438, End 2092545)
MkA = z((p18, qkA) => {
  function $a9(A) {
    let Q = {
      className: "attribute",
      begin: /[a-zA-Z-_]+/,
      end: /\s*:/,
      excludeEnd: !0,
      starts: {
        end: ";",
        relevance: 0,
        contains: [{
          className: "variable",
          begin: /\.[a-zA-Z-_]+/
        }, {
          className: "keyword",
          begin: /\(optional\)/
        }]
      }
    };
    return {
      name: "Roboconf",
      aliases: ["graph", "instances"],
      case_insensitive: !0,
      keywords: "import",
      contains: [{
        begin: "^facet [a-zA-Z-_][^\\n{]+\\{",
        end: /\}/,
        keywords: "facet",
        contains: [Q, A.HASH_COMMENT_MODE]
      }, {
        begin: "^\\s*instance of [a-zA-Z-_][^\\n{]+\\{",
        end: /\}/,
        keywords: "name count channels instance-data instance-state instance of",
        illegal: /\S/,
        contains: ["self", Q, A.HASH_COMMENT_MODE]
      }, {
        begin: "^[a-zA-Z-_][^\\n{]+\\{",
        end: /\}/,
        contains: [Q, A.HASH_COMMENT_MODE]
      }, A.HASH_COMMENT_MODE]
    }
  }
  qkA.exports = $a9
})
// @from(Start 2092551, End 2096023)
RkA = z((c18, LkA) => {
  function qa9(A) {
    let D = {
        className: "variable",
        variants: [{
          begin: /\$[\w\d#@][\w\d_]*/
        }, {
          begin: /\$\{(.*?)\}/
        }]
      },
      Y = {
        className: "string",
        begin: /"/,
        end: /"/,
        contains: [A.BACKSLASH_ESCAPE, D, {
          className: "variable",
          begin: /\$\(/,
          end: /\)/,
          contains: [A.BACKSLASH_ESCAPE]
        }]
      },
      W = {
        className: "string",
        begin: /'/,
        end: /'/
      };
    return {
      name: "Microtik RouterOS script",
      aliases: ["mikrotik"],
      case_insensitive: !0,
      keywords: {
        $pattern: /:?[\w-]+/,
        literal: "true false yes no nothing nil null",
        keyword: "foreach do while for if from to step else on-error and or not in :" + "foreach do while for if from to step else on-error and or not in".split(" ").join(" :") + " :" + "global local beep delay put len typeof pick log time set find environment terminal error execute parse resolve toarray tobool toid toip toip6 tonum tostr totime".split(" ").join(" :")
      },
      contains: [{
        variants: [{
          begin: /\/\*/,
          end: /\*\//
        }, {
          begin: /\/\//,
          end: /$/
        }, {
          begin: /<\//,
          end: />/
        }],
        illegal: /./
      }, A.COMMENT("^#", "$"), Y, W, D, {
        begin: /[\w-]+=([^\s{}[\]()>]+)/,
        relevance: 0,
        returnBegin: !0,
        contains: [{
          className: "attribute",
          begin: /[^=]+/
        }, {
          begin: /=/,
          endsWithParent: !0,
          relevance: 0,
          contains: [Y, W, D, {
            className: "literal",
            begin: "\\b(" + "true false yes no nothing nil null".split(" ").join("|") + ")\\b"
          }, {
            begin: /("[^"]*"|[^\s{}[\]]+)/
          }]
        }]
      }, {
        className: "number",
        begin: /\*[0-9a-fA-F]+/
      }, {
        begin: "\\b(" + "add remove enable disable set get print export edit find run debug error info warning".split(" ").join("|") + ")([\\s[(\\]|])",
        returnBegin: !0,
        contains: [{
          className: "builtin-name",
          begin: /\w+/
        }]
      }, {
        className: "built_in",
        variants: [{
          begin: "(\\.\\./|/|\\s)((" + "traffic-flow traffic-generator firewall scheduler aaa accounting address-list address align area bandwidth-server bfd bgp bridge client clock community config connection console customer default dhcp-client dhcp-server discovery dns e-mail ethernet filter firmware gps graphing group hardware health hotspot identity igmp-proxy incoming instance interface ip ipsec ipv6 irq l2tp-server lcd ldp logging mac-server mac-winbox mangle manual mirror mme mpls nat nd neighbor network note ntp ospf ospf-v3 ovpn-server page peer pim ping policy pool port ppp pppoe-client pptp-server prefix profile proposal proxy queue radius resource rip ripng route routing screen script security-profiles server service service-port settings shares smb sms sniffer snmp snooper socks sstp-server system tool tracking type upgrade upnp user-manager users user vlan secret vrrp watchdog web-access wireless pptp pppoe lan wan layer7-protocol lease simple raw".split(" ").join("|") + ");?\\s)+"
        }, {
          begin: /\.\./,
          relevance: 0
        }]
      }]
    }
  }
  LkA.exports = qa9
})
// @from(Start 2096029, End 2097284)
TkA = z((l18, OkA) => {
  function Ma9(A) {
    return {
      name: "RenderMan RSL",
      keywords: {
        keyword: "float color point normal vector matrix while for if do return else break extern continue",
        built_in: "abs acos ambient area asin atan atmosphere attribute calculatenormal ceil cellnoise clamp comp concat cos degrees depth Deriv diffuse distance Du Dv environment exp faceforward filterstep floor format fresnel incident length lightsource log match max min mod noise normalize ntransform opposite option phong pnoise pow printf ptlined radians random reflect refract renderinfo round setcomp setxcomp setycomp setzcomp shadow sign sin smoothstep specular specularbrdf spline sqrt step tan texture textureinfo trace transform vtransform xcomp ycomp zcomp"
      },
      illegal: "</",
      contains: [A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, A.QUOTE_STRING_MODE, A.APOS_STRING_MODE, A.C_NUMBER_MODE, {
        className: "meta",
        begin: "#",
        end: "$"
      }, {
        className: "class",
        beginKeywords: "surface displacement light volume imager",
        end: "\\("
      }, {
        beginKeywords: "illuminate illuminance gather",
        end: "\\("
      }]
    }
  }
  OkA.exports = Ma9
})
// @from(Start 2097290, End 2101284)
SkA = z((i18, PkA) => {
  function La9(A) {
    return {
      name: "Oracle Rules Language",
      keywords: {
        keyword: "BILL_PERIOD BILL_START BILL_STOP RS_EFFECTIVE_START RS_EFFECTIVE_STOP RS_JURIS_CODE RS_OPCO_CODE INTDADDATTRIBUTE|5 INTDADDVMSG|5 INTDBLOCKOP|5 INTDBLOCKOPNA|5 INTDCLOSE|5 INTDCOUNT|5 INTDCOUNTSTATUSCODE|5 INTDCREATEMASK|5 INTDCREATEDAYMASK|5 INTDCREATEFACTORMASK|5 INTDCREATEHANDLE|5 INTDCREATEOVERRIDEDAYMASK|5 INTDCREATEOVERRIDEMASK|5 INTDCREATESTATUSCODEMASK|5 INTDCREATETOUPERIOD|5 INTDDELETE|5 INTDDIPTEST|5 INTDEXPORT|5 INTDGETERRORCODE|5 INTDGETERRORMESSAGE|5 INTDISEQUAL|5 INTDJOIN|5 INTDLOAD|5 INTDLOADACTUALCUT|5 INTDLOADDATES|5 INTDLOADHIST|5 INTDLOADLIST|5 INTDLOADLISTDATES|5 INTDLOADLISTENERGY|5 INTDLOADLISTHIST|5 INTDLOADRELATEDCHANNEL|5 INTDLOADSP|5 INTDLOADSTAGING|5 INTDLOADUOM|5 INTDLOADUOMDATES|5 INTDLOADUOMHIST|5 INTDLOADVERSION|5 INTDOPEN|5 INTDREADFIRST|5 INTDREADNEXT|5 INTDRECCOUNT|5 INTDRELEASE|5 INTDREPLACE|5 INTDROLLAVG|5 INTDROLLPEAK|5 INTDSCALAROP|5 INTDSCALE|5 INTDSETATTRIBUTE|5 INTDSETDSTPARTICIPANT|5 INTDSETSTRING|5 INTDSETVALUE|5 INTDSETVALUESTATUS|5 INTDSHIFTSTARTTIME|5 INTDSMOOTH|5 INTDSORT|5 INTDSPIKETEST|5 INTDSUBSET|5 INTDTOU|5 INTDTOURELEASE|5 INTDTOUVALUE|5 INTDUPDATESTATS|5 INTDVALUE|5 STDEV INTDDELETEEX|5 INTDLOADEXACTUAL|5 INTDLOADEXCUT|5 INTDLOADEXDATES|5 INTDLOADEX|5 INTDLOADEXRELATEDCHANNEL|5 INTDSAVEEX|5 MVLOAD|5 MVLOADACCT|5 MVLOADACCTDATES|5 MVLOADACCTHIST|5 MVLOADDATES|5 MVLOADHIST|5 MVLOADLIST|5 MVLOADLISTDATES|5 MVLOADLISTHIST|5 IF FOR NEXT DONE SELECT END CALL ABORT CLEAR CHANNEL FACTOR LIST NUMBER OVERRIDE SET WEEK DISTRIBUTIONNODE ELSE WHEN THEN OTHERWISE IENUM CSV INCLUDE LEAVE RIDER SAVE DELETE NOVALUE SECTION WARN SAVE_UPDATE DETERMINANT LABEL REPORT REVENUE EACH IN FROM TOTAL CHARGE BLOCK AND OR CSV_FILE RATE_CODE AUXILIARY_DEMAND UIDACCOUNT RS BILL_PERIOD_SELECT HOURS_PER_MONTH INTD_ERROR_STOP SEASON_SCHEDULE_NAME ACCOUNTFACTOR ARRAYUPPERBOUND CALLSTOREDPROC GETADOCONNECTION GETCONNECT GETDATASOURCE GETQUALIFIER GETUSERID HASVALUE LISTCOUNT LISTOP LISTUPDATE LISTVALUE PRORATEFACTOR RSPRORATE SETBINPATH SETDBMONITOR WQ_OPEN BILLINGHOURS DATE DATEFROMFLOAT DATETIMEFROMSTRING DATETIMETOSTRING DATETOFLOAT DAY DAYDIFF DAYNAME DBDATETIME HOUR MINUTE MONTH MONTHDIFF MONTHHOURS MONTHNAME ROUNDDATE SAMEWEEKDAYLASTYEAR SECOND WEEKDAY WEEKDIFF YEAR YEARDAY YEARSTR COMPSUM HISTCOUNT HISTMAX HISTMIN HISTMINNZ HISTVALUE MAXNRANGE MAXRANGE MINRANGE COMPIKVA COMPKVA COMPKVARFROMKQKW COMPLF IDATTR FLAG LF2KW LF2KWH MAXKW POWERFACTOR READING2USAGE AVGSEASON MAXSEASON MONTHLYMERGE SEASONVALUE SUMSEASON ACCTREADDATES ACCTTABLELOAD CONFIGADD CONFIGGET CREATEOBJECT CREATEREPORT EMAILCLIENT EXPBLKMDMUSAGE EXPMDMUSAGE EXPORT_USAGE FACTORINEFFECT GETUSERSPECIFIEDSTOP INEFFECT ISHOLIDAY RUNRATE SAVE_PROFILE SETREPORTTITLE USEREXIT WATFORRUNRATE TO TABLE ACOS ASIN ATAN ATAN2 BITAND CEIL COS COSECANT COSH COTANGENT DIVQUOT DIVREM EXP FABS FLOOR FMOD FREPM FREXPN LOG LOG10 MAX MAXN MIN MINNZ MODF POW ROUND ROUND2VALUE ROUNDINT SECANT SIN SINH SQROOT TAN TANH FLOAT2STRING FLOAT2STRINGNC INSTR LEFT LEN LTRIM MID RIGHT RTRIM STRING STRINGNC TOLOWER TOUPPER TRIM NUMDAYS READ_DATE STAGING",
        built_in: "IDENTIFIER OPTIONS XML_ELEMENT XML_OP XML_ELEMENT_OF DOMDOCCREATE DOMDOCLOADFILE DOMDOCLOADXML DOMDOCSAVEFILE DOMDOCGETROOT DOMDOCADDPI DOMNODEGETNAME DOMNODEGETTYPE DOMNODEGETVALUE DOMNODEGETCHILDCT DOMNODEGETFIRSTCHILD DOMNODEGETSIBLING DOMNODECREATECHILDELEMENT DOMNODESETATTRIBUTE DOMNODEGETCHILDELEMENTCT DOMNODEGETFIRSTCHILDELEMENT DOMNODEGETSIBLINGELEMENT DOMNODEGETATTRIBUTECT DOMNODEGETATTRIBUTEI DOMNODEGETATTRIBUTEBYNAME DOMNODEGETBYNAME"
      },
      contains: [A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, A.APOS_STRING_MODE, A.QUOTE_STRING_MODE, A.C_NUMBER_MODE, {
        className: "literal",
        variants: [{
          begin: "#\\s+",
          relevance: 0
        }, {
          begin: "#[a-zA-Z .]+"
        }]
      }]
    }
  }
  PkA.exports = La9
})
// @from(Start 2101290, End 2104389)
jkA = z((n18, _kA) => {
  function Ra9(A) {
    let Q = "abstract as async await become box break const continue crate do dyn else enum extern false final fn for if impl in let loop macro match mod move mut override priv pub ref return self Self static struct super trait true try type typeof unsafe unsized use virtual where while yield",
      I = "drop i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize f32 f64 str char bool Box Option Result String Vec Copy Send Sized Sync Drop Fn FnMut FnOnce ToOwned Clone Debug PartialEq PartialOrd Eq Ord AsRef AsMut Into From Default Iterator Extend IntoIterator DoubleEndedIterator ExactSizeIterator SliceConcatExt ToString assert! assert_eq! bitflags! bytes! cfg! col! concat! concat_idents! debug_assert! debug_assert_eq! env! panic! file! format! format_args! include_bin! include_str! line! local_data_key! module_path! option_env! print! println! select! stringify! try! unimplemented! unreachable! vec! write! writeln! macro_rules! assert_ne! debug_assert_ne!";
    return {
      name: "Rust",
      aliases: ["rs"],
      keywords: {
        $pattern: A.IDENT_RE + "!?",
        keyword: Q,
        literal: "true false Some None Ok Err",
        built_in: I
      },
      illegal: "</",
      contains: [A.C_LINE_COMMENT_MODE, A.COMMENT("/\\*", "\\*/", {
        contains: ["self"]
      }), A.inherit(A.QUOTE_STRING_MODE, {
        begin: /b?"/,
        illegal: null
      }), {
        className: "string",
        variants: [{
          begin: /r(#*)"(.|\n)*?"\1(?!#)/
        }, {
          begin: /b?'\\?(x\w{2}|u\w{4}|U\w{8}|.)'/
        }]
      }, {
        className: "symbol",
        begin: /'[a-zA-Z_][a-zA-Z0-9_]*/
      }, {
        className: "number",
        variants: [{
          begin: "\\b0b([01_]+)([ui](8|16|32|64|128|size)|f(32|64))?"
        }, {
          begin: "\\b0o([0-7_]+)([ui](8|16|32|64|128|size)|f(32|64))?"
        }, {
          begin: "\\b0x([A-Fa-f0-9_]+)([ui](8|16|32|64|128|size)|f(32|64))?"
        }, {
          begin: "\\b(\\d[\\d_]*(\\.[0-9_]+)?([eE][+-]?[0-9_]+)?)([ui](8|16|32|64|128|size)|f(32|64))?"
        }],
        relevance: 0
      }, {
        className: "function",
        beginKeywords: "fn",
        end: "(\\(|<)",
        excludeEnd: !0,
        contains: [A.UNDERSCORE_TITLE_MODE]
      }, {
        className: "meta",
        begin: "#!?\\[",
        end: "\\]",
        contains: [{
          className: "meta-string",
          begin: /"/,
          end: /"/
        }]
      }, {
        className: "class",
        beginKeywords: "type",
        end: ";",
        contains: [A.inherit(A.UNDERSCORE_TITLE_MODE, {
          endsParent: !0
        })],
        illegal: "\\S"
      }, {
        className: "class",
        beginKeywords: "trait enum struct union",
        end: /\{/,
        contains: [A.inherit(A.UNDERSCORE_TITLE_MODE, {
          endsParent: !0
        })],
        illegal: "[\\w\\d]"
      }, {
        begin: A.IDENT_RE + "::",
        keywords: {
          built_in: I
        }
      }, {
        begin: "->"
      }]
    }
  }
  _kA.exports = Ra9
})
// @from(Start 2104395, End 2108372)
kkA = z((a18, ykA) => {
  function Oa9(A) {
    let B = "do if then else end until while abort array attrib by call cards cards4 catname continue datalines datalines4 delete delim delimiter display dm drop endsas error file filename footnote format goto in infile informat input keep label leave length libname link list lostcard merge missing modify options output out page put redirect remove rename replace retain return select set skip startsas stop title update waitsas where window x systask add and alter as cascade check create delete describe distinct drop foreign from group having index insert into in key like message modify msgtype not null on or order primary references reset restrict select set table unique update validate view where",
      Q = "abs|addr|airy|arcos|arsin|atan|attrc|attrn|band|betainv|blshift|bnot|bor|brshift|bxor|byte|cdf|ceil|cexist|cinv|close|cnonct|collate|compbl|compound|compress|cos|cosh|css|curobs|cv|daccdb|daccdbsl|daccsl|daccsyd|dacctab|dairy|date|datejul|datepart|datetime|day|dclose|depdb|depdbsl|depdbsl|depsl|depsl|depsyd|depsyd|deptab|deptab|dequote|dhms|dif|digamma|dim|dinfo|dnum|dopen|doptname|doptnum|dread|dropnote|dsname|erf|erfc|exist|exp|fappend|fclose|fcol|fdelete|fetch|fetchobs|fexist|fget|fileexist|filename|fileref|finfo|finv|fipname|fipnamel|fipstate|floor|fnonct|fnote|fopen|foptname|foptnum|fpoint|fpos|fput|fread|frewind|frlen|fsep|fuzz|fwrite|gaminv|gamma|getoption|getvarc|getvarn|hbound|hms|hosthelp|hour|ibessel|index|indexc|indexw|input|inputc|inputn|int|intck|intnx|intrr|irr|jbessel|juldate|kurtosis|lag|lbound|left|length|lgamma|libname|libref|log|log10|log2|logpdf|logpmf|logsdf|lowcase|max|mdy|mean|min|minute|mod|month|mopen|mort|n|netpv|nmiss|normal|note|npv|open|ordinal|pathname|pdf|peek|peekc|pmf|point|poisson|poke|probbeta|probbnml|probchi|probf|probgam|probhypr|probit|probnegb|probnorm|probt|put|putc|putn|qtr|quote|ranbin|rancau|ranexp|rangam|range|rank|rannor|ranpoi|rantbl|rantri|ranuni|repeat|resolve|reverse|rewind|right|round|saving|scan|sdf|second|sign|sin|sinh|skewness|soundex|spedis|sqrt|std|stderr|stfips|stname|stnamel|substr|sum|symget|sysget|sysmsg|sysprod|sysrc|system|tan|tanh|time|timepart|tinv|tnonct|today|translate|tranwrd|trigamma|trim|trimn|trunc|uniform|upcase|uss|var|varfmt|varinfmt|varlabel|varlen|varname|varnum|varray|varrayx|vartype|verify|vformat|vformatd|vformatdx|vformatn|vformatnx|vformatw|vformatwx|vformatx|vinarray|vinarrayx|vinformat|vinformatd|vinformatdx|vinformatn|vinformatnx|vinformatw|vinformatwx|vinformatx|vlabel|vlabelx|vlength|vlengthx|vname|vnamex|vtype|vtypex|weekday|year|yyq|zipfips|zipname|zipnamel|zipstate";
    return {
      name: "SAS",
      case_insensitive: !0,
      keywords: {
        literal: "null missing _all_ _automatic_ _character_ _infile_ _n_ _name_ _null_ _numeric_ _user_ _webout_",
        meta: B
      },
      contains: [{
        className: "keyword",
        begin: /^\s*(proc [\w\d_]+|data|run|quit)[\s;]/
      }, {
        className: "variable",
        begin: /&[a-zA-Z_&][a-zA-Z0-9_]*\.?/
      }, {
        className: "emphasis",
        begin: /^\s*datalines|cards.*;/,
        end: /^\s*;\s*$/
      }, {
        className: "built_in",
        begin: "%(" + "bquote|nrbquote|cmpres|qcmpres|compstor|datatyp|display|do|else|end|eval|global|goto|if|index|input|keydef|label|left|length|let|local|lowcase|macro|mend|nrbquote|nrquote|nrstr|put|qcmpres|qleft|qlowcase|qscan|qsubstr|qsysfunc|qtrim|quote|qupcase|scan|str|substr|superq|syscall|sysevalf|sysexec|sysfunc|sysget|syslput|sysprod|sysrc|sysrput|then|to|trim|unquote|until|upcase|verify|while|window" + ")"
      }, {
        className: "name",
        begin: /%[a-zA-Z_][a-zA-Z_0-9]*/
      }, {
        className: "meta",
        begin: "[^%](" + Q + ")[(]"
      }, {
        className: "string",
        variants: [A.APOS_STRING_MODE, A.QUOTE_STRING_MODE]
      }, A.COMMENT("\\*", ";"), A.C_BLOCK_COMMENT_MODE]
    }
  }
  ykA.exports = Oa9
})
// @from(Start 2108378, End 2110858)
fkA = z((s18, xkA) => {
  function Ta9(A) {
    let B = {
        className: "meta",
        begin: "@[A-Za-z]+"
      },
      Q = {
        className: "subst",
        variants: [{
          begin: "\\$[A-Za-z0-9_]+"
        }, {
          begin: /\$\{/,
          end: /\}/
        }]
      },
      I = {
        className: "string",
        variants: [{
          begin: '"""',
          end: '"""'
        }, {
          begin: '"',
          end: '"',
          illegal: "\\n",
          contains: [A.BACKSLASH_ESCAPE]
        }, {
          begin: '[a-z]+"',
          end: '"',
          illegal: "\\n",
          contains: [A.BACKSLASH_ESCAPE, Q]
        }, {
          className: "string",
          begin: '[a-z]+"""',
          end: '"""',
          contains: [Q],
          relevance: 10
        }]
      },
      G = {
        className: "symbol",
        begin: "'\\w[\\w\\d_]*(?!')"
      },
      Z = {
        className: "type",
        begin: "\\b[A-Z][A-Za-z0-9_]*",
        relevance: 0
      },
      D = {
        className: "title",
        begin: /[^0-9\n\t "'(),.`{}\[\]:;][^\n\t "'(),.`{}\[\]:;]+|[^0-9\n\t "'(),.`{}\[\]:;=]/,
        relevance: 0
      },
      Y = {
        className: "class",
        beginKeywords: "class object trait type",
        end: /[:={\[\n;]/,
        excludeEnd: !0,
        contains: [A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, {
          beginKeywords: "extends with",
          relevance: 10
        }, {
          begin: /\[/,
          end: /\]/,
          excludeBegin: !0,
          excludeEnd: !0,
          relevance: 0,
          contains: [Z]
        }, {
          className: "params",
          begin: /\(/,
          end: /\)/,
          excludeBegin: !0,
          excludeEnd: !0,
          relevance: 0,
          contains: [Z]
        }, D]
      },
      W = {
        className: "function",
        beginKeywords: "def",
        end: /[:={\[(\n;]/,
        excludeEnd: !0,
        contains: [D]
      };
    return {
      name: "Scala",
      keywords: {
        literal: "true false null",
        keyword: "type yield lazy override def with val var sealed abstract private trait object if forSome for while throw finally protected extends import final return else break new catch super class case package default try this match continue throws implicit"
      },
      contains: [A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, I, G, Z, W, Y, A.C_NUMBER_MODE, B]
    }
  }
  xkA.exports = Ta9
})
// @from(Start 2110864, End 2115245)
bkA = z((r18, vkA) => {
  function Pa9(A) {
    let I = "(-|\\+)?\\d+([./]\\d+)?[+\\-](-|\\+)?\\d+([./]\\d+)?i",
      G = {
        $pattern: "[^\\(\\)\\[\\]\\{\\}\",'`;#|\\\\\\s]+",
        "builtin-name": "case-lambda call/cc class define-class exit-handler field import inherit init-field interface let*-values let-values let/ec mixin opt-lambda override protect provide public rename require require-for-syntax syntax syntax-case syntax-error unit/sig unless when with-syntax and begin call-with-current-continuation call-with-input-file call-with-output-file case cond define define-syntax delay do dynamic-wind else for-each if lambda let let* let-syntax letrec letrec-syntax map or syntax-rules ' * + , ,@ - ... / ; < <= = => > >= ` abs acos angle append apply asin assoc assq assv atan boolean? caar cadr call-with-input-file call-with-output-file call-with-values car cdddar cddddr cdr ceiling char->integer char-alphabetic? char-ci<=? char-ci<? char-ci=? char-ci>=? char-ci>? char-downcase char-lower-case? char-numeric? char-ready? char-upcase char-upper-case? char-whitespace? char<=? char<? char=? char>=? char>? char? close-input-port close-output-port complex? cons cos current-input-port current-output-port denominator display eof-object? eq? equal? eqv? eval even? exact->inexact exact? exp expt floor force gcd imag-part inexact->exact inexact? input-port? integer->char integer? interaction-environment lcm length list list->string list->vector list-ref list-tail list? load log magnitude make-polar make-rectangular make-string make-vector max member memq memv min modulo negative? newline not null-environment null? number->string number? numerator odd? open-input-file open-output-file output-port? pair? peek-char port? positive? procedure? quasiquote quote quotient rational? rationalize read read-char real-part real? remainder reverse round scheme-report-environment set! set-car! set-cdr! sin sqrt string string->list string->number string->symbol string-append string-ci<=? string-ci<? string-ci=? string-ci>=? string-ci>? string-copy string-fill! string-length string-ref string-set! string<=? string<? string=? string>=? string>? string? substring symbol->string symbol? tan transcript-off transcript-on truncate values vector vector->list vector-fill! vector-length vector-ref vector-set! with-input-from-file with-output-to-file write write-char zero?"
      },
      Z = {
        className: "literal",
        begin: "(#t|#f|#\\\\[^\\(\\)\\[\\]\\{\\}\",'`;#|\\\\\\s]+|#\\\\.)"
      },
      D = {
        className: "number",
        variants: [{
          begin: "(-|\\+)?\\d+([./]\\d+)?",
          relevance: 0
        }, {
          begin: I,
          relevance: 0
        }, {
          begin: "#b[0-1]+(/[0-1]+)?"
        }, {
          begin: "#o[0-7]+(/[0-7]+)?"
        }, {
          begin: "#x[0-9a-f]+(/[0-9a-f]+)?"
        }]
      },
      Y = A.QUOTE_STRING_MODE,
      W = [A.COMMENT(";", "$", {
        relevance: 0
      }), A.COMMENT("#\\|", "\\|#")],
      J = {
        begin: "[^\\(\\)\\[\\]\\{\\}\",'`;#|\\\\\\s]+",
        relevance: 0
      },
      F = {
        className: "symbol",
        begin: "'[^\\(\\)\\[\\]\\{\\}\",'`;#|\\\\\\s]+"
      },
      X = {
        endsWithParent: !0,
        relevance: 0
      },
      V = {
        variants: [{
          begin: /'/
        }, {
          begin: "`"
        }],
        contains: [{
          begin: "\\(",
          end: "\\)",
          contains: ["self", Z, Y, D, J, F]
        }]
      },
      C = {
        className: "name",
        relevance: 0,
        begin: "[^\\(\\)\\[\\]\\{\\}\",'`;#|\\\\\\s]+",
        keywords: G
      },
      E = {
        variants: [{
          begin: "\\(",
          end: "\\)"
        }, {
          begin: "\\[",
          end: "\\]"
        }],
        contains: [{
          begin: /lambda/,
          endsWithParent: !0,
          returnBegin: !0,
          contains: [C, {
            endsParent: !0,
            variants: [{
              begin: /\(/,
              end: /\)/
            }, {
              begin: /\[/,
              end: /\]/
            }],
            contains: [J]
          }]
        }, C, X]
      };
    return X.contains = [Z, D, Y, J, F, V, E].concat(W), {
      name: "Scheme",
      illegal: /\S/,
      contains: [A.SHEBANG(), D, Y, F, V, E].concat(W)
    }
  }
  vkA.exports = Pa9
})
// @from(Start 2115251, End 2116789)
hkA = z((o18, gkA) => {
  function Sa9(A) {
    let B = [A.C_NUMBER_MODE, {
      className: "string",
      begin: `'|"`,
      end: `'|"`,
      contains: [A.BACKSLASH_ESCAPE, {
        begin: "''"
      }]
    }];
    return {
      name: "Scilab",
      aliases: ["sci"],
      keywords: {
        $pattern: /%?\w+/,
        keyword: "abort break case clear catch continue do elseif else endfunction end for function global if pause return resume select try then while",
        literal: "%f %F %t %T %pi %eps %inf %nan %e %i %z %s",
        built_in: "abs and acos asin atan ceil cd chdir clearglobal cosh cos cumprod deff disp error exec execstr exists exp eye gettext floor fprintf fread fsolve imag isdef isempty isinfisnan isvector lasterror length load linspace list listfiles log10 log2 log max min msprintf mclose mopen ones or pathconvert poly printf prod pwd rand real round sinh sin size gsort sprintf sqrt strcat strcmps tring sum system tanh tan type typename warning zeros matrix"
      },
      illegal: '("|#|/\\*|\\s+/\\w+)',
      contains: [{
        className: "function",
        beginKeywords: "function",
        end: "$",
        contains: [A.UNDERSCORE_TITLE_MODE, {
          className: "params",
          begin: "\\(",
          end: "\\)"
        }]
      }, {
        begin: "[a-zA-Z_][a-zA-Z_0-9]*[\\.']+",
        relevance: 0
      }, {
        begin: "\\[",
        end: "\\][\\.']*",
        relevance: 0,
        contains: B
      }, A.COMMENT("//", "$")].concat(B)
    }
  }
  gkA.exports = Sa9
})
// @from(Start 2116795, End 2125835)
dkA = z((t18, mkA) => {
  var _a9 = (A) => {
      return {
        IMPORTANT: {
          className: "meta",
          begin: "!important"
        },
        HEXCOLOR: {
          className: "number",
          begin: "#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})"
        },
        ATTRIBUTE_SELECTOR_MODE: {
          className: "selector-attr",
          begin: /\[/,
          end: /\]/,
          illegal: "$",
          contains: [A.APOS_STRING_MODE, A.QUOTE_STRING_MODE]
        }
      }
    },
    ja9 = ["a", "abbr", "address", "article", "aside", "audio", "b", "blockquote", "body", "button", "canvas", "caption", "cite", "code", "dd", "del", "details", "dfn", "div", "dl", "dt", "em", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup", "html", "i", "iframe", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "mark", "menu", "nav", "object", "ol", "p", "q", "quote", "samp", "section", "span", "strong", "summary", "sup", "table", "tbody", "td", "textarea", "tfoot", "th", "thead", "time", "tr", "ul", "var", "video"],
    ya9 = ["any-hover", "any-pointer", "aspect-ratio", "color", "color-gamut", "color-index", "device-aspect-ratio", "device-height", "device-width", "display-mode", "forced-colors", "grid", "height", "hover", "inverted-colors", "monochrome", "orientation", "overflow-block", "overflow-inline", "pointer", "prefers-color-scheme", "prefers-contrast", "prefers-reduced-motion", "prefers-reduced-transparency", "resolution", "scan", "scripting", "update", "width", "min-width", "max-width", "min-height", "max-height"],
    ka9 = ["active", "any-link", "blank", "checked", "current", "default", "defined", "dir", "disabled", "drop", "empty", "enabled", "first", "first-child", "first-of-type", "fullscreen", "future", "focus", "focus-visible", "focus-within", "has", "host", "host-context", "hover", "indeterminate", "in-range", "invalid", "is", "lang", "last-child", "last-of-type", "left", "link", "local-link", "not", "nth-child", "nth-col", "nth-last-child", "nth-last-col", "nth-last-of-type", "nth-of-type", "only-child", "only-of-type", "optional", "out-of-range", "past", "placeholder-shown", "read-only", "read-write", "required", "right", "root", "scope", "target", "target-within", "user-invalid", "valid", "visited", "where"],
    xa9 = ["after", "backdrop", "before", "cue", "cue-region", "first-letter", "first-line", "grammar-error", "marker", "part", "placeholder", "selection", "slotted", "spelling-error"],
    fa9 = ["align-content", "align-items", "align-self", "animation", "animation-delay", "animation-direction", "animation-duration", "animation-fill-mode", "animation-iteration-count", "animation-name", "animation-play-state", "animation-timing-function", "auto", "backface-visibility", "background", "background-attachment", "background-clip", "background-color", "background-image", "background-origin", "background-position", "background-repeat", "background-size", "border", "border-bottom", "border-bottom-color", "border-bottom-left-radius", "border-bottom-right-radius", "border-bottom-style", "border-bottom-width", "border-collapse", "border-color", "border-image", "border-image-outset", "border-image-repeat", "border-image-slice", "border-image-source", "border-image-width", "border-left", "border-left-color", "border-left-style", "border-left-width", "border-radius", "border-right", "border-right-color", "border-right-style", "border-right-width", "border-spacing", "border-style", "border-top", "border-top-color", "border-top-left-radius", "border-top-right-radius", "border-top-style", "border-top-width", "border-width", "bottom", "box-decoration-break", "box-shadow", "box-sizing", "break-after", "break-before", "break-inside", "caption-side", "clear", "clip", "clip-path", "color", "column-count", "column-fill", "column-gap", "column-rule", "column-rule-color", "column-rule-style", "column-rule-width", "column-span", "column-width", "columns", "content", "counter-increment", "counter-reset", "cursor", "direction", "display", "empty-cells", "filter", "flex", "flex-basis", "flex-direction", "flex-flow", "flex-grow", "flex-shrink", "flex-wrap", "float", "font", "font-display", "font-family", "font-feature-settings", "font-kerning", "font-language-override", "font-size", "font-size-adjust", "font-smoothing", "font-stretch", "font-style", "font-variant", "font-variant-ligatures", "font-variation-settings", "font-weight", "height", "hyphens", "icon", "image-orientation", "image-rendering", "image-resolution", "ime-mode", "inherit", "initial", "justify-content", "left", "letter-spacing", "line-height", "list-style", "list-style-image", "list-style-position", "list-style-type", "margin", "margin-bottom", "margin-left", "margin-right", "margin-top", "marks", "mask", "max-height", "max-width", "min-height", "min-width", "nav-down", "nav-index", "nav-left", "nav-right", "nav-up", "none", "normal", "object-fit", "object-position", "opacity", "order", "orphans", "outline", "outline-color", "outline-offset", "outline-style", "outline-width", "overflow", "overflow-wrap", "overflow-x", "overflow-y", "padding", "padding-bottom", "padding-left", "padding-right", "padding-top", "page-break-after", "page-break-before", "page-break-inside", "perspective", "perspective-origin", "pointer-events", "position", "quotes", "resize", "right", "src", "tab-size", "table-layout", "text-align", "text-align-last", "text-decoration", "text-decoration-color", "text-decoration-line", "text-decoration-style", "text-indent", "text-overflow", "text-rendering", "text-shadow", "text-transform", "text-underline-position", "top", "transform", "transform-origin", "transform-style", "transition", "transition-delay", "transition-duration", "transition-property", "transition-timing-function", "unicode-bidi", "vertical-align", "visibility", "white-space", "widows", "width", "word-break", "word-spacing", "word-wrap", "z-index"].reverse();

  function va9(A) {
    let B = _a9(A),
      Q = xa9,
      I = ka9,
      G = "@[a-z-]+",
      Z = "and or not only",
      D = "[a-zA-Z-][a-zA-Z0-9_-]*",
      Y = {
        className: "variable",
        begin: "(\\$[a-zA-Z-][a-zA-Z0-9_-]*)\\b"
      };
    return {
      name: "SCSS",
      case_insensitive: !0,
      illegal: "[=/|']",
      contains: [A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, {
        className: "selector-id",
        begin: "#[A-Za-z0-9_-]+",
        relevance: 0
      }, {
        className: "selector-class",
        begin: "\\.[A-Za-z0-9_-]+",
        relevance: 0
      }, B.ATTRIBUTE_SELECTOR_MODE, {
        className: "selector-tag",
        begin: "\\b(" + ja9.join("|") + ")\\b",
        relevance: 0
      }, {
        className: "selector-pseudo",
        begin: ":(" + I.join("|") + ")"
      }, {
        className: "selector-pseudo",
        begin: "::(" + Q.join("|") + ")"
      }, Y, {
        begin: /\(/,
        end: /\)/,
        contains: [A.CSS_NUMBER_MODE]
      }, {
        className: "attribute",
        begin: "\\b(" + fa9.join("|") + ")\\b"
      }, {
        begin: "\\b(whitespace|wait|w-resize|visible|vertical-text|vertical-ideographic|uppercase|upper-roman|upper-alpha|underline|transparent|top|thin|thick|text|text-top|text-bottom|tb-rl|table-header-group|table-footer-group|sw-resize|super|strict|static|square|solid|small-caps|separate|se-resize|scroll|s-resize|rtl|row-resize|ridge|right|repeat|repeat-y|repeat-x|relative|progress|pointer|overline|outside|outset|oblique|nowrap|not-allowed|normal|none|nw-resize|no-repeat|no-drop|newspaper|ne-resize|n-resize|move|middle|medium|ltr|lr-tb|lowercase|lower-roman|lower-alpha|loose|list-item|line|line-through|line-edge|lighter|left|keep-all|justify|italic|inter-word|inter-ideograph|inside|inset|inline|inline-block|inherit|inactive|ideograph-space|ideograph-parenthesis|ideograph-numeric|ideograph-alpha|horizontal|hidden|help|hand|groove|fixed|ellipsis|e-resize|double|dotted|distribute|distribute-space|distribute-letter|distribute-all-lines|disc|disabled|default|decimal|dashed|crosshair|collapse|col-resize|circle|char|center|capitalize|break-word|break-all|bottom|both|bolder|bold|block|bidi-override|below|baseline|auto|always|all-scroll|absolute|table|table-cell)\\b"
      }, {
        begin: ":",
        end: ";",
        contains: [Y, B.HEXCOLOR, A.CSS_NUMBER_MODE, A.QUOTE_STRING_MODE, A.APOS_STRING_MODE, B.IMPORTANT]
      }, {
        begin: "@(page|font-face)",
        lexemes: "@[a-z-]+",
        keywords: "@page @font-face"
      }, {
        begin: "@",
        end: "[{;]",
        returnBegin: !0,
        keywords: {
          $pattern: /[a-z-]+/,
          keyword: "and or not only",
          attribute: ya9.join(" ")
        },
        contains: [{
          begin: "@[a-z-]+",
          className: "keyword"
        }, {
          begin: /[a-z-]+(?=:)/,
          className: "attribute"
        }, Y, A.QUOTE_STRING_MODE, A.APOS_STRING_MODE, B.HEXCOLOR, A.CSS_NUMBER_MODE]
      }]
    }
  }
  mkA.exports = va9
})
// @from(Start 2125841, End 2126181)
pkA = z((e18, ukA) => {
  function ba9(A) {
    return {
      name: "Shell Session",
      aliases: ["console"],
      contains: [{
        className: "meta",
        begin: /^\s{0,3}[/~\w\d[\]()@-]*[>%$#]/,
        starts: {
          end: /[^\\](?=\s*$)/,
          subLanguage: "bash"
        }
      }]
    }
  }
  ukA.exports = ba9
})
// @from(Start 2126187, End 2127794)
lkA = z((AA8, ckA) => {
  function ga9(A) {
    let B = ["add", "and", "cmp", "cmpg", "cmpl", "const", "div", "double", "float", "goto", "if", "int", "long", "move", "mul", "neg", "new", "nop", "not", "or", "rem", "return", "shl", "shr", "sput", "sub", "throw", "ushr", "xor"],
      Q = ["aget", "aput", "array", "check", "execute", "fill", "filled", "goto/16", "goto/32", "iget", "instance", "invoke", "iput", "monitor", "packed", "sget", "sparse"],
      I = ["transient", "constructor", "abstract", "final", "synthetic", "public", "private", "protected", "static", "bridge", "system"];
    return {
      name: "Smali",
      contains: [{
        className: "string",
        begin: '"',
        end: '"',
        relevance: 0
      }, A.COMMENT("#", "$", {
        relevance: 0
      }), {
        className: "keyword",
        variants: [{
          begin: "\\s*\\.end\\s[a-zA-Z0-9]*"
        }, {
          begin: "^[ ]*\\.[a-zA-Z]*",
          relevance: 0
        }, {
          begin: "\\s:[a-zA-Z_0-9]*",
          relevance: 0
        }, {
          begin: "\\s(" + I.join("|") + ")"
        }]
      }, {
        className: "built_in",
        variants: [{
          begin: "\\s(" + B.join("|") + ")\\s"
        }, {
          begin: "\\s(" + B.join("|") + ")((-|/)[a-zA-Z0-9]+)+\\s",
          relevance: 10
        }, {
          begin: "\\s(" + Q.join("|") + ")((-|/)[a-zA-Z0-9]+)*\\s",
          relevance: 10
        }]
      }, {
        className: "class",
        begin: `L[^(;:
]*;`,
        relevance: 0
      }, {
        begin: "[vp][0-9]+"
      }]
    }
  }
  ckA.exports = ga9
})
// @from(Start 2127800, End 2128764)
nkA = z((BA8, ikA) => {
  function ha9(A) {
    let Q = {
        className: "string",
        begin: "\\$.{1}"
      },
      I = {
        className: "symbol",
        begin: "#" + A.UNDERSCORE_IDENT_RE
      };
    return {
      name: "Smalltalk",
      aliases: ["st"],
      keywords: "self super nil true false thisContext",
      contains: [A.COMMENT('"', '"'), A.APOS_STRING_MODE, {
        className: "type",
        begin: "\\b[A-Z][A-Za-z0-9_]*",
        relevance: 0
      }, {
        begin: "[a-z][a-zA-Z0-9_]*:",
        relevance: 0
      }, A.C_NUMBER_MODE, I, Q, {
        begin: "\\|[ ]*[a-z][a-zA-Z0-9_]*([ ]+[a-z][a-zA-Z0-9_]*)*[ ]*\\|",
        returnBegin: !0,
        end: /\|/,
        illegal: /\S/,
        contains: [{
          begin: "(\\|[ ]*)?[a-z][a-zA-Z0-9_]*"
        }]
      }, {
        begin: "#\\(",
        end: "\\)",
        contains: [A.APOS_STRING_MODE, Q, A.C_NUMBER_MODE, I]
      }]
    }
  }
  ikA.exports = ha9
})
// @from(Start 2128770, End 2130293)
skA = z((QA8, akA) => {
  function ma9(A) {
    return {
      name: "SML (Standard ML)",
      aliases: ["ml"],
      keywords: {
        $pattern: "[a-z_]\\w*!?",
        keyword: "abstype and andalso as case datatype do else end eqtype exception fn fun functor handle if in include infix infixr let local nonfix of op open orelse raise rec sharing sig signature struct structure then type val with withtype where while",
        built_in: "array bool char exn int list option order real ref string substring vector unit word",
        literal: "true false NONE SOME LESS EQUAL GREATER nil"
      },
      illegal: /\/\/|>>/,
      contains: [{
        className: "literal",
        begin: /\[(\|\|)?\]|\(\)/,
        relevance: 0
      }, A.COMMENT("\\(\\*", "\\*\\)", {
        contains: ["self"]
      }), {
        className: "symbol",
        begin: "'[A-Za-z_](?!')[\\w']*"
      }, {
        className: "type",
        begin: "`[A-Z][\\w']*"
      }, {
        className: "type",
        begin: "\\b[A-Z][\\w']*",
        relevance: 0
      }, {
        begin: "[a-z_]\\w*'[\\w']*"
      }, A.inherit(A.APOS_STRING_MODE, {
        className: "string",
        relevance: 0
      }), A.inherit(A.QUOTE_STRING_MODE, {
        illegal: null
      }), {
        className: "number",
        begin: "\\b(0[xX][a-fA-F0-9_]+[Lln]?|0[oO][0-7_]+[Lln]?|0[bB][01_]+[Lln]?|[0-9][0-9_]*([Lln]|(\\.[0-9_]*)?([eE][-+]?[0-9_]+)?)?)",
        relevance: 0
      }, {
        begin: /[-=]>/
      }]
    }
  }
  akA.exports = ma9
})
// @from(Start 2130299, End 2163101)
okA = z((IA8, rkA) => {
  function da9(A) {
    let B = {
        className: "variable",
        begin: /\b_+[a-zA-Z]\w*/
      },
      Q = {
        className: "title",
        begin: /[a-zA-Z][a-zA-Z0-9]+_fnc_\w*/
      },
      I = {
        className: "string",
        variants: [{
          begin: '"',
          end: '"',
          contains: [{
            begin: '""',
            relevance: 0
          }]
        }, {
          begin: "'",
          end: "'",
          contains: [{
            begin: "''",
            relevance: 0
          }]
        }]
      },
      G = {
        className: "meta",
        begin: /#\s*[a-z]+\b/,
        end: /$/,
        keywords: {
          "meta-keyword": "define undef ifdef ifndef else endif include"
        },
        contains: [{
          begin: /\\\n/,
          relevance: 0
        }, A.inherit(I, {
          className: "meta-string"
        }), {
          className: "meta-string",
          begin: /<[^\n>]*>/,
          end: /$/,
          illegal: "\\n"
        }, A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE]
      };
    return {
      name: "SQF",
      case_insensitive: !0,
      keywords: {
        keyword: "case catch default do else exit exitWith for forEach from if private switch then throw to try waitUntil while with",
        built_in: "abs accTime acos action actionIDs actionKeys actionKeysImages actionKeysNames actionKeysNamesArray actionName actionParams activateAddons activatedAddons activateKey add3DENConnection add3DENEventHandler add3DENLayer addAction addBackpack addBackpackCargo addBackpackCargoGlobal addBackpackGlobal addCamShake addCuratorAddons addCuratorCameraArea addCuratorEditableObjects addCuratorEditingArea addCuratorPoints addEditorObject addEventHandler addForce addGoggles addGroupIcon addHandgunItem addHeadgear addItem addItemCargo addItemCargoGlobal addItemPool addItemToBackpack addItemToUniform addItemToVest addLiveStats addMagazine addMagazineAmmoCargo addMagazineCargo addMagazineCargoGlobal addMagazineGlobal addMagazinePool addMagazines addMagazineTurret addMenu addMenuItem addMissionEventHandler addMPEventHandler addMusicEventHandler addOwnedMine addPlayerScores addPrimaryWeaponItem addPublicVariableEventHandler addRating addResources addScore addScoreSide addSecondaryWeaponItem addSwitchableUnit addTeamMember addToRemainsCollector addTorque addUniform addVehicle addVest addWaypoint addWeapon addWeaponCargo addWeaponCargoGlobal addWeaponGlobal addWeaponItem addWeaponPool addWeaponTurret admin agent agents AGLToASL aimedAtTarget aimPos airDensityRTD airplaneThrottle airportSide AISFinishHeal alive all3DENEntities allAirports allControls allCurators allCutLayers allDead allDeadMen allDisplays allGroups allMapMarkers allMines allMissionObjects allow3DMode allowCrewInImmobile allowCuratorLogicIgnoreAreas allowDamage allowDammage allowFileOperations allowFleeing allowGetIn allowSprint allPlayers allSimpleObjects allSites allTurrets allUnits allUnitsUAV allVariables ammo ammoOnPylon and animate animateBay animateDoor animatePylon animateSource animationNames animationPhase animationSourcePhase animationState append apply armoryPoints arrayIntersect asin ASLToAGL ASLToATL assert assignAsCargo assignAsCargoIndex assignAsCommander assignAsDriver assignAsGunner assignAsTurret assignCurator assignedCargo assignedCommander assignedDriver assignedGunner assignedItems assignedTarget assignedTeam assignedVehicle assignedVehicleRole assignItem assignTeam assignToAirport atan atan2 atg ATLToASL attachedObject attachedObjects attachedTo attachObject attachTo attackEnabled backpack backpackCargo backpackContainer backpackItems backpackMagazines backpackSpaceFor behaviour benchmark binocular boundingBox boundingBoxReal boundingCenter breakOut breakTo briefingName buildingExit buildingPos buttonAction buttonSetAction cadetMode call callExtension camCommand camCommit camCommitPrepared camCommitted camConstuctionSetParams camCreate camDestroy cameraEffect cameraEffectEnableHUD cameraInterest cameraOn cameraView campaignConfigFile camPreload camPreloaded camPrepareBank camPrepareDir camPrepareDive camPrepareFocus camPrepareFov camPrepareFovRange camPreparePos camPrepareRelPos camPrepareTarget camSetBank camSetDir camSetDive camSetFocus camSetFov camSetFovRange camSetPos camSetRelPos camSetTarget camTarget camUseNVG canAdd canAddItemToBackpack canAddItemToUniform canAddItemToVest cancelSimpleTaskDestination canFire canMove canSlingLoad canStand canSuspend canTriggerDynamicSimulation canUnloadInCombat canVehicleCargo captive captiveNum cbChecked cbSetChecked ceil channelEnabled cheatsEnabled checkAIFeature checkVisibility className clearAllItemsFromBackpack clearBackpackCargo clearBackpackCargoGlobal clearGroupIcons clearItemCargo clearItemCargoGlobal clearItemPool clearMagazineCargo clearMagazineCargoGlobal clearMagazinePool clearOverlay clearRadio clearWeaponCargo clearWeaponCargoGlobal clearWeaponPool clientOwner closeDialog closeDisplay closeOverlay collapseObjectTree collect3DENHistory collectiveRTD combatMode commandArtilleryFire commandChat commander commandFire commandFollow commandFSM commandGetOut commandingMenu commandMove commandRadio commandStop commandSuppressiveFire commandTarget commandWatch comment commitOverlay compile compileFinal completedFSM composeText configClasses configFile configHierarchy configName configProperties configSourceAddonList configSourceMod configSourceModList confirmSensorTarget connectTerminalToUAV controlsGroupCtrl copyFromClipboard copyToClipboard copyWaypoints cos count countEnemy countFriendly countSide countType countUnknown create3DENComposition create3DENEntity createAgent createCenter createDialog createDiaryLink createDiaryRecord createDiarySubject createDisplay createGearDialog createGroup createGuardedPoint createLocation createMarker createMarkerLocal createMenu createMine createMissionDisplay createMPCampaignDisplay createSimpleObject createSimpleTask createSite createSoundSource createTask createTeam createTrigger createUnit createVehicle createVehicleCrew createVehicleLocal crew ctAddHeader ctAddRow ctClear ctCurSel ctData ctFindHeaderRows ctFindRowHeader ctHeaderControls ctHeaderCount ctRemoveHeaders ctRemoveRows ctrlActivate ctrlAddEventHandler ctrlAngle ctrlAutoScrollDelay ctrlAutoScrollRewind ctrlAutoScrollSpeed ctrlChecked ctrlClassName ctrlCommit ctrlCommitted ctrlCreate ctrlDelete ctrlEnable ctrlEnabled ctrlFade ctrlHTMLLoaded ctrlIDC ctrlIDD ctrlMapAnimAdd ctrlMapAnimClear ctrlMapAnimCommit ctrlMapAnimDone ctrlMapCursor ctrlMapMouseOver ctrlMapScale ctrlMapScreenToWorld ctrlMapWorldToScreen ctrlModel ctrlModelDirAndUp ctrlModelScale ctrlParent ctrlParentControlsGroup ctrlPosition ctrlRemoveAllEventHandlers ctrlRemoveEventHandler ctrlScale ctrlSetActiveColor ctrlSetAngle ctrlSetAutoScrollDelay ctrlSetAutoScrollRewind ctrlSetAutoScrollSpeed ctrlSetBackgroundColor ctrlSetChecked ctrlSetEventHandler ctrlSetFade ctrlSetFocus ctrlSetFont ctrlSetFontH1 ctrlSetFontH1B ctrlSetFontH2 ctrlSetFontH2B ctrlSetFontH3 ctrlSetFontH3B ctrlSetFontH4 ctrlSetFontH4B ctrlSetFontH5 ctrlSetFontH5B ctrlSetFontH6 ctrlSetFontH6B ctrlSetFontHeight ctrlSetFontHeightH1 ctrlSetFontHeightH2 ctrlSetFontHeightH3 ctrlSetFontHeightH4 ctrlSetFontHeightH5 ctrlSetFontHeightH6 ctrlSetFontHeightSecondary ctrlSetFontP ctrlSetFontPB ctrlSetFontSecondary ctrlSetForegroundColor ctrlSetModel ctrlSetModelDirAndUp ctrlSetModelScale ctrlSetPixelPrecision ctrlSetPosition ctrlSetScale ctrlSetStructuredText ctrlSetText ctrlSetTextColor ctrlSetTooltip ctrlSetTooltipColorBox ctrlSetTooltipColorShade ctrlSetTooltipColorText ctrlShow ctrlShown ctrlText ctrlTextHeight ctrlTextWidth ctrlType ctrlVisible ctRowControls ctRowCount ctSetCurSel ctSetData ctSetHeaderTemplate ctSetRowTemplate ctSetValue ctValue curatorAddons curatorCamera curatorCameraArea curatorCameraAreaCeiling curatorCoef curatorEditableObjects curatorEditingArea curatorEditingAreaType curatorMouseOver curatorPoints curatorRegisteredObjects curatorSelected curatorWaypointCost current3DENOperation currentChannel currentCommand currentMagazine currentMagazineDetail currentMagazineDetailTurret currentMagazineTurret currentMuzzle currentNamespace currentTask currentTasks currentThrowable currentVisionMode currentWaypoint currentWeapon currentWeaponMode currentWeaponTurret currentZeroing cursorObject cursorTarget customChat customRadio cutFadeOut cutObj cutRsc cutText damage date dateToNumber daytime deActivateKey debriefingText debugFSM debugLog deg delete3DENEntities deleteAt deleteCenter deleteCollection deleteEditorObject deleteGroup deleteGroupWhenEmpty deleteIdentity deleteLocation deleteMarker deleteMarkerLocal deleteRange deleteResources deleteSite deleteStatus deleteTeam deleteVehicle deleteVehicleCrew deleteWaypoint detach detectedMines diag_activeMissionFSMs diag_activeScripts diag_activeSQFScripts diag_activeSQSScripts diag_captureFrame diag_captureFrameToFile diag_captureSlowFrame diag_codePerformance diag_drawMode diag_enable diag_enabled diag_fps diag_fpsMin diag_frameNo diag_lightNewLoad diag_list diag_log diag_logSlowFrame diag_mergeConfigFile diag_recordTurretLimits diag_setLightNew diag_tickTime diag_toggle dialog diarySubjectExists didJIP didJIPOwner difficulty difficultyEnabled difficultyEnabledRTD difficultyOption direction directSay disableAI disableCollisionWith disableConversation disableDebriefingStats disableMapIndicators disableNVGEquipment disableRemoteSensors disableSerialization disableTIEquipment disableUAVConnectability disableUserInput displayAddEventHandler displayCtrl displayParent displayRemoveAllEventHandlers displayRemoveEventHandler displaySetEventHandler dissolveTeam distance distance2D distanceSqr distributionRegion do3DENAction doArtilleryFire doFire doFollow doFSM doGetOut doMove doorPhase doStop doSuppressiveFire doTarget doWatch drawArrow drawEllipse drawIcon drawIcon3D drawLine drawLine3D drawLink drawLocation drawPolygon drawRectangle drawTriangle driver drop dynamicSimulationDistance dynamicSimulationDistanceCoef dynamicSimulationEnabled dynamicSimulationSystemEnabled echo edit3DENMissionAttributes editObject editorSetEventHandler effectiveCommander emptyPositions enableAI enableAIFeature enableAimPrecision enableAttack enableAudioFeature enableAutoStartUpRTD enableAutoTrimRTD enableCamShake enableCaustics enableChannel enableCollisionWith enableCopilot enableDebriefingStats enableDiagLegend enableDynamicSimulation enableDynamicSimulationSystem enableEndDialog enableEngineArtillery enableEnvironment enableFatigue enableGunLights enableInfoPanelComponent enableIRLasers enableMimics enablePersonTurret enableRadio enableReload enableRopeAttach enableSatNormalOnDetail enableSaving enableSentences enableSimulation enableSimulationGlobal enableStamina enableTeamSwitch enableTraffic enableUAVConnectability enableUAVWaypoints enableVehicleCargo enableVehicleSensor enableWeaponDisassembly endLoadingScreen endMission engineOn enginesIsOnRTD enginesRpmRTD enginesTorqueRTD entities environmentEnabled estimatedEndServerTime estimatedTimeLeft evalObjectArgument everyBackpack everyContainer exec execEditorScript execFSM execVM exp expectedDestination exportJIPMessages eyeDirection eyePos face faction fadeMusic fadeRadio fadeSound fadeSpeech failMission fillWeaponsFromPool find findCover findDisplay findEditorObject findEmptyPosition findEmptyPositionReady findIf findNearestEnemy finishMissionInit finite fire fireAtTarget firstBackpack flag flagAnimationPhase flagOwner flagSide flagTexture fleeing floor flyInHeight flyInHeightASL fog fogForecast fogParams forceAddUniform forcedMap forceEnd forceFlagTexture forceFollowRoad forceMap forceRespawn forceSpeed forceWalk forceWeaponFire forceWeatherChange forEachMember forEachMemberAgent forEachMemberTeam forgetTarget format formation formationDirection formationLeader formationMembers formationPosition formationTask formatText formLeader freeLook fromEditor fuel fullCrew gearIDCAmmoCount gearSlotAmmoCount gearSlotData get3DENActionState get3DENAttribute get3DENCamera get3DENConnections get3DENEntity get3DENEntityID get3DENGrid get3DENIconsVisible get3DENLayerEntities get3DENLinesVisible get3DENMissionAttribute get3DENMouseOver get3DENSelected getAimingCoef getAllEnvSoundControllers getAllHitPointsDamage getAllOwnedMines getAllSoundControllers getAmmoCargo getAnimAimPrecision getAnimSpeedCoef getArray getArtilleryAmmo getArtilleryComputerSettings getArtilleryETA getAssignedCuratorLogic getAssignedCuratorUnit getBackpackCargo getBleedingRemaining getBurningValue getCameraViewDirection getCargoIndex getCenterOfMass getClientState getClientStateNumber getCompatiblePylonMagazines getConnectedUAV getContainerMaxLoad getCursorObjectParams getCustomAimCoef getDammage getDescription getDir getDirVisual getDLCAssetsUsage getDLCAssetsUsageByName getDLCs getEditorCamera getEditorMode getEditorObjectScope getElevationOffset getEnvSoundController getFatigue getForcedFlagTexture getFriend getFSMVariable getFuelCargo getGroupIcon getGroupIconParams getGroupIcons getHideFrom getHit getHitIndex getHitPointDamage getItemCargo getMagazineCargo getMarkerColor getMarkerPos getMarkerSize getMarkerType getMass getMissionConfig getMissionConfigValue getMissionDLCs getMissionLayerEntities getModelInfo getMousePosition getMusicPlayedTime getNumber getObjectArgument getObjectChildren getObjectDLC getObjectMaterials getObjectProxy getObjectTextures getObjectType getObjectViewDistance getOxygenRemaining getPersonUsedDLCs getPilotCameraDirection getPilotCameraPosition getPilotCameraRotation getPilotCameraTarget getPlateNumber getPlayerChannel getPlayerScores getPlayerUID getPos getPosASL getPosASLVisual getPosASLW getPosATL getPosATLVisual getPosVisual getPosWorld getPylonMagazines getRelDir getRelPos getRemoteSensorsDisabled getRepairCargo getResolution getShadowDistance getShotParents getSlingLoad getSoundController getSoundControllerResult getSpeed getStamina getStatValue getSuppression getTerrainGrid getTerrainHeightASL getText getTotalDLCUsageTime getUnitLoadout getUnitTrait getUserMFDText getUserMFDvalue getVariable getVehicleCargo getWeaponCargo getWeaponSway getWingsOrientationRTD getWingsPositionRTD getWPPos glanceAt globalChat globalRadio goggles goto group groupChat groupFromNetId groupIconSelectable groupIconsVisible groupId groupOwner groupRadio groupSelectedUnits groupSelectUnit gunner gusts halt handgunItems handgunMagazine handgunWeapon handsHit hasInterface hasPilotCamera hasWeapon hcAllGroups hcGroupParams hcLeader hcRemoveAllGroups hcRemoveGroup hcSelected hcSelectGroup hcSetGroup hcShowBar hcShownBar headgear hideBody hideObject hideObjectGlobal hideSelection hint hintC hintCadet hintSilent hmd hostMission htmlLoad HUDMovementLevels humidity image importAllGroups importance in inArea inAreaArray incapacitatedState inflame inflamed infoPanel infoPanelComponentEnabled infoPanelComponents infoPanels inGameUISetEventHandler inheritsFrom initAmbientLife inPolygon inputAction inRangeOfArtillery insertEditorObject intersect is3DEN is3DENMultiplayer isAbleToBreathe isAgent isArray isAutoHoverOn isAutonomous isAutotest isBleeding isBurning isClass isCollisionLightOn isCopilotEnabled isDamageAllowed isDedicated isDLCAvailable isEngineOn isEqualTo isEqualType isEqualTypeAll isEqualTypeAny isEqualTypeArray isEqualTypeParams isFilePatchingEnabled isFlashlightOn isFlatEmpty isForcedWalk isFormationLeader isGroupDeletedWhenEmpty isHidden isInRemainsCollector isInstructorFigureEnabled isIRLaserOn isKeyActive isKindOf isLaserOn isLightOn isLocalized isManualFire isMarkedForCollection isMultiplayer isMultiplayerSolo isNil isNull isNumber isObjectHidden isObjectRTD isOnRoad isPipEnabled isPlayer isRealTime isRemoteExecuted isRemoteExecutedJIP isServer isShowing3DIcons isSimpleObject isSprintAllowed isStaminaEnabled isSteamMission isStreamFriendlyUIEnabled isText isTouchingGround isTurnedOut isTutHintsEnabled isUAVConnectable isUAVConnected isUIContext isUniformAllowed isVehicleCargo isVehicleRadarOn isVehicleSensorEnabled isWalking isWeaponDeployed isWeaponRested itemCargo items itemsWithMagazines join joinAs joinAsSilent joinSilent joinString kbAddDatabase kbAddDatabaseTargets kbAddTopic kbHasTopic kbReact kbRemoveTopic kbTell kbWasSaid keyImage keyName knowsAbout land landAt landResult language laserTarget lbAdd lbClear lbColor lbColorRight lbCurSel lbData lbDelete lbIsSelected lbPicture lbPictureRight lbSelection lbSetColor lbSetColorRight lbSetCurSel lbSetData lbSetPicture lbSetPictureColor lbSetPictureColorDisabled lbSetPictureColorSelected lbSetPictureRight lbSetPictureRightColor lbSetPictureRightColorDisabled lbSetPictureRightColorSelected lbSetSelectColor lbSetSelectColorRight lbSetSelected lbSetText lbSetTextRight lbSetTooltip lbSetValue lbSize lbSort lbSortByValue lbText lbTextRight lbValue leader leaderboardDeInit leaderboardGetRows leaderboardInit leaderboardRequestRowsFriends leaderboardsRequestUploadScore leaderboardsRequestUploadScoreKeepBest leaderboardState leaveVehicle libraryCredits libraryDisclaimers lifeState lightAttachObject lightDetachObject lightIsOn lightnings limitSpeed linearConversion lineIntersects lineIntersectsObjs lineIntersectsSurfaces lineIntersectsWith linkItem list listObjects listRemoteTargets listVehicleSensors ln lnbAddArray lnbAddColumn lnbAddRow lnbClear lnbColor lnbCurSelRow lnbData lnbDeleteColumn lnbDeleteRow lnbGetColumnsPosition lnbPicture lnbSetColor lnbSetColumnsPos lnbSetCurSelRow lnbSetData lnbSetPicture lnbSetText lnbSetValue lnbSize lnbSort lnbSortByValue lnbText lnbValue load loadAbs loadBackpack loadFile loadGame loadIdentity loadMagazine loadOverlay loadStatus loadUniform loadVest local localize locationPosition lock lockCameraTo lockCargo lockDriver locked lockedCargo lockedDriver lockedTurret lockIdentity lockTurret lockWP log logEntities logNetwork logNetworkTerminate lookAt lookAtPos magazineCargo magazines magazinesAllTurrets magazinesAmmo magazinesAmmoCargo magazinesAmmoFull magazinesDetail magazinesDetailBackpack magazinesDetailUniform magazinesDetailVest magazinesTurret magazineTurretAmmo mapAnimAdd mapAnimClear mapAnimCommit mapAnimDone mapCenterOnCamera mapGridPosition markAsFinishedOnSteam markerAlpha markerBrush markerColor markerDir markerPos markerShape markerSize markerText markerType max members menuAction menuAdd menuChecked menuClear menuCollapse menuData menuDelete menuEnable menuEnabled menuExpand menuHover menuPicture menuSetAction menuSetCheck menuSetData menuSetPicture menuSetValue menuShortcut menuShortcutText menuSize menuSort menuText menuURL menuValue min mineActive mineDetectedBy missionConfigFile missionDifficulty missionName missionNamespace missionStart missionVersion mod modelToWorld modelToWorldVisual modelToWorldVisualWorld modelToWorldWorld modParams moonIntensity moonPhase morale move move3DENCamera moveInAny moveInCargo moveInCommander moveInDriver moveInGunner moveInTurret moveObjectToEnd moveOut moveTime moveTo moveToCompleted moveToFailed musicVolume name nameSound nearEntities nearestBuilding nearestLocation nearestLocations nearestLocationWithDubbing nearestObject nearestObjects nearestTerrainObjects nearObjects nearObjectsReady nearRoads nearSupplies nearTargets needReload netId netObjNull newOverlay nextMenuItemIndex nextWeatherChange nMenuItems not numberOfEnginesRTD numberToDate objectCurators objectFromNetId objectParent objStatus onBriefingGroup onBriefingNotes onBriefingPlan onBriefingTeamSwitch onCommandModeChanged onDoubleClick onEachFrame onGroupIconClick onGroupIconOverEnter onGroupIconOverLeave onHCGroupSelectionChanged onMapSingleClick onPlayerConnected onPlayerDisconnected onPreloadFinished onPreloadStarted onShowNewObject onTeamSwitch openCuratorInterface openDLCPage openMap openSteamApp openYoutubeVideo or orderGetIn overcast overcastForecast owner param params parseNumber parseSimpleArray parseText parsingNamespace particlesQuality pickWeaponPool pitch pixelGrid pixelGridBase pixelGridNoUIScale pixelH pixelW playableSlotsNumber playableUnits playAction playActionNow player playerRespawnTime playerSide playersNumber playGesture playMission playMove playMoveNow playMusic playScriptedMission playSound playSound3D position positionCameraToWorld posScreenToWorld posWorldToScreen ppEffectAdjust ppEffectCommit ppEffectCommitted ppEffectCreate ppEffectDestroy ppEffectEnable ppEffectEnabled ppEffectForceInNVG precision preloadCamera preloadObject preloadSound preloadTitleObj preloadTitleRsc preprocessFile preprocessFileLineNumbers primaryWeapon primaryWeaponItems primaryWeaponMagazine priority processDiaryLink productVersion profileName profileNamespace profileNameSteam progressLoadingScreen progressPosition progressSetPosition publicVariable publicVariableClient publicVariableServer pushBack pushBackUnique putWeaponPool queryItemsPool queryMagazinePool queryWeaponPool rad radioChannelAdd radioChannelCreate radioChannelRemove radioChannelSetCallSign radioChannelSetLabel radioVolume rain rainbow random rank rankId rating rectangular registeredTasks registerTask reload reloadEnabled remoteControl remoteExec remoteExecCall remoteExecutedOwner remove3DENConnection remove3DENEventHandler remove3DENLayer removeAction removeAll3DENEventHandlers removeAllActions removeAllAssignedItems removeAllContainers removeAllCuratorAddons removeAllCuratorCameraAreas removeAllCuratorEditingAreas removeAllEventHandlers removeAllHandgunItems removeAllItems removeAllItemsWithMagazines removeAllMissionEventHandlers removeAllMPEventHandlers removeAllMusicEventHandlers removeAllOwnedMines removeAllPrimaryWeaponItems removeAllWeapons removeBackpack removeBackpackGlobal removeCuratorAddons removeCuratorCameraArea removeCuratorEditableObjects removeCuratorEditingArea removeDrawIcon removeDrawLinks removeEventHandler removeFromRemainsCollector removeGoggles removeGroupIcon removeHandgunItem removeHeadgear removeItem removeItemFromBackpack removeItemFromUniform removeItemFromVest removeItems removeMagazine removeMagazineGlobal removeMagazines removeMagazinesTurret removeMagazineTurret removeMenuItem removeMissionEventHandler removeMPEventHandler removeMusicEventHandler removeOwnedMine removePrimaryWeaponItem removeSecondaryWeaponItem removeSimpleTask removeSwitchableUnit removeTeamMember removeUniform removeVest removeWeapon removeWeaponAttachmentCargo removeWeaponCargo removeWeaponGlobal removeWeaponTurret reportRemoteTarget requiredVersion resetCamShake resetSubgroupDirection resize resources respawnVehicle restartEditorCamera reveal revealMine reverse reversedMouseY roadAt roadsConnectedTo roleDescription ropeAttachedObjects ropeAttachedTo ropeAttachEnabled ropeAttachTo ropeCreate ropeCut ropeDestroy ropeDetach ropeEndPosition ropeLength ropes ropeUnwind ropeUnwound rotorsForcesRTD rotorsRpmRTD round runInitScript safeZoneH safeZoneW safeZoneWAbs safeZoneX safeZoneXAbs safeZoneY save3DENInventory saveGame saveIdentity saveJoysticks saveOverlay saveProfileNamespace saveStatus saveVar savingEnabled say say2D say3D scopeName score scoreSide screenshot screenToWorld scriptDone scriptName scudState secondaryWeapon secondaryWeaponItems secondaryWeaponMagazine select selectBestPlaces selectDiarySubject selectedEditorObjects selectEditorObject selectionNames selectionPosition selectLeader selectMax selectMin selectNoPlayer selectPlayer selectRandom selectRandomWeighted selectWeapon selectWeaponTurret sendAUMessage sendSimpleCommand sendTask sendTaskResult sendUDPMessage serverCommand serverCommandAvailable serverCommandExecutable serverName serverTime set set3DENAttribute set3DENAttributes set3DENGrid set3DENIconsVisible set3DENLayer set3DENLinesVisible set3DENLogicType set3DENMissionAttribute set3DENMissionAttributes set3DENModelsVisible set3DENObjectType set3DENSelected setAccTime setActualCollectiveRTD setAirplaneThrottle setAirportSide setAmmo setAmmoCargo setAmmoOnPylon setAnimSpeedCoef setAperture setApertureNew setArmoryPoints setAttributes setAutonomous setBehaviour setBleedingRemaining setBrakesRTD setCameraInterest setCamShakeDefParams setCamShakeParams setCamUseTI setCaptive setCenterOfMass setCollisionLight setCombatMode setCompassOscillation setConvoySeparation setCuratorCameraAreaCeiling setCuratorCoef setCuratorEditingAreaType setCuratorWaypointCost setCurrentChannel setCurrentTask setCurrentWaypoint setCustomAimCoef setCustomWeightRTD setDamage setDammage setDate setDebriefingText setDefaultCamera setDestination setDetailMapBlendPars setDir setDirection setDrawIcon setDriveOnPath setDropInterval setDynamicSimulationDistance setDynamicSimulationDistanceCoef setEditorMode setEditorObjectScope setEffectCondition setEngineRPMRTD setFace setFaceAnimation setFatigue setFeatureType setFlagAnimationPhase setFlagOwner setFlagSide setFlagTexture setFog setFormation setFormationTask setFormDir setFriend setFromEditor setFSMVariable setFuel setFuelCargo setGroupIcon setGroupIconParams setGroupIconsSelectable setGroupIconsVisible setGroupId setGroupIdGlobal setGroupOwner setGusts setHideBehind setHit setHitIndex setHitPointDamage setHorizonParallaxCoef setHUDMovementLevels setIdentity setImportance setInfoPanel setLeader setLightAmbient setLightAttenuation setLightBrightness setLightColor setLightDayLight setLightFlareMaxDistance setLightFlareSize setLightIntensity setLightnings setLightUseFlare setLocalWindParams setMagazineTurretAmmo setMarkerAlpha setMarkerAlphaLocal setMarkerBrush setMarkerBrushLocal setMarkerColor setMarkerColorLocal setMarkerDir setMarkerDirLocal setMarkerPos setMarkerPosLocal setMarkerShape setMarkerShapeLocal setMarkerSize setMarkerSizeLocal setMarkerText setMarkerTextLocal setMarkerType setMarkerTypeLocal setMass setMimic setMousePosition setMusicEffect setMusicEventHandler setName setNameSound setObjectArguments setObjectMaterial setObjectMaterialGlobal setObjectProxy setObjectTexture setObjectTextureGlobal setObjectViewDistance setOvercast setOwner setOxygenRemaining setParticleCircle setParticleClass setParticleFire setParticleParams setParticleRandom setPilotCameraDirection setPilotCameraRotation setPilotCameraTarget setPilotLight setPiPEffect setPitch setPlateNumber setPlayable setPlayerRespawnTime setPos setPosASL setPosASL2 setPosASLW setPosATL setPosition setPosWorld setPylonLoadOut setPylonsPriority setRadioMsg setRain setRainbow setRandomLip setRank setRectangular setRepairCargo setRotorBrakeRTD setShadowDistance setShotParents setSide setSimpleTaskAlwaysVisible setSimpleTaskCustomData setSimpleTaskDescription setSimpleTaskDestination setSimpleTaskTarget setSimpleTaskType setSimulWeatherLayers setSize setSkill setSlingLoad setSoundEffect setSpeaker setSpeech setSpeedMode setStamina setStaminaScheme setStatValue setSuppression setSystemOfUnits setTargetAge setTaskMarkerOffset setTaskResult setTaskState setTerrainGrid setText setTimeMultiplier setTitleEffect setTrafficDensity setTrafficDistance setTrafficGap setTrafficSpeed setTriggerActivation setTriggerArea setTriggerStatements setTriggerText setTriggerTimeout setTriggerType setType setUnconscious setUnitAbility setUnitLoadout setUnitPos setUnitPosWeak setUnitRank setUnitRecoilCoefficient setUnitTrait setUnloadInCombat setUserActionText setUserMFDText setUserMFDvalue setVariable setVectorDir setVectorDirAndUp setVectorUp setVehicleAmmo setVehicleAmmoDef setVehicleArmor setVehicleCargo setVehicleId setVehicleLock setVehiclePosition setVehicleRadar setVehicleReceiveRemoteTargets setVehicleReportOwnPosition setVehicleReportRemoteTargets setVehicleTIPars setVehicleVarName setVelocity setVelocityModelSpace setVelocityTransformation setViewDistance setVisibleIfTreeCollapsed setWantedRPMRTD setWaves setWaypointBehaviour setWaypointCombatMode setWaypointCompletionRadius setWaypointDescription setWaypointForceBehaviour setWaypointFormation setWaypointHousePosition setWaypointLoiterRadius setWaypointLoiterType setWaypointName setWaypointPosition setWaypointScript setWaypointSpeed setWaypointStatements setWaypointTimeout setWaypointType setWaypointVisible setWeaponReloadingTime setWind setWindDir setWindForce setWindStr setWingForceScaleRTD setWPPos show3DIcons showChat showCinemaBorder showCommandingMenu showCompass showCuratorCompass showGPS showHUD showLegend showMap shownArtilleryComputer shownChat shownCompass shownCuratorCompass showNewEditorObject shownGPS shownHUD shownMap shownPad shownRadio shownScoretable shownUAVFeed shownWarrant shownWatch showPad showRadio showScoretable showSubtitles showUAVFeed showWarrant showWatch showWaypoint showWaypoints side sideChat sideEnemy sideFriendly sideRadio simpleTasks simulationEnabled simulCloudDensity simulCloudOcclusion simulInClouds simulWeatherSync sin size sizeOf skill skillFinal skipTime sleep sliderPosition sliderRange sliderSetPosition sliderSetRange sliderSetSpeed sliderSpeed slingLoadAssistantShown soldierMagazines someAmmo sort soundVolume spawn speaker speed speedMode splitString sqrt squadParams stance startLoadingScreen step stop stopEngineRTD stopped str sunOrMoon supportInfo suppressFor surfaceIsWater surfaceNormal surfaceType swimInDepth switchableUnits switchAction switchCamera switchGesture switchLight switchMove synchronizedObjects synchronizedTriggers synchronizedWaypoints synchronizeObjectsAdd synchronizeObjectsRemove synchronizeTrigger synchronizeWaypoint systemChat systemOfUnits tan targetKnowledge targets targetsAggregate targetsQuery taskAlwaysVisible taskChildren taskCompleted taskCustomData taskDescription taskDestination taskHint taskMarkerOffset taskParent taskResult taskState taskType teamMember teamName teams teamSwitch teamSwitchEnabled teamType terminate terrainIntersect terrainIntersectASL terrainIntersectAtASL text textLog textLogFormat tg time timeMultiplier titleCut titleFadeOut titleObj titleRsc titleText toArray toFixed toLower toString toUpper triggerActivated triggerActivation triggerArea triggerAttachedVehicle triggerAttachObject triggerAttachVehicle triggerDynamicSimulation triggerStatements triggerText triggerTimeout triggerTimeoutCurrent triggerType turretLocal turretOwner turretUnit tvAdd tvClear tvCollapse tvCollapseAll tvCount tvCurSel tvData tvDelete tvExpand tvExpandAll tvPicture tvSetColor tvSetCurSel tvSetData tvSetPicture tvSetPictureColor tvSetPictureColorDisabled tvSetPictureColorSelected tvSetPictureRight tvSetPictureRightColor tvSetPictureRightColorDisabled tvSetPictureRightColorSelected tvSetText tvSetTooltip tvSetValue tvSort tvSortByValue tvText tvTooltip tvValue type typeName typeOf UAVControl uiNamespace uiSleep unassignCurator unassignItem unassignTeam unassignVehicle underwater uniform uniformContainer uniformItems uniformMagazines unitAddons unitAimPosition unitAimPositionVisual unitBackpack unitIsUAV unitPos unitReady unitRecoilCoefficient units unitsBelowHeight unlinkItem unlockAchievement unregisterTask updateDrawIcon updateMenuItem updateObjectTree useAISteeringComponent useAudioTimeForMoves userInputDisabled vectorAdd vectorCos vectorCrossProduct vectorDiff vectorDir vectorDirVisual vectorDistance vectorDistanceSqr vectorDotProduct vectorFromTo vectorMagnitude vectorMagnitudeSqr vectorModelToWorld vectorModelToWorldVisual vectorMultiply vectorNormalized vectorUp vectorUpVisual vectorWorldToModel vectorWorldToModelVisual vehicle vehicleCargoEnabled vehicleChat vehicleRadio vehicleReceiveRemoteTargets vehicleReportOwnPosition vehicleReportRemoteTargets vehicles vehicleVarName velocity velocityModelSpace verifySignature vest vestContainer vestItems vestMagazines viewDistance visibleCompass visibleGPS visibleMap visiblePosition visiblePositionASL visibleScoretable visibleWatch waves waypointAttachedObject waypointAttachedVehicle waypointAttachObject waypointAttachVehicle waypointBehaviour waypointCombatMode waypointCompletionRadius waypointDescription waypointForceBehaviour waypointFormation waypointHousePosition waypointLoiterRadius waypointLoiterType waypointName waypointPosition waypoints waypointScript waypointsEnabledUAV waypointShow waypointSpeed waypointStatements waypointTimeout waypointTimeoutCurrent waypointType waypointVisible weaponAccessories weaponAccessoriesCargo weaponCargo weaponDirection weaponInertia weaponLowered weapons weaponsItems weaponsItemsCargo weaponState weaponsTurret weightRTD WFSideText wind ",
        literal: "blufor civilian configNull controlNull displayNull east endl false grpNull independent lineBreak locationNull nil objNull opfor pi resistance scriptNull sideAmbientLife sideEmpty sideLogic sideUnknown taskNull teamMemberNull true west"
      },
      contains: [A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, A.NUMBER_MODE, B, Q, I, G],
      illegal: /#|^\$ /
    }
  }
  rkA.exports = da9
})
// @from(Start 2163107, End 2175778)
ekA = z((GA8, tkA) => {
  function ua9(A) {
    var B = A.COMMENT("--", "$");
    return {
      name: "SQL (more)",
      aliases: ["mysql", "oracle"],
      disableAutodetect: !0,
      case_insensitive: !0,
      illegal: /[<>{}*]/,
      contains: [{
        beginKeywords: "begin end start commit rollback savepoint lock alter create drop rename call delete do handler insert load replace select truncate update set show pragma grant merge describe use explain help declare prepare execute deallocate release unlock purge reset change stop analyze cache flush optimize repair kill install uninstall checksum restore check backup revoke comment values with",
        end: /;/,
        endsWithParent: !0,
        keywords: {
          $pattern: /[\w\.]+/,
          keyword: "as abort abs absolute acc acce accep accept access accessed accessible account acos action activate add addtime admin administer advanced advise aes_decrypt aes_encrypt after agent aggregate ali alia alias all allocate allow alter always analyze ancillary and anti any anydata anydataset anyschema anytype apply archive archived archivelog are as asc ascii asin assembly assertion associate asynchronous at atan atn2 attr attri attrib attribu attribut attribute attributes audit authenticated authentication authid authors auto autoallocate autodblink autoextend automatic availability avg backup badfile basicfile before begin beginning benchmark between bfile bfile_base big bigfile bin binary_double binary_float binlog bit_and bit_count bit_length bit_or bit_xor bitmap blob_base block blocksize body both bound bucket buffer_cache buffer_pool build bulk by byte byteordermark bytes cache caching call calling cancel capacity cascade cascaded case cast catalog category ceil ceiling chain change changed char_base char_length character_length characters characterset charindex charset charsetform charsetid check checksum checksum_agg child choose chr chunk class cleanup clear client clob clob_base clone close cluster_id cluster_probability cluster_set clustering coalesce coercibility col collate collation collect colu colum column column_value columns columns_updated comment commit compact compatibility compiled complete composite_limit compound compress compute concat concat_ws concurrent confirm conn connec connect connect_by_iscycle connect_by_isleaf connect_by_root connect_time connection consider consistent constant constraint constraints constructor container content contents context contributors controlfile conv convert convert_tz corr corr_k corr_s corresponding corruption cos cost count count_big counted covar_pop covar_samp cpu_per_call cpu_per_session crc32 create creation critical cross cube cume_dist curdate current current_date current_time current_timestamp current_user cursor curtime customdatum cycle data database databases datafile datafiles datalength date_add date_cache date_format date_sub dateadd datediff datefromparts datename datepart datetime2fromparts day day_to_second dayname dayofmonth dayofweek dayofyear days db_role_change dbtimezone ddl deallocate declare decode decompose decrement decrypt deduplicate def defa defau defaul default defaults deferred defi defin define degrees delayed delegate delete delete_all delimited demand dense_rank depth dequeue des_decrypt des_encrypt des_key_file desc descr descri describ describe descriptor deterministic diagnostics difference dimension direct_load directory disable disable_all disallow disassociate discardfile disconnect diskgroup distinct distinctrow distribute distributed div do document domain dotnet double downgrade drop dumpfile duplicate duration each edition editionable editions element ellipsis else elsif elt empty enable enable_all enclosed encode encoding encrypt end end-exec endian enforced engine engines enqueue enterprise entityescaping eomonth error errors escaped evalname evaluate event eventdata events except exception exceptions exchange exclude excluding execu execut execute exempt exists exit exp expire explain explode export export_set extended extent external external_1 external_2 externally extract failed failed_login_attempts failover failure far fast feature_set feature_value fetch field fields file file_name_convert filesystem_like_logging final finish first first_value fixed flash_cache flashback floor flush following follows for forall force foreign form forma format found found_rows freelist freelists freepools fresh from from_base64 from_days ftp full function general generated get get_format get_lock getdate getutcdate global global_name globally go goto grant grants greatest group group_concat group_id grouping grouping_id groups gtid_subtract guarantee guard handler hash hashkeys having hea head headi headin heading heap help hex hierarchy high high_priority hosts hour hours http id ident_current ident_incr ident_seed identified identity idle_time if ifnull ignore iif ilike ilm immediate import in include including increment index indexes indexing indextype indicator indices inet6_aton inet6_ntoa inet_aton inet_ntoa infile initial initialized initially initrans inmemory inner innodb input insert install instance instantiable instr interface interleaved intersect into invalidate invisible is is_free_lock is_ipv4 is_ipv4_compat is_not is_not_null is_used_lock isdate isnull isolation iterate java join json json_exists keep keep_duplicates key keys kill language large last last_day last_insert_id last_value lateral lax lcase lead leading least leaves left len lenght length less level levels library like like2 like4 likec limit lines link list listagg little ln load load_file lob lobs local localtime localtimestamp locate locator lock locked log log10 log2 logfile logfiles logging logical logical_reads_per_call logoff logon logs long loop low low_priority lower lpad lrtrim ltrim main make_set makedate maketime managed management manual map mapping mask master master_pos_wait match matched materialized max maxextents maximize maxinstances maxlen maxlogfiles maxloghistory maxlogmembers maxsize maxtrans md5 measures median medium member memcompress memory merge microsecond mid migration min minextents minimum mining minus minute minutes minvalue missing mod mode model modification modify module monitoring month months mount move movement multiset mutex name name_const names nan national native natural nav nchar nclob nested never new newline next nextval no no_write_to_binlog noarchivelog noaudit nobadfile nocheck nocompress nocopy nocycle nodelay nodiscardfile noentityescaping noguarantee nokeep nologfile nomapping nomaxvalue nominimize nominvalue nomonitoring none noneditionable nonschema noorder nopr nopro noprom nopromp noprompt norely noresetlogs noreverse normal norowdependencies noschemacheck noswitch not nothing notice notnull notrim novalidate now nowait nth_value nullif nulls num numb numbe nvarchar nvarchar2 object ocicoll ocidate ocidatetime ociduration ociinterval ociloblocator ocinumber ociref ocirefcursor ocirowid ocistring ocitype oct octet_length of off offline offset oid oidindex old on online only opaque open operations operator optimal optimize option optionally or oracle oracle_date oradata ord ordaudio orddicom orddoc order ordimage ordinality ordvideo organization orlany orlvary out outer outfile outline output over overflow overriding package pad parallel parallel_enable parameters parent parse partial partition partitions pascal passing password password_grace_time password_lock_time password_reuse_max password_reuse_time password_verify_function patch path patindex pctincrease pctthreshold pctused pctversion percent percent_rank percentile_cont percentile_disc performance period period_add period_diff permanent physical pi pipe pipelined pivot pluggable plugin policy position post_transaction pow power pragma prebuilt precedes preceding precision prediction prediction_cost prediction_details prediction_probability prediction_set prepare present preserve prior priority private private_sga privileges procedural procedure procedure_analyze processlist profiles project prompt protection public publishingservername purge quarter query quick quiesce quota quotename radians raise rand range rank raw read reads readsize rebuild record records recover recovery recursive recycle redo reduced ref reference referenced references referencing refresh regexp_like register regr_avgx regr_avgy regr_count regr_intercept regr_r2 regr_slope regr_sxx regr_sxy reject rekey relational relative relaylog release release_lock relies_on relocate rely rem remainder rename repair repeat replace replicate replication required reset resetlogs resize resource respect restore restricted result result_cache resumable resume retention return returning returns reuse reverse revoke right rlike role roles rollback rolling rollup round row row_count rowdependencies rowid rownum rows rtrim rules safe salt sample save savepoint sb1 sb2 sb4 scan schema schemacheck scn scope scroll sdo_georaster sdo_topo_geometry search sec_to_time second seconds section securefile security seed segment select self semi sequence sequential serializable server servererror session session_user sessions_per_user set sets settings sha sha1 sha2 share shared shared_pool short show shrink shutdown si_averagecolor si_colorhistogram si_featurelist si_positionalcolor si_stillimage si_texture siblings sid sign sin size size_t sizes skip slave sleep smalldatetimefromparts smallfile snapshot some soname sort soundex source space sparse spfile split sql sql_big_result sql_buffer_result sql_cache sql_calc_found_rows sql_small_result sql_variant_property sqlcode sqldata sqlerror sqlname sqlstate sqrt square standalone standby start starting startup statement static statistics stats_binomial_test stats_crosstab stats_ks_test stats_mode stats_mw_test stats_one_way_anova stats_t_test_ stats_t_test_indep stats_t_test_one stats_t_test_paired stats_wsr_test status std stddev stddev_pop stddev_samp stdev stop storage store stored str str_to_date straight_join strcmp strict string struct stuff style subdate subpartition subpartitions substitutable substr substring subtime subtring_index subtype success sum suspend switch switchoffset switchover sync synchronous synonym sys sys_xmlagg sysasm sysaux sysdate sysdatetimeoffset sysdba sysoper system system_user sysutcdatetime table tables tablespace tablesample tan tdo template temporary terminated tertiary_weights test than then thread through tier ties time time_format time_zone timediff timefromparts timeout timestamp timestampadd timestampdiff timezone_abbr timezone_minute timezone_region to to_base64 to_date to_days to_seconds todatetimeoffset trace tracking transaction transactional translate translation treat trigger trigger_nestlevel triggers trim truncate try_cast try_convert try_parse type ub1 ub2 ub4 ucase unarchived unbounded uncompress under undo unhex unicode uniform uninstall union unique unix_timestamp unknown unlimited unlock unnest unpivot unrecoverable unsafe unsigned until untrusted unusable unused update updated upgrade upped upper upsert url urowid usable usage use use_stored_outlines user user_data user_resources users using utc_date utc_timestamp uuid uuid_short validate validate_password_strength validation valist value values var var_samp varcharc vari varia variab variabl variable variables variance varp varraw varrawc varray verify version versions view virtual visible void wait wallet warning warnings week weekday weekofyear wellformed when whene whenev wheneve whenever where while whitespace window with within without work wrapped xdb xml xmlagg xmlattributes xmlcast xmlcolattval xmlelement xmlexists xmlforest xmlindex xmlnamespaces xmlpi xmlquery xmlroot xmlschema xmlserialize xmltable xmltype xor year year_to_month years yearweek",
          literal: "true false null unknown",
          built_in: "array bigint binary bit blob bool boolean char character date dec decimal float int int8 integer interval number numeric real record serial serial8 smallint text time timestamp tinyint varchar varchar2 varying void"
        },
        contains: [{
          className: "string",
          begin: "'",
          end: "'",
          contains: [{
            begin: "''"
          }]
        }, {
          className: "string",
          begin: '"',
          end: '"',
          contains: [{
            begin: '""'
          }]
        }, {
          className: "string",
          begin: "`",
          end: "`"
        }, A.C_NUMBER_MODE, A.C_BLOCK_COMMENT_MODE, B, A.HASH_COMMENT_MODE]
      }, A.C_BLOCK_COMMENT_MODE, B, A.HASH_COMMENT_MODE]
    }
  }
  tkA.exports = ua9
})
// @from(Start 2175784, End 2183850)
QxA = z((ZA8, BxA) => {
  function AxA(A) {
    if (!A) return null;
    if (typeof A === "string") return A;
    return A.source
  }

  function pa9(...A) {
    return A.map((Q) => AxA(Q)).join("")
  }

  function pT1(...A) {
    return "(" + A.map((Q) => AxA(Q)).join("|") + ")"
  }

  function ca9(A) {
    let B = A.COMMENT("--", "$"),
      Q = {
        className: "string",
        variants: [{
          begin: /'/,
          end: /'/,
          contains: [{
            begin: /''/
          }]
        }]
      },
      I = {
        begin: /"/,
        end: /"/,
        contains: [{
          begin: /""/
        }]
      },
      G = ["true", "false", "unknown"],
      Z = ["double precision", "large object", "with timezone", "without timezone"],
      D = ["bigint", "binary", "blob", "boolean", "char", "character", "clob", "date", "dec", "decfloat", "decimal", "float", "int", "integer", "interval", "nchar", "nclob", "national", "numeric", "real", "row", "smallint", "time", "timestamp", "varchar", "varying", "varbinary"],
      Y = ["add", "asc", "collation", "desc", "final", "first", "last", "view"],
      W = ["abs", "acos", "all", "allocate", "alter", "and", "any", "are", "array", "array_agg", "array_max_cardinality", "as", "asensitive", "asin", "asymmetric", "at", "atan", "atomic", "authorization", "avg", "begin", "begin_frame", "begin_partition", "between", "bigint", "binary", "blob", "boolean", "both", "by", "call", "called", "cardinality", "cascaded", "case", "cast", "ceil", "ceiling", "char", "char_length", "character", "character_length", "check", "classifier", "clob", "close", "coalesce", "collate", "collect", "column", "commit", "condition", "connect", "constraint", "contains", "convert", "copy", "corr", "corresponding", "cos", "cosh", "count", "covar_pop", "covar_samp", "create", "cross", "cube", "cume_dist", "current", "current_catalog", "current_date", "current_default_transform_group", "current_path", "current_role", "current_row", "current_schema", "current_time", "current_timestamp", "current_path", "current_role", "current_transform_group_for_type", "current_user", "cursor", "cycle", "date", "day", "deallocate", "dec", "decimal", "decfloat", "declare", "default", "define", "delete", "dense_rank", "deref", "describe", "deterministic", "disconnect", "distinct", "double", "drop", "dynamic", "each", "element", "else", "empty", "end", "end_frame", "end_partition", "end-exec", "equals", "escape", "every", "except", "exec", "execute", "exists", "exp", "external", "extract", "false", "fetch", "filter", "first_value", "float", "floor", "for", "foreign", "frame_row", "free", "from", "full", "function", "fusion", "get", "global", "grant", "group", "grouping", "groups", "having", "hold", "hour", "identity", "in", "indicator", "initial", "inner", "inout", "insensitive", "insert", "int", "integer", "intersect", "intersection", "interval", "into", "is", "join", "json_array", "json_arrayagg", "json_exists", "json_object", "json_objectagg", "json_query", "json_table", "json_table_primitive", "json_value", "lag", "language", "large", "last_value", "lateral", "lead", "leading", "left", "like", "like_regex", "listagg", "ln", "local", "localtime", "localtimestamp", "log", "log10", "lower", "match", "match_number", "match_recognize", "matches", "max", "member", "merge", "method", "min", "minute", "mod", "modifies", "module", "month", "multiset", "national", "natural", "nchar", "nclob", "new", "no", "none", "normalize", "not", "nth_value", "ntile", "null", "nullif", "numeric", "octet_length", "occurrences_regex", "of", "offset", "old", "omit", "on", "one", "only", "open", "or", "order", "out", "outer", "over", "overlaps", "overlay", "parameter", "partition", "pattern", "per", "percent", "percent_rank", "percentile_cont", "percentile_disc", "period", "portion", "position", "position_regex", "power", "precedes", "precision", "prepare", "primary", "procedure", "ptf", "range", "rank", "reads", "real", "recursive", "ref", "references", "referencing", "regr_avgx", "regr_avgy", "regr_count", "regr_intercept", "regr_r2", "regr_slope", "regr_sxx", "regr_sxy", "regr_syy", "release", "result", "return", "returns", "revoke", "right", "rollback", "rollup", "row", "row_number", "rows", "running", "savepoint", "scope", "scroll", "search", "second", "seek", "select", "sensitive", "session_user", "set", "show", "similar", "sin", "sinh", "skip", "smallint", "some", "specific", "specifictype", "sql", "sqlexception", "sqlstate", "sqlwarning", "sqrt", "start", "static", "stddev_pop", "stddev_samp", "submultiset", "subset", "substring", "substring_regex", "succeeds", "sum", "symmetric", "system", "system_time", "system_user", "table", "tablesample", "tan", "tanh", "then", "time", "timestamp", "timezone_hour", "timezone_minute", "to", "trailing", "translate", "translate_regex", "translation", "treat", "trigger", "trim", "trim_array", "true", "truncate", "uescape", "union", "unique", "unknown", "unnest", "update   ", "upper", "user", "using", "value", "values", "value_of", "var_pop", "var_samp", "varbinary", "varchar", "varying", "versioning", "when", "whenever", "where", "width_bucket", "window", "with", "within", "without", "year"],
      J = ["abs", "acos", "array_agg", "asin", "atan", "avg", "cast", "ceil", "ceiling", "coalesce", "corr", "cos", "cosh", "count", "covar_pop", "covar_samp", "cume_dist", "dense_rank", "deref", "element", "exp", "extract", "first_value", "floor", "json_array", "json_arrayagg", "json_exists", "json_object", "json_objectagg", "json_query", "json_table", "json_table_primitive", "json_value", "lag", "last_value", "lead", "listagg", "ln", "log", "log10", "lower", "max", "min", "mod", "nth_value", "ntile", "nullif", "percent_rank", "percentile_cont", "percentile_disc", "position", "position_regex", "power", "rank", "regr_avgx", "regr_avgy", "regr_count", "regr_intercept", "regr_r2", "regr_slope", "regr_sxx", "regr_sxy", "regr_syy", "row_number", "sin", "sinh", "sqrt", "stddev_pop", "stddev_samp", "substring", "substring_regex", "sum", "tan", "tanh", "translate", "translate_regex", "treat", "trim", "trim_array", "unnest", "upper", "value_of", "var_pop", "var_samp", "width_bucket"],
      F = ["current_catalog", "current_date", "current_default_transform_group", "current_path", "current_role", "current_schema", "current_transform_group_for_type", "current_user", "session_user", "system_time", "system_user", "current_time", "localtime", "current_timestamp", "localtimestamp"],
      X = ["create table", "insert into", "primary key", "foreign key", "not null", "alter table", "add constraint", "grouping sets", "on overflow", "character set", "respect nulls", "ignore nulls", "nulls first", "nulls last", "depth first", "breadth first"],
      V = J,
      C = [...W, ...Y].filter((O) => {
        return !J.includes(O)
      }),
      K = {
        className: "variable",
        begin: /@[a-z0-9]+/
      },
      E = {
        className: "operator",
        begin: /[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/,
        relevance: 0
      },
      N = {
        begin: pa9(/\b/, pT1(...V), /\s*\(/),
        keywords: {
          built_in: V
        }
      };

    function q(O, {
      exceptions: R,
      when: T
    } = {}) {
      let L = T;
      return R = R || [], O.map((_) => {
        if (_.match(/\|\d+$/) || R.includes(_)) return _;
        else if (L(_)) return `${_}|0`;
        else return _
      })
    }
    return {
      name: "SQL",
      case_insensitive: !0,
      illegal: /[{}]|<\//,
      keywords: {
        $pattern: /\b[\w\.]+/,
        keyword: q(C, {
          when: (O) => O.length < 3
        }),
        literal: G,
        type: D,
        built_in: F
      },
      contains: [{
        begin: pT1(...X),
        keywords: {
          $pattern: /[\w\.]+/,
          keyword: C.concat(X),
          literal: G,
          type: D
        }
      }, {
        className: "type",
        begin: pT1(...Z)
      }, N, K, Q, I, A.C_NUMBER_MODE, A.C_BLOCK_COMMENT_MODE, B, E]
    }
  }
  BxA.exports = ca9
})
// @from(Start 2183856, End 2192258)
GxA = z((DA8, IxA) => {
  function la9(A) {
    let B = ["functions", "model", "data", "parameters", "quantities", "transformed", "generated"],
      Q = ["for", "in", "if", "else", "while", "break", "continue", "return"],
      I = ["print", "reject", "increment_log_prob|10", "integrate_ode|10", "integrate_ode_rk45|10", "integrate_ode_bdf|10", "algebra_solver"],
      G = ["int", "real", "vector", "ordered", "positive_ordered", "simplex", "unit_vector", "row_vector", "matrix", "cholesky_factor_corr|10", "cholesky_factor_cov|10", "corr_matrix|10", "cov_matrix|10", "void"],
      Z = ["Phi", "Phi_approx", "abs", "acos", "acosh", "algebra_solver", "append_array", "append_col", "append_row", "asin", "asinh", "atan", "atan2", "atanh", "bernoulli_cdf", "bernoulli_lccdf", "bernoulli_lcdf", "bernoulli_logit_lpmf", "bernoulli_logit_rng", "bernoulli_lpmf", "bernoulli_rng", "bessel_first_kind", "bessel_second_kind", "beta_binomial_cdf", "beta_binomial_lccdf", "beta_binomial_lcdf", "beta_binomial_lpmf", "beta_binomial_rng", "beta_cdf", "beta_lccdf", "beta_lcdf", "beta_lpdf", "beta_rng", "binary_log_loss", "binomial_cdf", "binomial_coefficient_log", "binomial_lccdf", "binomial_lcdf", "binomial_logit_lpmf", "binomial_lpmf", "binomial_rng", "block", "categorical_logit_lpmf", "categorical_logit_rng", "categorical_lpmf", "categorical_rng", "cauchy_cdf", "cauchy_lccdf", "cauchy_lcdf", "cauchy_lpdf", "cauchy_rng", "cbrt", "ceil", "chi_square_cdf", "chi_square_lccdf", "chi_square_lcdf", "chi_square_lpdf", "chi_square_rng", "cholesky_decompose", "choose", "col", "cols", "columns_dot_product", "columns_dot_self", "cos", "cosh", "cov_exp_quad", "crossprod", "csr_extract_u", "csr_extract_v", "csr_extract_w", "csr_matrix_times_vector", "csr_to_dense_matrix", "cumulative_sum", "determinant", "diag_matrix", "diag_post_multiply", "diag_pre_multiply", "diagonal", "digamma", "dims", "dirichlet_lpdf", "dirichlet_rng", "distance", "dot_product", "dot_self", "double_exponential_cdf", "double_exponential_lccdf", "double_exponential_lcdf", "double_exponential_lpdf", "double_exponential_rng", "e", "eigenvalues_sym", "eigenvectors_sym", "erf", "erfc", "exp", "exp2", "exp_mod_normal_cdf", "exp_mod_normal_lccdf", "exp_mod_normal_lcdf", "exp_mod_normal_lpdf", "exp_mod_normal_rng", "expm1", "exponential_cdf", "exponential_lccdf", "exponential_lcdf", "exponential_lpdf", "exponential_rng", "fabs", "falling_factorial", "fdim", "floor", "fma", "fmax", "fmin", "fmod", "frechet_cdf", "frechet_lccdf", "frechet_lcdf", "frechet_lpdf", "frechet_rng", "gamma_cdf", "gamma_lccdf", "gamma_lcdf", "gamma_lpdf", "gamma_p", "gamma_q", "gamma_rng", "gaussian_dlm_obs_lpdf", "get_lp", "gumbel_cdf", "gumbel_lccdf", "gumbel_lcdf", "gumbel_lpdf", "gumbel_rng", "head", "hypergeometric_lpmf", "hypergeometric_rng", "hypot", "inc_beta", "int_step", "integrate_ode", "integrate_ode_bdf", "integrate_ode_rk45", "inv", "inv_Phi", "inv_chi_square_cdf", "inv_chi_square_lccdf", "inv_chi_square_lcdf", "inv_chi_square_lpdf", "inv_chi_square_rng", "inv_cloglog", "inv_gamma_cdf", "inv_gamma_lccdf", "inv_gamma_lcdf", "inv_gamma_lpdf", "inv_gamma_rng", "inv_logit", "inv_sqrt", "inv_square", "inv_wishart_lpdf", "inv_wishart_rng", "inverse", "inverse_spd", "is_inf", "is_nan", "lbeta", "lchoose", "lgamma", "lkj_corr_cholesky_lpdf", "lkj_corr_cholesky_rng", "lkj_corr_lpdf", "lkj_corr_rng", "lmgamma", "lmultiply", "log", "log10", "log1m", "log1m_exp", "log1m_inv_logit", "log1p", "log1p_exp", "log2", "log_determinant", "log_diff_exp", "log_falling_factorial", "log_inv_logit", "log_mix", "log_rising_factorial", "log_softmax", "log_sum_exp", "logistic_cdf", "logistic_lccdf", "logistic_lcdf", "logistic_lpdf", "logistic_rng", "logit", "lognormal_cdf", "lognormal_lccdf", "lognormal_lcdf", "lognormal_lpdf", "lognormal_rng", "machine_precision", "matrix_exp", "max", "mdivide_left_spd", "mdivide_left_tri_low", "mdivide_right_spd", "mdivide_right_tri_low", "mean", "min", "modified_bessel_first_kind", "modified_bessel_second_kind", "multi_gp_cholesky_lpdf", "multi_gp_lpdf", "multi_normal_cholesky_lpdf", "multi_normal_cholesky_rng", "multi_normal_lpdf", "multi_normal_prec_lpdf", "multi_normal_rng", "multi_student_t_lpdf", "multi_student_t_rng", "multinomial_lpmf", "multinomial_rng", "multiply_log", "multiply_lower_tri_self_transpose", "neg_binomial_2_cdf", "neg_binomial_2_lccdf", "neg_binomial_2_lcdf", "neg_binomial_2_log_lpmf", "neg_binomial_2_log_rng", "neg_binomial_2_lpmf", "neg_binomial_2_rng", "neg_binomial_cdf", "neg_binomial_lccdf", "neg_binomial_lcdf", "neg_binomial_lpmf", "neg_binomial_rng", "negative_infinity", "normal_cdf", "normal_lccdf", "normal_lcdf", "normal_lpdf", "normal_rng", "not_a_number", "num_elements", "ordered_logistic_lpmf", "ordered_logistic_rng", "owens_t", "pareto_cdf", "pareto_lccdf", "pareto_lcdf", "pareto_lpdf", "pareto_rng", "pareto_type_2_cdf", "pareto_type_2_lccdf", "pareto_type_2_lcdf", "pareto_type_2_lpdf", "pareto_type_2_rng", "pi", "poisson_cdf", "poisson_lccdf", "poisson_lcdf", "poisson_log_lpmf", "poisson_log_rng", "poisson_lpmf", "poisson_rng", "positive_infinity", "pow", "print", "prod", "qr_Q", "qr_R", "quad_form", "quad_form_diag", "quad_form_sym", "rank", "rayleigh_cdf", "rayleigh_lccdf", "rayleigh_lcdf", "rayleigh_lpdf", "rayleigh_rng", "reject", "rep_array", "rep_matrix", "rep_row_vector", "rep_vector", "rising_factorial", "round", "row", "rows", "rows_dot_product", "rows_dot_self", "scaled_inv_chi_square_cdf", "scaled_inv_chi_square_lccdf", "scaled_inv_chi_square_lcdf", "scaled_inv_chi_square_lpdf", "scaled_inv_chi_square_rng", "sd", "segment", "sin", "singular_values", "sinh", "size", "skew_normal_cdf", "skew_normal_lccdf", "skew_normal_lcdf", "skew_normal_lpdf", "skew_normal_rng", "softmax", "sort_asc", "sort_desc", "sort_indices_asc", "sort_indices_desc", "sqrt", "sqrt2", "square", "squared_distance", "step", "student_t_cdf", "student_t_lccdf", "student_t_lcdf", "student_t_lpdf", "student_t_rng", "sub_col", "sub_row", "sum", "tail", "tan", "tanh", "target", "tcrossprod", "tgamma", "to_array_1d", "to_array_2d", "to_matrix", "to_row_vector", "to_vector", "trace", "trace_gen_quad_form", "trace_quad_form", "trigamma", "trunc", "uniform_cdf", "uniform_lccdf", "uniform_lcdf", "uniform_lpdf", "uniform_rng", "variance", "von_mises_lpdf", "von_mises_rng", "weibull_cdf", "weibull_lccdf", "weibull_lcdf", "weibull_lpdf", "weibull_rng", "wiener_lpdf", "wishart_lpdf", "wishart_rng"],
      D = ["bernoulli", "bernoulli_logit", "beta", "beta_binomial", "binomial", "binomial_logit", "categorical", "categorical_logit", "cauchy", "chi_square", "dirichlet", "double_exponential", "exp_mod_normal", "exponential", "frechet", "gamma", "gaussian_dlm_obs", "gumbel", "hypergeometric", "inv_chi_square", "inv_gamma", "inv_wishart", "lkj_corr", "lkj_corr_cholesky", "logistic", "lognormal", "multi_gp", "multi_gp_cholesky", "multi_normal", "multi_normal_cholesky", "multi_normal_prec", "multi_student_t", "multinomial", "neg_binomial", "neg_binomial_2", "neg_binomial_2_log", "normal", "ordered_logistic", "pareto", "pareto_type_2", "poisson", "poisson_log", "rayleigh", "scaled_inv_chi_square", "skew_normal", "student_t", "uniform", "von_mises", "weibull", "wiener", "wishart"];
    return {
      name: "Stan",
      aliases: ["stanfuncs"],
      keywords: {
        $pattern: A.IDENT_RE,
        title: B,
        keyword: Q.concat(G).concat(I),
        built_in: Z
      },
      contains: [A.C_LINE_COMMENT_MODE, A.COMMENT(/#/, /$/, {
        relevance: 0,
        keywords: {
          "meta-keyword": "include"
        }
      }), A.COMMENT(/\/\*/, /\*\//, {
        relevance: 0,
        contains: [{
          className: "doctag",
          begin: /@(return|param)/
        }]
      }), {
        begin: /<\s*lower\s*=/,
        keywords: "lower"
      }, {
        begin: /[<,]\s*upper\s*=/,
        keywords: "upper"
      }, {
        className: "keyword",
        begin: /\btarget\s*\+=/,
        relevance: 10
      }, {
        begin: "~\\s*(" + A.IDENT_RE + ")\\s*\\(",
        keywords: D
      }, {
        className: "number",
        variants: [{
          begin: /\b\d+(?:\.\d*)?(?:[eE][+-]?\d+)?/
        }, {
          begin: /\.\d+(?:[eE][+-]?\d+)?\b/
        }],
        relevance: 0
      }, {
        className: "string",
        begin: '"',
        end: '"',
        relevance: 0
      }]
    }
  }
  IxA.exports = la9
})
// @from(Start 2192264, End 2209207)
DxA = z((YA8, ZxA) => {
  function ia9(A) {
    return {
      name: "Stata",
      aliases: ["do", "ado"],
      case_insensitive: !0,
      keywords: "if else in foreach for forv forva forval forvalu forvalue forvalues by bys bysort xi quietly qui capture about ac ac_7 acprplot acprplot_7 adjust ado adopath adoupdate alpha ameans an ano anov anova anova_estat anova_terms anovadef aorder ap app appe appen append arch arch_dr arch_estat arch_p archlm areg areg_p args arima arima_dr arima_estat arima_p as asmprobit asmprobit_estat asmprobit_lf asmprobit_mfx__dlg asmprobit_p ass asse asser assert avplot avplot_7 avplots avplots_7 bcskew0 bgodfrey bias binreg bip0_lf biplot bipp_lf bipr_lf bipr_p biprobit bitest bitesti bitowt blogit bmemsize boot bootsamp bootstrap bootstrap_8 boxco_l boxco_p boxcox boxcox_6 boxcox_p bprobit br break brier bro brow brows browse brr brrstat bs bs_7 bsampl_w bsample bsample_7 bsqreg bstat bstat_7 bstat_8 bstrap bstrap_7 bubble bubbleplot ca ca_estat ca_p cabiplot camat canon canon_8 canon_8_p canon_estat canon_p cap caprojection capt captu captur capture cat cc cchart cchart_7 cci cd censobs_table centile cf char chdir checkdlgfiles checkestimationsample checkhlpfiles checksum chelp ci cii cl class classutil clear cli clis clist clo clog clog_lf clog_p clogi clogi_sw clogit clogit_lf clogit_p clogitp clogl_sw cloglog clonevar clslistarray cluster cluster_measures cluster_stop cluster_tree cluster_tree_8 clustermat cmdlog cnr cnre cnreg cnreg_p cnreg_sw cnsreg codebook collaps4 collapse colormult_nb colormult_nw compare compress conf confi confir confirm conren cons const constr constra constrai constrain constraint continue contract copy copyright copysource cor corc corr corr2data corr_anti corr_kmo corr_smc corre correl correla correlat correlate corrgram cou coun count cox cox_p cox_sw coxbase coxhaz coxvar cprplot cprplot_7 crc cret cretu cretur creturn cross cs cscript cscript_log csi ct ct_is ctset ctst_5 ctst_st cttost cumsp cumsp_7 cumul cusum cusum_7 cutil d|0 datasig datasign datasigna datasignat datasignatu datasignatur datasignature datetof db dbeta de dec deco decod decode deff des desc descr descri describ describe destring dfbeta dfgls dfuller di di_g dir dirstats dis discard disp disp_res disp_s displ displa display distinct do doe doed doedi doedit dotplot dotplot_7 dprobit drawnorm drop ds ds_util dstdize duplicates durbina dwstat dydx e|0 ed edi edit egen eivreg emdef en enc enco encod encode eq erase ereg ereg_lf ereg_p ereg_sw ereghet ereghet_glf ereghet_glf_sh ereghet_gp ereghet_ilf ereghet_ilf_sh ereghet_ip eret eretu eretur ereturn err erro error esize est est_cfexist est_cfname est_clickable est_expand est_hold est_table est_unhold est_unholdok estat estat_default estat_summ estat_vce_only esti estimates etodow etof etomdy ex exi exit expand expandcl fac fact facto factor factor_estat factor_p factor_pca_rotated factor_rotate factormat fcast fcast_compute fcast_graph fdades fdadesc fdadescr fdadescri fdadescrib fdadescribe fdasav fdasave fdause fh_st file open file read file close file filefilter fillin find_hlp_file findfile findit findit_7 fit fl fli flis flist for5_0 forest forestplot form forma format fpredict frac_154 frac_adj frac_chk frac_cox frac_ddp frac_dis frac_dv frac_in frac_mun frac_pp frac_pq frac_pv frac_wgt frac_xo fracgen fracplot fracplot_7 fracpoly fracpred fron_ex fron_hn fron_p fron_tn fron_tn2 frontier ftodate ftoe ftomdy ftowdate funnel funnelplot g|0 gamhet_glf gamhet_gp gamhet_ilf gamhet_ip gamma gamma_d2 gamma_p gamma_sw gammahet gdi_hexagon gdi_spokes ge gen gene gener genera generat generate genrank genstd genvmean gettoken gl gladder gladder_7 glim_l01 glim_l02 glim_l03 glim_l04 glim_l05 glim_l06 glim_l07 glim_l08 glim_l09 glim_l10 glim_l11 glim_l12 glim_lf glim_mu glim_nw1 glim_nw2 glim_nw3 glim_p glim_v1 glim_v2 glim_v3 glim_v4 glim_v5 glim_v6 glim_v7 glm glm_6 glm_p glm_sw glmpred glo glob globa global glogit glogit_8 glogit_p gmeans gnbre_lf gnbreg gnbreg_5 gnbreg_p gomp_lf gompe_sw gomper_p gompertz gompertzhet gomphet_glf gomphet_glf_sh gomphet_gp gomphet_ilf gomphet_ilf_sh gomphet_ip gphdot gphpen gphprint gprefs gprobi_p gprobit gprobit_8 gr gr7 gr_copy gr_current gr_db gr_describe gr_dir gr_draw gr_draw_replay gr_drop gr_edit gr_editviewopts gr_example gr_example2 gr_export gr_print gr_qscheme gr_query gr_read gr_rename gr_replay gr_save gr_set gr_setscheme gr_table gr_undo gr_use graph graph7 grebar greigen greigen_7 greigen_8 grmeanby grmeanby_7 gs_fileinfo gs_filetype gs_graphinfo gs_stat gsort gwood h|0 hadimvo hareg hausman haver he heck_d2 heckma_p heckman heckp_lf heckpr_p heckprob hel help hereg hetpr_lf hetpr_p hetprob hettest hexdump hilite hist hist_7 histogram hlogit hlu hmeans hotel hotelling hprobit hreg hsearch icd9 icd9_ff icd9p iis impute imtest inbase include inf infi infil infile infix inp inpu input ins insheet insp inspe inspec inspect integ inten intreg intreg_7 intreg_p intrg2_ll intrg_ll intrg_ll2 ipolate iqreg ir irf irf_create irfm iri is_svy is_svysum isid istdize ivprob_1_lf ivprob_lf ivprobit ivprobit_p ivreg ivreg_footnote ivtob_1_lf ivtob_lf ivtobit ivtobit_p jackknife jacknife jknife jknife_6 jknife_8 jkstat joinby kalarma1 kap kap_3 kapmeier kappa kapwgt kdensity kdensity_7 keep ksm ksmirnov ktau kwallis l|0 la lab labbe labbeplot labe label labelbook ladder levels levelsof leverage lfit lfit_p li lincom line linktest lis list lloghet_glf lloghet_glf_sh lloghet_gp lloghet_ilf lloghet_ilf_sh lloghet_ip llogi_sw llogis_p llogist llogistic llogistichet lnorm_lf lnorm_sw lnorma_p lnormal lnormalhet lnormhet_glf lnormhet_glf_sh lnormhet_gp lnormhet_ilf lnormhet_ilf_sh lnormhet_ip lnskew0 loadingplot loc loca local log logi logis_lf logistic logistic_p logit logit_estat logit_p loglogs logrank loneway lookfor lookup lowess lowess_7 lpredict lrecomp lroc lroc_7 lrtest ls lsens lsens_7 lsens_x lstat ltable ltable_7 ltriang lv lvr2plot lvr2plot_7 m|0 ma mac macr macro makecns man manova manova_estat manova_p manovatest mantel mark markin markout marksample mat mat_capp mat_order mat_put_rr mat_rapp mata mata_clear mata_describe mata_drop mata_matdescribe mata_matsave mata_matuse mata_memory mata_mlib mata_mosave mata_rename mata_which matalabel matcproc matlist matname matr matri matrix matrix_input__dlg matstrik mcc mcci md0_ md1_ md1debug_ md2_ md2debug_ mds mds_estat mds_p mdsconfig mdslong mdsmat mdsshepard mdytoe mdytof me_derd mean means median memory memsize menl meqparse mer merg merge meta mfp mfx mhelp mhodds minbound mixed_ll mixed_ll_reparm mkassert mkdir mkmat mkspline ml ml_5 ml_adjs ml_bhhhs ml_c_d ml_check ml_clear ml_cnt ml_debug ml_defd ml_e0 ml_e0_bfgs ml_e0_cycle ml_e0_dfp ml_e0i ml_e1 ml_e1_bfgs ml_e1_bhhh ml_e1_cycle ml_e1_dfp ml_e2 ml_e2_cycle ml_ebfg0 ml_ebfr0 ml_ebfr1 ml_ebh0q ml_ebhh0 ml_ebhr0 ml_ebr0i ml_ecr0i ml_edfp0 ml_edfr0 ml_edfr1 ml_edr0i ml_eds ml_eer0i ml_egr0i ml_elf ml_elf_bfgs ml_elf_bhhh ml_elf_cycle ml_elf_dfp ml_elfi ml_elfs ml_enr0i ml_enrr0 ml_erdu0 ml_erdu0_bfgs ml_erdu0_bhhh ml_erdu0_bhhhq ml_erdu0_cycle ml_erdu0_dfp ml_erdu0_nrbfgs ml_exde ml_footnote ml_geqnr ml_grad0 ml_graph ml_hbhhh ml_hd0 ml_hold ml_init ml_inv ml_log ml_max ml_mlout ml_mlout_8 ml_model ml_nb0 ml_opt ml_p ml_plot ml_query ml_rdgrd ml_repor ml_s_e ml_score ml_searc ml_technique ml_unhold mleval mlf_ mlmatbysum mlmatsum mlog mlogi mlogit mlogit_footnote mlogit_p mlopts mlsum mlvecsum mnl0_ mor more mov move mprobit mprobit_lf mprobit_p mrdu0_ mrdu1_ mvdecode mvencode mvreg mvreg_estat n|0 nbreg nbreg_al nbreg_lf nbreg_p nbreg_sw nestreg net newey newey_7 newey_p news nl nl_7 nl_9 nl_9_p nl_p nl_p_7 nlcom nlcom_p nlexp2 nlexp2_7 nlexp2a nlexp2a_7 nlexp3 nlexp3_7 nlgom3 nlgom3_7 nlgom4 nlgom4_7 nlinit nllog3 nllog3_7 nllog4 nllog4_7 nlog_rd nlogit nlogit_p nlogitgen nlogittree nlpred no nobreak noi nois noisi noisil noisily note notes notes_dlg nptrend numlabel numlist odbc old_ver olo olog ologi ologi_sw ologit ologit_p ologitp on one onew onewa oneway op_colnm op_comp op_diff op_inv op_str opr opro oprob oprob_sw oprobi oprobi_p oprobit oprobitp opts_exclusive order orthog orthpoly ou out outf outfi outfil outfile outs outsh outshe outshee outsheet ovtest pac pac_7 palette parse parse_dissim pause pca pca_8 pca_display pca_estat pca_p pca_rotate pcamat pchart pchart_7 pchi pchi_7 pcorr pctile pentium pergram pergram_7 permute permute_8 personal peto_st pkcollapse pkcross pkequiv pkexamine pkexamine_7 pkshape pksumm pksumm_7 pl plo plot plugin pnorm pnorm_7 poisgof poiss_lf poiss_sw poisso_p poisson poisson_estat post postclose postfile postutil pperron pr prais prais_e prais_e2 prais_p predict predictnl preserve print pro prob probi probit probit_estat probit_p proc_time procoverlay procrustes procrustes_estat procrustes_p profiler prog progr progra program prop proportion prtest prtesti pwcorr pwd q\\s qby qbys qchi qchi_7 qladder qladder_7 qnorm qnorm_7 qqplot qqplot_7 qreg qreg_c qreg_p qreg_sw qu quadchk quantile quantile_7 que quer query range ranksum ratio rchart rchart_7 rcof recast reclink recode reg reg3 reg3_p regdw regr regre regre_p2 regres regres_p regress regress_estat regriv_p remap ren rena renam rename renpfix repeat replace report reshape restore ret retu retur return rm rmdir robvar roccomp roccomp_7 roccomp_8 rocf_lf rocfit rocfit_8 rocgold rocplot rocplot_7 roctab roctab_7 rolling rologit rologit_p rot rota rotat rotate rotatemat rreg rreg_p ru run runtest rvfplot rvfplot_7 rvpplot rvpplot_7 sa safesum sample sampsi sav save savedresults saveold sc sca scal scala scalar scatter scm_mine sco scob_lf scob_p scobi_sw scobit scor score scoreplot scoreplot_help scree screeplot screeplot_help sdtest sdtesti se search separate seperate serrbar serrbar_7 serset set set_defaults sfrancia sh she shel shell shewhart shewhart_7 signestimationsample signrank signtest simul simul_7 simulate simulate_8 sktest sleep slogit slogit_d2 slogit_p smooth snapspan so sor sort spearman spikeplot spikeplot_7 spikeplt spline_x split sqreg sqreg_p sret sretu sretur sreturn ssc st st_ct st_hc st_hcd st_hcd_sh st_is st_issys st_note st_promo st_set st_show st_smpl st_subid stack statsby statsby_8 stbase stci stci_7 stcox stcox_estat stcox_fr stcox_fr_ll stcox_p stcox_sw stcoxkm stcoxkm_7 stcstat stcurv stcurve stcurve_7 stdes stem stepwise stereg stfill stgen stir stjoin stmc stmh stphplot stphplot_7 stphtest stphtest_7 stptime strate strate_7 streg streg_sw streset sts sts_7 stset stsplit stsum sttocc sttoct stvary stweib su suest suest_8 sum summ summa summar summari summariz summarize sunflower sureg survcurv survsum svar svar_p svmat svy svy_disp svy_dreg svy_est svy_est_7 svy_estat svy_get svy_gnbreg_p svy_head svy_header svy_heckman_p svy_heckprob_p svy_intreg_p svy_ivreg_p svy_logistic_p svy_logit_p svy_mlogit_p svy_nbreg_p svy_ologit_p svy_oprobit_p svy_poisson_p svy_probit_p svy_regress_p svy_sub svy_sub_7 svy_x svy_x_7 svy_x_p svydes svydes_8 svygen svygnbreg svyheckman svyheckprob svyintreg svyintreg_7 svyintrg svyivreg svylc svylog_p svylogit svymarkout svymarkout_8 svymean svymlog svymlogit svynbreg svyolog svyologit svyoprob svyoprobit svyopts svypois svypois_7 svypoisson svyprobit svyprobt svyprop svyprop_7 svyratio svyreg svyreg_p svyregress svyset svyset_7 svyset_8 svytab svytab_7 svytest svytotal sw sw_8 swcnreg swcox swereg swilk swlogis swlogit swologit swoprbt swpois swprobit swqreg swtobit swweib symmetry symmi symplot symplot_7 syntax sysdescribe sysdir sysuse szroeter ta tab tab1 tab2 tab_or tabd tabdi tabdis tabdisp tabi table tabodds tabodds_7 tabstat tabu tabul tabula tabulat tabulate te tempfile tempname tempvar tes test testnl testparm teststd tetrachoric time_it timer tis tob tobi tobit tobit_p tobit_sw token tokeni tokeniz tokenize tostring total translate translator transmap treat_ll treatr_p treatreg trim trimfill trnb_cons trnb_mean trpoiss_d2 trunc_ll truncr_p truncreg tsappend tset tsfill tsline tsline_ex tsreport tsrevar tsrline tsset tssmooth tsunab ttest ttesti tut_chk tut_wait tutorial tw tware_st two twoway twoway__fpfit_serset twoway__function_gen twoway__histogram_gen twoway__ipoint_serset twoway__ipoints_serset twoway__kdensity_gen twoway__lfit_serset twoway__normgen_gen twoway__pci_serset twoway__qfit_serset twoway__scatteri_serset twoway__sunflower_gen twoway_ksm_serset ty typ type typeof u|0 unab unabbrev unabcmd update us use uselabel var var_mkcompanion var_p varbasic varfcast vargranger varirf varirf_add varirf_cgraph varirf_create varirf_ctable varirf_describe varirf_dir varirf_drop varirf_erase varirf_graph varirf_ograph varirf_rename varirf_set varirf_table varlist varlmar varnorm varsoc varstable varstable_w varstable_w2 varwle vce vec vec_fevd vec_mkphi vec_p vec_p_w vecirf_create veclmar veclmar_w vecnorm vecnorm_w vecrank vecstable verinst vers versi versio version view viewsource vif vwls wdatetof webdescribe webseek webuse weib1_lf weib2_lf weib_lf weib_lf0 weibhet_glf weibhet_glf_sh weibhet_glfa weibhet_glfa_sh weibhet_gp weibhet_ilf weibhet_ilf_sh weibhet_ilfa weibhet_ilfa_sh weibhet_ip weibu_sw weibul_p weibull weibull_c weibull_s weibullhet wh whelp whi which whil while wilc_st wilcoxon win wind windo window winexec wntestb wntestb_7 wntestq xchart xchart_7 xcorr xcorr_7 xi xi_6 xmlsav xmlsave xmluse xpose xsh xshe xshel xshell xt_iis xt_tis xtab_p xtabond xtbin_p xtclog xtcloglog xtcloglog_8 xtcloglog_d2 xtcloglog_pa_p xtcloglog_re_p xtcnt_p xtcorr xtdata xtdes xtfront_p xtfrontier xtgee xtgee_elink xtgee_estat xtgee_makeivar xtgee_p xtgee_plink xtgls xtgls_p xthaus xthausman xtht_p xthtaylor xtile xtint_p xtintreg xtintreg_8 xtintreg_d2 xtintreg_p xtivp_1 xtivp_2 xtivreg xtline xtline_ex xtlogit xtlogit_8 xtlogit_d2 xtlogit_fe_p xtlogit_pa_p xtlogit_re_p xtmixed xtmixed_estat xtmixed_p xtnb_fe xtnb_lf xtnbreg xtnbreg_pa_p xtnbreg_refe_p xtpcse xtpcse_p xtpois xtpoisson xtpoisson_d2 xtpoisson_pa_p xtpoisson_refe_p xtpred xtprobit xtprobit_8 xtprobit_d2 xtprobit_re_p xtps_fe xtps_lf xtps_ren xtps_ren_8 xtrar_p xtrc xtrc_p xtrchh xtrefe_p xtreg xtreg_be xtreg_fe xtreg_ml xtreg_pa_p xtreg_re xtregar xtrere_p xtset xtsf_ll xtsf_llti xtsum xttab xttest0 xttobit xttobit_8 xttobit_p xttrans yx yxview__barlike_draw yxview_area_draw yxview_bar_draw yxview_dot_draw yxview_dropline_draw yxview_function_draw yxview_iarrow_draw yxview_ilabels_draw yxview_normal_draw yxview_pcarrow_draw yxview_pcbarrow_draw yxview_pccapsym_draw yxview_pcscatter_draw yxview_pcspike_draw yxview_rarea_draw yxview_rbar_draw yxview_rbarm_draw yxview_rcap_draw yxview_rcapsym_draw yxview_rconnected_draw yxview_rline_draw yxview_rscatter_draw yxview_rspike_draw yxview_spike_draw yxview_sunflower_draw zap_s zinb zinb_llf zinb_plf zip zip_llf zip_p zip_plf zt_ct_5 zt_hc_5 zt_hcd_5 zt_is_5 zt_iss_5 zt_sho_5 zt_smp_5 ztbase_5 ztcox_5 ztdes_5 ztereg_5 ztfill_5 ztgen_5 ztir_5 ztjoin_5 ztnb ztnb_p ztp ztp_p zts_5 ztset_5 ztspli_5 ztsum_5 zttoct_5 ztvary_5 ztweib_5",
      contains: [{
        className: "symbol",
        begin: /`[a-zA-Z0-9_]+'/
      }, {
        className: "variable",
        begin: /\$\{?[a-zA-Z0-9_]+\}?/
      }, {
        className: "string",
        variants: [{
          begin: `\`"[^\r
]*?"'`
        }, {
          begin: `"[^\r
"]*"`
        }]
      }, {
        className: "built_in",
        variants: [{
          begin: "\\b(abs|acos|asin|atan|atan2|atanh|ceil|cloglog|comb|cos|digamma|exp|floor|invcloglog|invlogit|ln|lnfact|lnfactorial|lngamma|log|log10|max|min|mod|reldif|round|sign|sin|sqrt|sum|tan|tanh|trigamma|trunc|betaden|Binomial|binorm|binormal|chi2|chi2tail|dgammapda|dgammapdada|dgammapdadx|dgammapdx|dgammapdxdx|F|Fden|Ftail|gammaden|gammap|ibeta|invbinomial|invchi2|invchi2tail|invF|invFtail|invgammap|invibeta|invnchi2|invnFtail|invnibeta|invnorm|invnormal|invttail|nbetaden|nchi2|nFden|nFtail|nibeta|norm|normal|normalden|normd|npnchi2|tden|ttail|uniform|abbrev|char|index|indexnot|length|lower|ltrim|match|plural|proper|real|regexm|regexr|regexs|reverse|rtrim|string|strlen|strlower|strltrim|strmatch|strofreal|strpos|strproper|strreverse|strrtrim|strtrim|strupper|subinstr|subinword|substr|trim|upper|word|wordcount|_caller|autocode|byteorder|chop|clip|cond|e|epsdouble|epsfloat|group|inlist|inrange|irecode|matrix|maxbyte|maxdouble|maxfloat|maxint|maxlong|mi|minbyte|mindouble|minfloat|minint|minlong|missing|r|recode|replay|return|s|scalar|d|date|day|dow|doy|halfyear|mdy|month|quarter|week|year|d|daily|dofd|dofh|dofm|dofq|dofw|dofy|h|halfyearly|hofd|m|mofd|monthly|q|qofd|quarterly|tin|twithin|w|weekly|wofd|y|yearly|yh|ym|yofd|yq|yw|cholesky|colnumb|colsof|corr|det|diag|diag0cnt|el|get|hadamard|I|inv|invsym|issym|issymmetric|J|matmissing|matuniform|mreldif|nullmat|rownumb|rowsof|sweep|syminv|trace|vec|vecdiag)(?=\\()"
        }]
      }, A.COMMENT("^[ 	]*\\*.*$", !1), A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE]
    }
  }
  ZxA.exports = ia9
})
// @from(Start 2209213, End 2210149)
WxA = z((WA8, YxA) => {
  function na9(A) {
    return {
      name: "STEP Part 21",
      aliases: ["p21", "step", "stp"],
      case_insensitive: !0,
      keywords: {
        $pattern: "[A-Z_][A-Z0-9_.]*",
        keyword: "HEADER ENDSEC DATA"
      },
      contains: [{
        className: "meta",
        begin: "ISO-10303-21;",
        relevance: 10
      }, {
        className: "meta",
        begin: "END-ISO-10303-21;",
        relevance: 10
      }, A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, A.COMMENT("/\\*\\*!", "\\*/"), A.C_NUMBER_MODE, A.inherit(A.APOS_STRING_MODE, {
        illegal: null
      }), A.inherit(A.QUOTE_STRING_MODE, {
        illegal: null
      }), {
        className: "string",
        begin: "'",
        end: "'"
      }, {
        className: "symbol",
        variants: [{
          begin: "#",
          end: "\\d+",
          illegal: "\\W"
        }]
      }]
    }
  }
  YxA.exports = na9
})
// @from(Start 2210155, End 2218641)
FxA = z((JA8, JxA) => {
  var aa9 = (A) => {
      return {
        IMPORTANT: {
          className: "meta",
          begin: "!important"
        },
        HEXCOLOR: {
          className: "number",
          begin: "#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})"
        },
        ATTRIBUTE_SELECTOR_MODE: {
          className: "selector-attr",
          begin: /\[/,
          end: /\]/,
          illegal: "$",
          contains: [A.APOS_STRING_MODE, A.QUOTE_STRING_MODE]
        }
      }
    },
    sa9 = ["a", "abbr", "address", "article", "aside", "audio", "b", "blockquote", "body", "button", "canvas", "caption", "cite", "code", "dd", "del", "details", "dfn", "div", "dl", "dt", "em", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup", "html", "i", "iframe", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "mark", "menu", "nav", "object", "ol", "p", "q", "quote", "samp", "section", "span", "strong", "summary", "sup", "table", "tbody", "td", "textarea", "tfoot", "th", "thead", "time", "tr", "ul", "var", "video"],
    ra9 = ["any-hover", "any-pointer", "aspect-ratio", "color", "color-gamut", "color-index", "device-aspect-ratio", "device-height", "device-width", "display-mode", "forced-colors", "grid", "height", "hover", "inverted-colors", "monochrome", "orientation", "overflow-block", "overflow-inline", "pointer", "prefers-color-scheme", "prefers-contrast", "prefers-reduced-motion", "prefers-reduced-transparency", "resolution", "scan", "scripting", "update", "width", "min-width", "max-width", "min-height", "max-height"],
    oa9 = ["active", "any-link", "blank", "checked", "current", "default", "defined", "dir", "disabled", "drop", "empty", "enabled", "first", "first-child", "first-of-type", "fullscreen", "future", "focus", "focus-visible", "focus-within", "has", "host", "host-context", "hover", "indeterminate", "in-range", "invalid", "is", "lang", "last-child", "last-of-type", "left", "link", "local-link", "not", "nth-child", "nth-col", "nth-last-child", "nth-last-col", "nth-last-of-type", "nth-of-type", "only-child", "only-of-type", "optional", "out-of-range", "past", "placeholder-shown", "read-only", "read-write", "required", "right", "root", "scope", "target", "target-within", "user-invalid", "valid", "visited", "where"],
    ta9 = ["after", "backdrop", "before", "cue", "cue-region", "first-letter", "first-line", "grammar-error", "marker", "part", "placeholder", "selection", "slotted", "spelling-error"],
    ea9 = ["align-content", "align-items", "align-self", "animation", "animation-delay", "animation-direction", "animation-duration", "animation-fill-mode", "animation-iteration-count", "animation-name", "animation-play-state", "animation-timing-function", "auto", "backface-visibility", "background", "background-attachment", "background-clip", "background-color", "background-image", "background-origin", "background-position", "background-repeat", "background-size", "border", "border-bottom", "border-bottom-color", "border-bottom-left-radius", "border-bottom-right-radius", "border-bottom-style", "border-bottom-width", "border-collapse", "border-color", "border-image", "border-image-outset", "border-image-repeat", "border-image-slice", "border-image-source", "border-image-width", "border-left", "border-left-color", "border-left-style", "border-left-width", "border-radius", "border-right", "border-right-color", "border-right-style", "border-right-width", "border-spacing", "border-style", "border-top", "border-top-color", "border-top-left-radius", "border-top-right-radius", "border-top-style", "border-top-width", "border-width", "bottom", "box-decoration-break", "box-shadow", "box-sizing", "break-after", "break-before", "break-inside", "caption-side", "clear", "clip", "clip-path", "color", "column-count", "column-fill", "column-gap", "column-rule", "column-rule-color", "column-rule-style", "column-rule-width", "column-span", "column-width", "columns", "content", "counter-increment", "counter-reset", "cursor", "direction", "display", "empty-cells", "filter", "flex", "flex-basis", "flex-direction", "flex-flow", "flex-grow", "flex-shrink", "flex-wrap", "float", "font", "font-display", "font-family", "font-feature-settings", "font-kerning", "font-language-override", "font-size", "font-size-adjust", "font-smoothing", "font-stretch", "font-style", "font-variant", "font-variant-ligatures", "font-variation-settings", "font-weight", "height", "hyphens", "icon", "image-orientation", "image-rendering", "image-resolution", "ime-mode", "inherit", "initial", "justify-content", "left", "letter-spacing", "line-height", "list-style", "list-style-image", "list-style-position", "list-style-type", "margin", "margin-bottom", "margin-left", "margin-right", "margin-top", "marks", "mask", "max-height", "max-width", "min-height", "min-width", "nav-down", "nav-index", "nav-left", "nav-right", "nav-up", "none", "normal", "object-fit", "object-position", "opacity", "order", "orphans", "outline", "outline-color", "outline-offset", "outline-style", "outline-width", "overflow", "overflow-wrap", "overflow-x", "overflow-y", "padding", "padding-bottom", "padding-left", "padding-right", "padding-top", "page-break-after", "page-break-before", "page-break-inside", "perspective", "perspective-origin", "pointer-events", "position", "quotes", "resize", "right", "src", "tab-size", "table-layout", "text-align", "text-align-last", "text-decoration", "text-decoration-color", "text-decoration-line", "text-decoration-style", "text-indent", "text-overflow", "text-rendering", "text-shadow", "text-transform", "text-underline-position", "top", "transform", "transform-origin", "transform-style", "transition", "transition-delay", "transition-duration", "transition-property", "transition-timing-function", "unicode-bidi", "vertical-align", "visibility", "white-space", "widows", "width", "word-break", "word-spacing", "word-wrap", "z-index"].reverse();

  function As9(A) {
    let B = aa9(A),
      Q = "and or not only",
      I = {
        className: "variable",
        begin: "\\$" + A.IDENT_RE
      },
      G = ["charset", "css", "debug", "extend", "font-face", "for", "import", "include", "keyframes", "media", "mixin", "page", "warn", "while"],
      Z = "(?=[.\\s\\n[:,(])";
    return {
      name: "Stylus",
      aliases: ["styl"],
      case_insensitive: !1,
      keywords: "if else for in",
      illegal: "(" + ["\\?", "(\\bReturn\\b)", "(\\bEnd\\b)", "(\\bend\\b)", "(\\bdef\\b)", ";", "#\\s", "\\*\\s", "===\\s", "\\|", "%"].join("|") + ")",
      contains: [A.QUOTE_STRING_MODE, A.APOS_STRING_MODE, A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, B.HEXCOLOR, {
        begin: "\\.[a-zA-Z][a-zA-Z0-9_-]*(?=[.\\s\\n[:,(])",
        className: "selector-class"
      }, {
        begin: "#[a-zA-Z][a-zA-Z0-9_-]*(?=[.\\s\\n[:,(])",
        className: "selector-id"
      }, {
        begin: "\\b(" + sa9.join("|") + ")(?=[.\\s\\n[:,(])",
        className: "selector-tag"
      }, {
        className: "selector-pseudo",
        begin: "&?:(" + oa9.join("|") + ")(?=[.\\s\\n[:,(])"
      }, {
        className: "selector-pseudo",
        begin: "&?::(" + ta9.join("|") + ")(?=[.\\s\\n[:,(])"
      }, B.ATTRIBUTE_SELECTOR_MODE, {
        className: "keyword",
        begin: /@media/,
        starts: {
          end: /[{;}]/,
          keywords: {
            $pattern: /[a-z-]+/,
            keyword: "and or not only",
            attribute: ra9.join(" ")
          },
          contains: [A.CSS_NUMBER_MODE]
        }
      }, {
        className: "keyword",
        begin: "@((-(o|moz|ms|webkit)-)?(" + G.join("|") + "))\\b"
      }, I, A.CSS_NUMBER_MODE, {
        className: "function",
        begin: "^[a-zA-Z][a-zA-Z0-9_-]*\\(.*\\)",
        illegal: "[\\n]",
        returnBegin: !0,
        contains: [{
          className: "title",
          begin: "\\b[a-zA-Z][a-zA-Z0-9_-]*"
        }, {
          className: "params",
          begin: /\(/,
          end: /\)/,
          contains: [B.HEXCOLOR, I, A.APOS_STRING_MODE, A.CSS_NUMBER_MODE, A.QUOTE_STRING_MODE]
        }]
      }, {
        className: "attribute",
        begin: "\\b(" + ea9.join("|") + ")\\b",
        starts: {
          end: /;|$/,
          contains: [B.HEXCOLOR, I, A.APOS_STRING_MODE, A.QUOTE_STRING_MODE, A.CSS_NUMBER_MODE, A.C_BLOCK_COMMENT_MODE, B.IMPORTANT],
          illegal: /\./,
          relevance: 0
        }
      }]
    }
  }
  JxA.exports = As9
})
// @from(Start 2218647, End 2219420)
VxA = z((FA8, XxA) => {
  function Bs9(A) {
    return {
      name: "SubUnit",
      case_insensitive: !0,
      contains: [{
        className: "string",
        begin: `\\[
(multipart)?`,
        end: `\\]
`
      }, {
        className: "string",
        begin: "\\d{4}-\\d{2}-\\d{2}(\\s+)\\d{2}:\\d{2}:\\d{2}.\\d+Z"
      }, {
        className: "string",
        begin: "(\\+|-)\\d+"
      }, {
        className: "keyword",
        relevance: 10,
        variants: [{
          begin: "^(test|testing|success|successful|failure|error|skip|xfail|uxsuccess)(:?)\\s+(test)?"
        }, {
          begin: "^progress(:?)(\\s+)?(pop|push)?"
        }, {
          begin: "^tags:"
        }, {
          begin: "^time:"
        }]
      }]
    }
  }
  XxA.exports = Bs9
})
// @from(Start 2219426, End 2230498)
$xA = z((XA8, NxA) => {
  function zxA(A) {
    if (!A) return null;
    if (typeof A === "string") return A;
    return A.source
  }

  function Xv(A) {
    return h8("(?=", A, ")")
  }

  function h8(...A) {
    return A.map((Q) => zxA(Q)).join("")
  }

  function RD(...A) {
    return "(" + A.map((Q) => zxA(Q)).join("|") + ")"
  }
  var aT1 = (A) => h8(/\b/, A, /\w$/.test(A) ? /\b/ : /\B/),
    CxA = ["Protocol", "Type"].map(aT1),
    cT1 = ["init", "self"].map(aT1),
    Qs9 = ["Any", "Self"],
    lT1 = ["associatedtype", "async", "await", /as\?/, /as!/, "as", "break", "case", "catch", "class", "continue", "convenience", "default", "defer", "deinit", "didSet", "do", "dynamic", "else", "enum", "extension", "fallthrough", /fileprivate\(set\)/, "fileprivate", "final", "for", "func", "get", "guard", "if", "import", "indirect", "infix", /init\?/, /init!/, "inout", /internal\(set\)/, "internal", "in", "is", "lazy", "let", "mutating", "nonmutating", /open\(set\)/, "open", "operator", "optional", "override", "postfix", "precedencegroup", "prefix", /private\(set\)/, "private", "protocol", /public\(set\)/, "public", "repeat", "required", "rethrows", "return", "set", "some", "static", "struct", "subscript", "super", "switch", "throws", "throw", /try\?/, /try!/, "try", "typealias", /unowned\(safe\)/, /unowned\(unsafe\)/, "unowned", "var", "weak", "where", "while", "willSet"],
    KxA = ["false", "nil", "true"],
    Is9 = ["assignment", "associativity", "higherThan", "left", "lowerThan", "none", "right"],
    Gs9 = ["#colorLiteral", "#column", "#dsohandle", "#else", "#elseif", "#endif", "#error", "#file", "#fileID", "#fileLiteral", "#filePath", "#function", "#if", "#imageLiteral", "#keyPath", "#line", "#selector", "#sourceLocation", "#warn_unqualified_access", "#warning"],
    HxA = ["abs", "all", "any", "assert", "assertionFailure", "debugPrint", "dump", "fatalError", "getVaList", "isKnownUniquelyReferenced", "max", "min", "numericCast", "pointwiseMax", "pointwiseMin", "precondition", "preconditionFailure", "print", "readLine", "repeatElement", "sequence", "stride", "swap", "swift_unboxFromSwiftValueWithType", "transcode", "type", "unsafeBitCast", "unsafeDowncast", "withExtendedLifetime", "withUnsafeMutablePointer", "withUnsafePointer", "withVaList", "withoutActuallyEscaping", "zip"],
    wxA = RD(/[/=\-+!*%<>&|^~?]/, /[\u00A1-\u00A7]/, /[\u00A9\u00AB]/, /[\u00AC\u00AE]/, /[\u00B0\u00B1]/, /[\u00B6\u00BB\u00BF\u00D7\u00F7]/, /[\u2016-\u2017]/, /[\u2020-\u2027]/, /[\u2030-\u203E]/, /[\u2041-\u2053]/, /[\u2055-\u205E]/, /[\u2190-\u23FF]/, /[\u2500-\u2775]/, /[\u2794-\u2BFF]/, /[\u2E00-\u2E7F]/, /[\u3001-\u3003]/, /[\u3008-\u3020]/, /[\u3030]/),
    ExA = RD(wxA, /[\u0300-\u036F]/, /[\u1DC0-\u1DFF]/, /[\u20D0-\u20FF]/, /[\uFE00-\uFE0F]/, /[\uFE20-\uFE2F]/),
    iT1 = h8(wxA, ExA, "*"),
    UxA = RD(/[a-zA-Z_]/, /[\u00A8\u00AA\u00AD\u00AF\u00B2-\u00B5\u00B7-\u00BA]/, /[\u00BC-\u00BE\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF]/, /[\u0100-\u02FF\u0370-\u167F\u1681-\u180D\u180F-\u1DBF]/, /[\u1E00-\u1FFF]/, /[\u200B-\u200D\u202A-\u202E\u203F-\u2040\u2054\u2060-\u206F]/, /[\u2070-\u20CF\u2100-\u218F\u2460-\u24FF\u2776-\u2793]/, /[\u2C00-\u2DFF\u2E80-\u2FFF]/, /[\u3004-\u3007\u3021-\u302F\u3031-\u303F\u3040-\uD7FF]/, /[\uF900-\uFD3D\uFD40-\uFDCF\uFDF0-\uFE1F\uFE30-\uFE44]/, /[\uFE47-\uFEFE\uFF00-\uFFFD]/),
    q81 = RD(UxA, /\d/, /[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/),
    nU = h8(UxA, q81, "*"),
    nT1 = h8(/[A-Z]/, q81, "*"),
    Zs9 = ["autoclosure", h8(/convention\(/, RD("swift", "block", "c"), /\)/), "discardableResult", "dynamicCallable", "dynamicMemberLookup", "escaping", "frozen", "GKInspectable", "IBAction", "IBDesignable", "IBInspectable", "IBOutlet", "IBSegueAction", "inlinable", "main", "nonobjc", "NSApplicationMain", "NSCopying", "NSManaged", h8(/objc\(/, nU, /\)/), "objc", "objcMembers", "propertyWrapper", "requires_stored_property_inits", "testable", "UIApplicationMain", "unknown", "usableFromInline"],
    Ds9 = ["iOS", "iOSApplicationExtension", "macOS", "macOSApplicationExtension", "macCatalyst", "macCatalystApplicationExtension", "watchOS", "watchOSApplicationExtension", "tvOS", "tvOSApplicationExtension", "swift"];

  function Ys9(A) {
    let B = {
        match: /\s+/,
        relevance: 0
      },
      Q = A.COMMENT("/\\*", "\\*/", {
        contains: ["self"]
      }),
      I = [A.C_LINE_COMMENT_MODE, Q],
      G = {
        className: "keyword",
        begin: h8(/\./, Xv(RD(...CxA, ...cT1))),
        end: RD(...CxA, ...cT1),
        excludeBegin: !0
      },
      Z = {
        match: h8(/\./, RD(...lT1)),
        relevance: 0
      },
      D = lT1.filter((B1) => typeof B1 === "string").concat(["_|0"]),
      Y = lT1.filter((B1) => typeof B1 !== "string").concat(Qs9).map(aT1),
      W = {
        variants: [{
          className: "keyword",
          match: RD(...Y, ...cT1)
        }]
      },
      J = {
        $pattern: RD(/\b\w+/, /#\w+/),
        keyword: D.concat(Gs9),
        literal: KxA
      },
      F = [G, Z, W],
      X = {
        match: h8(/\./, RD(...HxA)),
        relevance: 0
      },
      V = {
        className: "built_in",
        match: h8(/\b/, RD(...HxA), /(?=\()/)
      },
      C = [X, V],
      K = {
        match: /->/,
        relevance: 0
      },
      E = {
        className: "operator",
        relevance: 0,
        variants: [{
          match: iT1
        }, {
          match: `\\.(\\.|${ExA})+`
        }]
      },
      N = [K, E],
      q = "([0-9]_*)+",
      O = "([0-9a-fA-F]_*)+",
      R = {
        className: "number",
        relevance: 0,
        variants: [{
          match: "\\b(([0-9]_*)+)(\\.(([0-9]_*)+))?([eE][+-]?(([0-9]_*)+))?\\b"
        }, {
          match: "\\b0x(([0-9a-fA-F]_*)+)(\\.(([0-9a-fA-F]_*)+))?([pP][+-]?(([0-9]_*)+))?\\b"
        }, {
          match: /\b0o([0-7]_*)+\b/
        }, {
          match: /\b0b([01]_*)+\b/
        }]
      },
      T = (B1 = "") => ({
        className: "subst",
        variants: [{
          match: h8(/\\/, B1, /[0\\tnr"']/)
        }, {
          match: h8(/\\/, B1, /u\{[0-9a-fA-F]{1,8}\}/)
        }]
      }),
      L = (B1 = "") => ({
        className: "subst",
        match: h8(/\\/, B1, /[\t ]*(?:[\r\n]|\r\n)/)
      }),
      _ = (B1 = "") => ({
        className: "subst",
        label: "interpol",
        begin: h8(/\\/, B1, /\(/),
        end: /\)/
      }),
      k = (B1 = "") => ({
        begin: h8(B1, /"""/),
        end: h8(/"""/, B1),
        contains: [T(B1), L(B1), _(B1)]
      }),
      i = (B1 = "") => ({
        begin: h8(B1, /"/),
        end: h8(/"/, B1),
        contains: [T(B1), _(B1)]
      }),
      x = {
        className: "string",
        variants: [k(), k("#"), k("##"), k("###"), i(), i("#"), i("##"), i("###")]
      },
      s = {
        match: h8(/`/, nU, /`/)
      },
      d = {
        className: "variable",
        match: /\$\d+/
      },
      F1 = {
        className: "variable",
        match: `\\$${q81}+`
      },
      X1 = [s, d, F1],
      v = {
        match: /(@|#)available/,
        className: "keyword",
        starts: {
          contains: [{
            begin: /\(/,
            end: /\)/,
            keywords: Ds9,
            contains: [...N, R, x]
          }]
        }
      },
      D1 = {
        className: "keyword",
        match: h8(/@/, RD(...Zs9))
      },
      N1 = {
        className: "meta",
        match: h8(/@/, nU)
      },
      u1 = [v, D1, N1],
      d1 = {
        match: Xv(/\b[A-Z]/),
        relevance: 0,
        contains: [{
          className: "type",
          match: h8(/(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)/, q81, "+")
        }, {
          className: "type",
          match: nT1,
          relevance: 0
        }, {
          match: /[?!]+/,
          relevance: 0
        }, {
          match: /\.\.\./,
          relevance: 0
        }, {
          match: h8(/\s+&\s+/, Xv(nT1)),
          relevance: 0
        }]
      },
      YA = {
        begin: /</,
        end: />/,
        keywords: J,
        contains: [...I, ...F, ...u1, K, d1]
      };
    d1.contains.push(YA);
    let bA = {
        match: h8(nU, /\s*:/),
        keywords: "_|0",
        relevance: 0
      },
      e1 = {
        begin: /\(/,
        end: /\)/,
        relevance: 0,
        keywords: J,
        contains: ["self", bA, ...I, ...F, ...C, ...N, R, x, ...X1, ...u1, d1]
      },
      k1 = {
        beginKeywords: "func",
        contains: [{
          className: "title",
          match: RD(s.match, nU, iT1),
          endsParent: !0,
          relevance: 0
        }, B]
      },
      Q1 = {
        begin: /</,
        end: />/,
        contains: [...I, d1]
      },
      v1 = {
        begin: RD(Xv(h8(nU, /\s*:/)), Xv(h8(nU, /\s+/, nU, /\s*:/))),
        end: /:/,
        relevance: 0,
        contains: [{
          className: "keyword",
          match: /\b_\b/
        }, {
          className: "params",
          match: nU
        }]
      },
      L1 = {
        begin: /\(/,
        end: /\)/,
        keywords: J,
        contains: [v1, ...I, ...F, ...N, R, x, ...u1, d1, e1],
        endsParent: !0,
        illegal: /["']/
      },
      BA = {
        className: "function",
        match: Xv(/\bfunc\b/),
        contains: [k1, Q1, L1, B],
        illegal: [/\[/, /%/]
      },
      HA = {
        className: "function",
        match: /\b(subscript|init[?!]?)\s*(?=[<(])/,
        keywords: {
          keyword: "subscript init init? init!",
          $pattern: /\w+[?!]?/
        },
        contains: [Q1, L1, B],
        illegal: /\[|%/
      },
      MA = {
        beginKeywords: "operator",
        end: A.MATCH_NOTHING_RE,
        contains: [{
          className: "title",
          match: iT1,
          endsParent: !0,
          relevance: 0
        }]
      },
      t = {
        beginKeywords: "precedencegroup",
        end: A.MATCH_NOTHING_RE,
        contains: [{
          className: "title",
          match: nT1,
          relevance: 0
        }, {
          begin: /{/,
          end: /}/,
          relevance: 0,
          endsParent: !0,
          keywords: [...Is9, ...KxA],
          contains: [d1]
        }]
      };
    for (let B1 of x.variants) {
      let W1 = B1.contains.find((P1) => P1.label === "interpol");
      W1.keywords = J;
      let w1 = [...F, ...C, ...N, R, x, ...X1];
      W1.contains = [...w1, {
        begin: /\(/,
        end: /\)/,
        contains: ["self", ...w1]
      }]
    }
    return {
      name: "Swift",
      keywords: J,
      contains: [...I, BA, HA, {
        className: "class",
        beginKeywords: "struct protocol class extension enum",
        end: "\\{",
        excludeEnd: !0,
        keywords: J,
        contains: [A.inherit(A.TITLE_MODE, {
          begin: /[A-Za-z$_][\u00C0-\u02B80-9A-Za-z$_]*/
        }), ...F]
      }, MA, t, {
        beginKeywords: "import",
        end: /$/,
        contains: [...I],
        relevance: 0
      }, ...F, ...C, ...N, R, x, ...X1, ...u1, d1, e1]
    }
  }
  NxA.exports = Ys9
})
// @from(Start 2230504, End 2231181)
MxA = z((VA8, qxA) => {
  function Ws9(A) {
    return {
      name: "Tagger Script",
      contains: [{
        className: "comment",
        begin: /\$noop\(/,
        end: /\)/,
        contains: [{
          begin: /\(/,
          end: /\)/,
          contains: ["self", {
            begin: /\\./
          }]
        }],
        relevance: 10
      }, {
        className: "keyword",
        begin: /\$(?!noop)[a-zA-Z][_a-zA-Z0-9]*/,
        end: /\(/,
        excludeEnd: !0
      }, {
        className: "variable",
        begin: /%[_a-zA-Z0-9:]*/,
        end: "%"
      }, {
        className: "symbol",
        begin: /\\./
      }]
    }
  }
  qxA.exports = Ws9
})
// @from(Start 2231187, End 2234222)
RxA = z((CA8, LxA) => {
  function Js9(A) {
    var B = "true false yes no null",
      Q = "[\\w#;/?:@&=+$,.~*'()[\\]]+",
      I = {
        className: "attr",
        variants: [{
          begin: "\\w[\\w :\\/.-]*:(?=[ 	]|$)"
        }, {
          begin: '"\\w[\\w :\\/.-]*":(?=[ 	]|$)'
        }, {
          begin: "'\\w[\\w :\\/.-]*':(?=[ 	]|$)"
        }]
      },
      G = {
        className: "template-variable",
        variants: [{
          begin: /\{\{/,
          end: /\}\}/
        }, {
          begin: /%\{/,
          end: /\}/
        }]
      },
      Z = {
        className: "string",
        relevance: 0,
        variants: [{
          begin: /'/,
          end: /'/
        }, {
          begin: /"/,
          end: /"/
        }, {
          begin: /\S+/
        }],
        contains: [A.BACKSLASH_ESCAPE, G]
      },
      D = A.inherit(Z, {
        variants: [{
          begin: /'/,
          end: /'/
        }, {
          begin: /"/,
          end: /"/
        }, {
          begin: /[^\s,{}[\]]+/
        }]
      }),
      Y = "[0-9]{4}(-[0-9][0-9]){0,2}",
      W = "([Tt \\t][0-9][0-9]?(:[0-9][0-9]){2})?",
      J = "(\\.[0-9]*)?",
      F = "([ \\t])*(Z|[-+][0-9][0-9]?(:[0-9][0-9])?)?",
      X = {
        className: "number",
        begin: "\\b" + Y + W + J + F + "\\b"
      },
      V = {
        end: ",",
        endsWithParent: !0,
        excludeEnd: !0,
        keywords: B,
        relevance: 0
      },
      C = {
        begin: /\{/,
        end: /\}/,
        contains: [V],
        illegal: "\\n",
        relevance: 0
      },
      K = {
        begin: "\\[",
        end: "\\]",
        contains: [V],
        illegal: "\\n",
        relevance: 0
      },
      E = [I, {
        className: "meta",
        begin: "^---\\s*$",
        relevance: 10
      }, {
        className: "string",
        begin: "[\\|>]([1-9]?[+-])?[ ]*\\n( +)[^ ][^\\n]*\\n(\\2[^\\n]+\\n?)*"
      }, {
        begin: "<%[%=-]?",
        end: "[%-]?%>",
        subLanguage: "ruby",
        excludeBegin: !0,
        excludeEnd: !0,
        relevance: 0
      }, {
        className: "type",
        begin: "!\\w+!" + Q
      }, {
        className: "type",
        begin: "!<" + Q + ">"
      }, {
        className: "type",
        begin: "!" + Q
      }, {
        className: "type",
        begin: "!!" + Q
      }, {
        className: "meta",
        begin: "&" + A.UNDERSCORE_IDENT_RE + "$"
      }, {
        className: "meta",
        begin: "\\*" + A.UNDERSCORE_IDENT_RE + "$"
      }, {
        className: "bullet",
        begin: "-(?=[ ]|$)",
        relevance: 0
      }, A.HASH_COMMENT_MODE, {
        beginKeywords: B,
        keywords: {
          literal: B
        }
      }, X, {
        className: "number",
        begin: A.C_NUMBER_RE + "\\b",
        relevance: 0
      }, C, K, Z],
      N = [...E];
    return N.pop(), N.push(D), V.contains = N, {
      name: "YAML",
      case_insensitive: !0,
      aliases: ["yml"],
      contains: E
    }
  }
  LxA.exports = Js9
})
// @from(Start 2234228, End 2234891)
TxA = z((KA8, OxA) => {
  function Fs9(A) {
    return {
      name: "Test Anything Protocol",
      case_insensitive: !0,
      contains: [A.HASH_COMMENT_MODE, {
        className: "meta",
        variants: [{
          begin: "^TAP version (\\d+)$"
        }, {
          begin: "^1\\.\\.(\\d+)$"
        }]
      }, {
        begin: /---$/,
        end: "\\.\\.\\.$",
        subLanguage: "yaml",
        relevance: 0
      }, {
        className: "number",
        begin: " (\\d+) "
      }, {
        className: "symbol",
        variants: [{
          begin: "^ok"
        }, {
          begin: "^not ok"
        }]
      }]
    }
  }
  OxA.exports = Fs9
})
// @from(Start 2234897, End 2237169)
_xA = z((HA8, SxA) => {
  function Xs9(A) {
    if (!A) return null;
    if (typeof A === "string") return A;
    return A.source
  }

  function Vs9(A) {
    return PxA("(", A, ")?")
  }

  function PxA(...A) {
    return A.map((Q) => Xs9(Q)).join("")
  }

  function Cs9(A) {
    let B = /[a-zA-Z_][a-zA-Z0-9_]*/,
      Q = {
        className: "number",
        variants: [A.BINARY_NUMBER_MODE, A.C_NUMBER_MODE]
      };
    return {
      name: "Tcl",
      aliases: ["tk"],
      keywords: "after append apply array auto_execok auto_import auto_load auto_mkindex auto_mkindex_old auto_qualify auto_reset bgerror binary break catch cd chan clock close concat continue dde dict encoding eof error eval exec exit expr fblocked fconfigure fcopy file fileevent filename flush for foreach format gets glob global history http if incr info interp join lappend|10 lassign|10 lindex|10 linsert|10 list llength|10 load lrange|10 lrepeat|10 lreplace|10 lreverse|10 lsearch|10 lset|10 lsort|10 mathfunc mathop memory msgcat namespace open package parray pid pkg::create pkg_mkIndex platform platform::shell proc puts pwd read refchan regexp registry regsub|10 rename return safe scan seek set socket source split string subst switch tcl_endOfWord tcl_findLibrary tcl_startOfNextWord tcl_startOfPreviousWord tcl_wordBreakAfter tcl_wordBreakBefore tcltest tclvars tell time tm trace unknown unload unset update uplevel upvar variable vwait while",
      contains: [A.COMMENT(";[ \\t]*#", "$"), A.COMMENT("^[ \\t]*#", "$"), {
        beginKeywords: "proc",
        end: "[\\{]",
        excludeEnd: !0,
        contains: [{
          className: "title",
          begin: "[ \\t\\n\\r]+(::)?[a-zA-Z_]((::)?[a-zA-Z0-9_])*",
          end: "[ \\t\\n\\r]",
          endsWithParent: !0,
          excludeEnd: !0
        }]
      }, {
        className: "variable",
        variants: [{
          begin: PxA(/\$/, Vs9(/::/), B, "(::", B, ")*")
        }, {
          begin: "\\$\\{(::)?[a-zA-Z_]((::)?[a-zA-Z0-9_])*",
          end: "\\}",
          contains: [Q]
        }]
      }, {
        className: "string",
        contains: [A.BACKSLASH_ESCAPE],
        variants: [A.inherit(A.QUOTE_STRING_MODE, {
          illegal: null
        })]
      }, Q]
    }
  }
  SxA.exports = Cs9
})
// @from(Start 2237175, End 2238070)
yxA = z((zA8, jxA) => {
  function Ks9(A) {
    return {
      name: "Thrift",
      keywords: {
        keyword: "namespace const typedef struct enum service exception void oneway set list map required optional",
        built_in: "bool byte i16 i32 i64 double string binary",
        literal: "true false"
      },
      contains: [A.QUOTE_STRING_MODE, A.NUMBER_MODE, A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, {
        className: "class",
        beginKeywords: "struct enum service exception",
        end: /\{/,
        illegal: /\n/,
        contains: [A.inherit(A.TITLE_MODE, {
          starts: {
            endsWithParent: !0,
            excludeEnd: !0
          }
        })]
      }, {
        begin: "\\b(set|list|map)\\s*<",
        end: ">",
        keywords: "bool byte i16 i32 i64 double string binary",
        contains: ["self"]
      }]
    }
  }
  jxA.exports = Ks9
})
// @from(Start 2238076, End 2240006)
xxA = z((wA8, kxA) => {
  function Hs9(A) {
    let B = {
        className: "number",
        begin: "[1-9][0-9]*",
        relevance: 0
      },
      Q = {
        className: "symbol",
        begin: ":[^\\]]+"
      },
      I = {
        className: "built_in",
        begin: "(AR|P|PAYLOAD|PR|R|SR|RSR|LBL|VR|UALM|MESSAGE|UTOOL|UFRAME|TIMER|TIMER_OVERFLOW|JOINT_MAX_SPEED|RESUME_PROG|DIAG_REC)\\[",
        end: "\\]",
        contains: ["self", B, Q]
      },
      G = {
        className: "built_in",
        begin: "(AI|AO|DI|DO|F|RI|RO|UI|UO|GI|GO|SI|SO)\\[",
        end: "\\]",
        contains: ["self", B, A.QUOTE_STRING_MODE, Q]
      };
    return {
      name: "TP",
      keywords: {
        keyword: "ABORT ACC ADJUST AND AP_LD BREAK CALL CNT COL CONDITION CONFIG DA DB DIV DETECT ELSE END ENDFOR ERR_NUM ERROR_PROG FINE FOR GP GUARD INC IF JMP LINEAR_MAX_SPEED LOCK MOD MONITOR OFFSET Offset OR OVERRIDE PAUSE PREG PTH RT_LD RUN SELECT SKIP Skip TA TB TO TOOL_OFFSET Tool_Offset UF UT UFRAME_NUM UTOOL_NUM UNLOCK WAIT X Y Z W P R STRLEN SUBSTR FINDSTR VOFFSET PROG ATTR MN POS",
        literal: "ON OFF max_speed LPOS JPOS ENABLE DISABLE START STOP RESET"
      },
      contains: [I, G, {
        className: "keyword",
        begin: "/(PROG|ATTR|MN|POS|END)\\b"
      }, {
        className: "keyword",
        begin: "(CALL|RUN|POINT_LOGIC|LBL)\\b"
      }, {
        className: "keyword",
        begin: "\\b(ACC|CNT|Skip|Offset|PSPD|RT_LD|AP_LD|Tool_Offset)"
      }, {
        className: "number",
        begin: "\\d+(sec|msec|mm/sec|cm/min|inch/min|deg/sec|mm|in|cm)?\\b",
        relevance: 0
      }, A.COMMENT("//", "[;$]"), A.COMMENT("!", "[;$]"), A.COMMENT("--eg:", "$"), A.QUOTE_STRING_MODE, {
        className: "string",
        begin: "'",
        end: "'"
      }, A.C_NUMBER_MODE, {
        className: "variable",
        begin: "\\$[A-Za-z0-9_]+"
      }]
    }
  }
  kxA.exports = Hs9
})
// @from(Start 2240012, End 2241661)
vxA = z((EA8, fxA) => {
  function zs9(A) {
    var B = {
        className: "params",
        begin: "\\(",
        end: "\\)"
      },
      Q = "attribute block constant cycle date dump include max min parent random range source template_from_string",
      I = {
        beginKeywords: Q,
        keywords: {
          name: Q
        },
        relevance: 0,
        contains: [B]
      },
      G = {
        begin: /\|[A-Za-z_]+:?/,
        keywords: "abs batch capitalize column convert_encoding date date_modify default escape filter first format inky_to_html inline_css join json_encode keys last length lower map markdown merge nl2br number_format raw reduce replace reverse round slice sort spaceless split striptags title trim upper url_encode",
        contains: [I]
      },
      Z = "apply autoescape block deprecated do embed extends filter flush for from if import include macro sandbox set use verbatim with";
    return Z = Z + " " + Z.split(" ").map(function(D) {
      return "end" + D
    }).join(" "), {
      name: "Twig",
      aliases: ["craftcms"],
      case_insensitive: !0,
      subLanguage: "xml",
      contains: [A.COMMENT(/\{#/, /#\}/), {
        className: "template-tag",
        begin: /\{%/,
        end: /%\}/,
        contains: [{
          className: "name",
          begin: /\w+/,
          keywords: Z,
          starts: {
            endsWithParent: !0,
            contains: [G, I],
            relevance: 0
          }
        }]
      }, {
        className: "template-variable",
        begin: /\{\{/,
        end: /\}\}/,
        contains: ["self", G, I]
      }]
    }
  }
  fxA.exports = zs9
})
// @from(Start 2241667, End 2251974)
uxA = z((UA8, dxA) => {
  var gxA = ["as", "in", "of", "if", "for", "while", "finally", "var", "new", "function", "do", "return", "void", "else", "break", "catch", "instanceof", "with", "throw", "case", "default", "try", "switch", "continue", "typeof", "delete", "let", "yield", "const", "class", "debugger", "async", "await", "static", "import", "from", "export", "extends"],
    hxA = ["true", "false", "null", "undefined", "NaN", "Infinity"],
    ws9 = ["Intl", "DataView", "Number", "Math", "Date", "String", "RegExp", "Object", "Function", "Boolean", "Error", "Symbol", "Set", "Map", "WeakSet", "WeakMap", "Proxy", "Reflect", "JSON", "Promise", "Float64Array", "Int16Array", "Int32Array", "Int8Array", "Uint16Array", "Uint32Array", "Float32Array", "Array", "Uint8Array", "Uint8ClampedArray", "ArrayBuffer", "BigInt64Array", "BigUint64Array", "BigInt"],
    Es9 = ["EvalError", "InternalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError"],
    Us9 = ["setInterval", "setTimeout", "clearInterval", "clearTimeout", "require", "exports", "eval", "isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "escape", "unescape"],
    Ns9 = ["arguments", "this", "super", "console", "window", "document", "localStorage", "module", "global"],
    mxA = [].concat(Us9, Ns9, ws9, Es9);

  function $s9(A) {
    if (!A) return null;
    if (typeof A === "string") return A;
    return A.source
  }

  function bxA(A) {
    return sT1("(?=", A, ")")
  }

  function sT1(...A) {
    return A.map((Q) => $s9(Q)).join("")
  }

  function qs9(A) {
    let B = (T, {
        after: L
      }) => {
        let _ = "</" + T[0].slice(1);
        return T.input.indexOf(_, L) !== -1
      },
      Q = "[A-Za-z$_][0-9A-Za-z$_]*",
      I = {
        begin: "<>",
        end: "</>"
      },
      G = {
        begin: /<[A-Za-z0-9\\._:-]+/,
        end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
        isTrulyOpeningTag: (T, L) => {
          let _ = T[0].length + T.index,
            k = T.input[_];
          if (k === "<") {
            L.ignoreMatch();
            return
          }
          if (k === ">") {
            if (!B(T, {
                after: _
              })) L.ignoreMatch()
          }
        }
      },
      Z = {
        $pattern: "[A-Za-z$_][0-9A-Za-z$_]*",
        keyword: gxA,
        literal: hxA,
        built_in: mxA
      },
      D = "[0-9](_?[0-9])*",
      Y = "\\.([0-9](_?[0-9])*)",
      W = "0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*",
      J = {
        className: "number",
        variants: [{
          begin: "(\\b(0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*)((\\.([0-9](_?[0-9])*))|\\.)?|(\\.([0-9](_?[0-9])*)))[eE][+-]?([0-9](_?[0-9])*)\\b"
        }, {
          begin: "\\b(0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*)\\b((\\.([0-9](_?[0-9])*))\\b|\\.)?|(\\.([0-9](_?[0-9])*))\\b"
        }, {
          begin: "\\b(0|[1-9](_?[0-9])*)n\\b"
        }, {
          begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b"
        }, {
          begin: "\\b0[bB][0-1](_?[0-1])*n?\\b"
        }, {
          begin: "\\b0[oO][0-7](_?[0-7])*n?\\b"
        }, {
          begin: "\\b0[0-7]+n?\\b"
        }],
        relevance: 0
      },
      F = {
        className: "subst",
        begin: "\\$\\{",
        end: "\\}",
        keywords: Z,
        contains: []
      },
      X = {
        begin: "html`",
        end: "",
        starts: {
          end: "`",
          returnEnd: !1,
          contains: [A.BACKSLASH_ESCAPE, F],
          subLanguage: "xml"
        }
      },
      V = {
        begin: "css`",
        end: "",
        starts: {
          end: "`",
          returnEnd: !1,
          contains: [A.BACKSLASH_ESCAPE, F],
          subLanguage: "css"
        }
      },
      C = {
        className: "string",
        begin: "`",
        end: "`",
        contains: [A.BACKSLASH_ESCAPE, F]
      },
      E = {
        className: "comment",
        variants: [A.COMMENT(/\/\*\*(?!\/)/, "\\*/", {
          relevance: 0,
          contains: [{
            className: "doctag",
            begin: "@[A-Za-z]+",
            contains: [{
              className: "type",
              begin: "\\{",
              end: "\\}",
              relevance: 0
            }, {
              className: "variable",
              begin: "[A-Za-z$_][0-9A-Za-z$_]*(?=\\s*(-)|$)",
              endsParent: !0,
              relevance: 0
            }, {
              begin: /(?=[^\n])\s/,
              relevance: 0
            }]
          }]
        }), A.C_BLOCK_COMMENT_MODE, A.C_LINE_COMMENT_MODE]
      },
      N = [A.APOS_STRING_MODE, A.QUOTE_STRING_MODE, X, V, C, J, A.REGEXP_MODE];
    F.contains = N.concat({
      begin: /\{/,
      end: /\}/,
      keywords: Z,
      contains: ["self"].concat(N)
    });
    let q = [].concat(E, F.contains),
      O = q.concat([{
        begin: /\(/,
        end: /\)/,
        keywords: Z,
        contains: ["self"].concat(q)
      }]),
      R = {
        className: "params",
        begin: /\(/,
        end: /\)/,
        excludeBegin: !0,
        excludeEnd: !0,
        keywords: Z,
        contains: O
      };
    return {
      name: "Javascript",
      aliases: ["js", "jsx", "mjs", "cjs"],
      keywords: Z,
      exports: {
        PARAMS_CONTAINS: O
      },
      illegal: /#(?![$_A-z])/,
      contains: [A.SHEBANG({
        label: "shebang",
        binary: "node",
        relevance: 5
      }), {
        label: "use_strict",
        className: "meta",
        relevance: 10,
        begin: /^\s*['"]use (strict|asm)['"]/
      }, A.APOS_STRING_MODE, A.QUOTE_STRING_MODE, X, V, C, E, J, {
        begin: sT1(/[{,\n]\s*/, bxA(sT1(/(((\/\/.*$)|(\/\*(\*[^/]|[^*])*\*\/))\s*)*/, "[A-Za-z$_][0-9A-Za-z$_]*\\s*:"))),
        relevance: 0,
        contains: [{
          className: "attr",
          begin: "[A-Za-z$_][0-9A-Za-z$_]*" + bxA("\\s*:"),
          relevance: 0
        }]
      }, {
        begin: "(" + A.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
        keywords: "return throw case",
        contains: [E, A.REGEXP_MODE, {
          className: "function",
          begin: "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + A.UNDERSCORE_IDENT_RE + ")\\s*=>",
          returnBegin: !0,
          end: "\\s*=>",
          contains: [{
            className: "params",
            variants: [{
              begin: A.UNDERSCORE_IDENT_RE,
              relevance: 0
            }, {
              className: null,
              begin: /\(\s*\)/,
              skip: !0
            }, {
              begin: /\(/,
              end: /\)/,
              excludeBegin: !0,
              excludeEnd: !0,
              keywords: Z,
              contains: O
            }]
          }]
        }, {
          begin: /,/,
          relevance: 0
        }, {
          className: "",
          begin: /\s/,
          end: /\s*/,
          skip: !0
        }, {
          variants: [{
            begin: I.begin,
            end: I.end
          }, {
            begin: G.begin,
            "on:begin": G.isTrulyOpeningTag,
            end: G.end
          }],
          subLanguage: "xml",
          contains: [{
            begin: G.begin,
            end: G.end,
            skip: !0,
            contains: ["self"]
          }]
        }],
        relevance: 0
      }, {
        className: "function",
        beginKeywords: "function",
        end: /[{;]/,
        excludeEnd: !0,
        keywords: Z,
        contains: ["self", A.inherit(A.TITLE_MODE, {
          begin: "[A-Za-z$_][0-9A-Za-z$_]*"
        }), R],
        illegal: /%/
      }, {
        beginKeywords: "while if switch catch for"
      }, {
        className: "function",
        begin: A.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
        returnBegin: !0,
        contains: [R, A.inherit(A.TITLE_MODE, {
          begin: "[A-Za-z$_][0-9A-Za-z$_]*"
        })]
      }, {
        variants: [{
          begin: "\\.[A-Za-z$_][0-9A-Za-z$_]*"
        }, {
          begin: "\\$[A-Za-z$_][0-9A-Za-z$_]*"
        }],
        relevance: 0
      }, {
        className: "class",
        beginKeywords: "class",
        end: /[{;=]/,
        excludeEnd: !0,
        illegal: /[:"[\]]/,
        contains: [{
          beginKeywords: "extends"
        }, A.UNDERSCORE_TITLE_MODE]
      }, {
        begin: /\b(?=constructor)/,
        end: /[{;]/,
        excludeEnd: !0,
        contains: [A.inherit(A.TITLE_MODE, {
          begin: "[A-Za-z$_][0-9A-Za-z$_]*"
        }), "self", R]
      }, {
        begin: "(get|set)\\s+(?=[A-Za-z$_][0-9A-Za-z$_]*\\()",
        end: /\{/,
        keywords: "get set",
        contains: [A.inherit(A.TITLE_MODE, {
          begin: "[A-Za-z$_][0-9A-Za-z$_]*"
        }), {
          begin: /\(\)/
        }, R]
      }, {
        begin: /\$[(.]/
      }]
    }
  }

  function Ms9(A) {
    let Q = {
        beginKeywords: "namespace",
        end: /\{/,
        excludeEnd: !0
      },
      I = {
        beginKeywords: "interface",
        end: /\{/,
        excludeEnd: !0,
        keywords: "interface extends"
      },
      G = {
        className: "meta",
        relevance: 10,
        begin: /^\s*['"]use strict['"]/
      },
      Z = ["any", "void", "number", "boolean", "string", "object", "never", "enum"],
      D = ["type", "namespace", "typedef", "interface", "public", "private", "protected", "implements", "declare", "abstract", "readonly"],
      Y = {
        $pattern: "[A-Za-z$_][0-9A-Za-z$_]*",
        keyword: gxA.concat(D),
        literal: hxA,
        built_in: mxA.concat(Z)
      },
      W = {
        className: "meta",
        begin: "@[A-Za-z$_][0-9A-Za-z$_]*"
      },
      J = (V, C, K) => {
        let E = V.contains.findIndex((N) => N.label === C);
        if (E === -1) throw new Error("can not find mode to replace");
        V.contains.splice(E, 1, K)
      },
      F = qs9(A);
    Object.assign(F.keywords, Y), F.exports.PARAMS_CONTAINS.push(W), F.contains = F.contains.concat([W, Q, I]), J(F, "shebang", A.SHEBANG()), J(F, "use_strict", G);
    let X = F.contains.find((V) => V.className === "function");
    return X.relevance = 0, Object.assign(F, {
      name: "TypeScript",
      aliases: ["ts", "tsx"]
    }), F
  }
  dxA.exports = Ms9
})
// @from(Start 2251980, End 2253152)
cxA = z((NA8, pxA) => {
  function Ls9(A) {
    return {
      name: "Vala",
      keywords: {
        keyword: "char uchar unichar int uint long ulong short ushort int8 int16 int32 int64 uint8 uint16 uint32 uint64 float double bool struct enum string void weak unowned owned async signal static abstract interface override virtual delegate if while do for foreach else switch case break default return try catch public private protected internal using new this get set const stdout stdin stderr var",
        built_in: "DBus GLib CCode Gee Object Gtk Posix",
        literal: "false true null"
      },
      contains: [{
        className: "class",
        beginKeywords: "class interface namespace",
        end: /\{/,
        excludeEnd: !0,
        illegal: "[^,:\\n\\s\\.]",
        contains: [A.UNDERSCORE_TITLE_MODE]
      }, A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, {
        className: "string",
        begin: '"""',
        end: '"""',
        relevance: 5
      }, A.APOS_STRING_MODE, A.QUOTE_STRING_MODE, A.C_NUMBER_MODE, {
        className: "meta",
        begin: "^#",
        end: "$",
        relevance: 2
      }]
    }
  }
  pxA.exports = Ls9
})
// @from(Start 2253158, End 2256874)
nxA = z(($A8, ixA) => {
  function lxA(A) {
    if (!A) return null;
    if (typeof A === "string") return A;
    return A.source
  }

  function M81(...A) {
    return A.map((Q) => lxA(Q)).join("")
  }

  function rT1(...A) {
    return "(" + A.map((Q) => lxA(Q)).join("|") + ")"
  }

  function Rs9(A) {
    let B = {
        className: "string",
        begin: /"(""|[^/n])"C\b/
      },
      Q = {
        className: "string",
        begin: /"/,
        end: /"/,
        illegal: /\n/,
        contains: [{
          begin: /""/
        }]
      },
      I = /\d{1,2}\/\d{1,2}\/\d{4}/,
      G = /\d{4}-\d{1,2}-\d{1,2}/,
      Z = /(\d|1[012])(:\d+){0,2} *(AM|PM)/,
      D = /\d{1,2}(:\d{1,2}){1,2}/,
      Y = {
        className: "literal",
        variants: [{
          begin: M81(/# */, rT1(G, I), / *#/)
        }, {
          begin: M81(/# */, D, / *#/)
        }, {
          begin: M81(/# */, Z, / *#/)
        }, {
          begin: M81(/# */, rT1(G, I), / +/, rT1(Z, D), / *#/)
        }]
      },
      W = {
        className: "number",
        relevance: 0,
        variants: [{
          begin: /\b\d[\d_]*((\.[\d_]+(E[+-]?[\d_]+)?)|(E[+-]?[\d_]+))[RFD@!#]?/
        }, {
          begin: /\b\d[\d_]*((U?[SIL])|[%&])?/
        }, {
          begin: /&H[\dA-F_]+((U?[SIL])|[%&])?/
        }, {
          begin: /&O[0-7_]+((U?[SIL])|[%&])?/
        }, {
          begin: /&B[01_]+((U?[SIL])|[%&])?/
        }]
      },
      J = {
        className: "label",
        begin: /^\w+:/
      },
      F = A.COMMENT(/'''/, /$/, {
        contains: [{
          className: "doctag",
          begin: /<\/?/,
          end: />/
        }]
      }),
      X = A.COMMENT(null, /$/, {
        variants: [{
          begin: /'/
        }, {
          begin: /([\t ]|^)REM(?=\s)/
        }]
      });
    return {
      name: "Visual Basic .NET",
      aliases: ["vb"],
      case_insensitive: !0,
      classNameAliases: {
        label: "symbol"
      },
      keywords: {
        keyword: "addhandler alias aggregate ansi as async assembly auto binary by byref byval call case catch class compare const continue custom declare default delegate dim distinct do each equals else elseif end enum erase error event exit explicit finally for friend from function get global goto group handles if implements imports in inherits interface into iterator join key let lib loop me mid module mustinherit mustoverride mybase myclass namespace narrowing new next notinheritable notoverridable of off on operator option optional order overloads overridable overrides paramarray partial preserve private property protected public raiseevent readonly redim removehandler resume return select set shadows shared skip static step stop structure strict sub synclock take text then throw to try unicode until using when where while widening with withevents writeonly yield",
        built_in: "addressof and andalso await directcast gettype getxmlnamespace is isfalse isnot istrue like mod nameof new not or orelse trycast typeof xor cbool cbyte cchar cdate cdbl cdec cint clng cobj csbyte cshort csng cstr cuint culng cushort",
        type: "boolean byte char date decimal double integer long object sbyte short single string uinteger ulong ushort",
        literal: "true false nothing"
      },
      illegal: "//|\\{|\\}|endif|gosub|variant|wend|^\\$ ",
      contains: [B, Q, Y, W, J, F, X, {
        className: "meta",
        begin: /[\t ]*#(const|disable|else|elseif|enable|end|externalsource|if|region)\b/,
        end: /$/,
        keywords: {
          "meta-keyword": "const disable else elseif enable end externalsource if region then"
        },
        contains: [X]
      }]
    }
  }
  ixA.exports = Rs9
})
// @from(Start 2256880, End 2258935)
rxA = z((qA8, sxA) => {
  function axA(A) {
    if (!A) return null;
    if (typeof A === "string") return A;
    return A.source
  }

  function Os9(...A) {
    return A.map((Q) => axA(Q)).join("")
  }

  function Ts9(...A) {
    return "(" + A.map((Q) => axA(Q)).join("|") + ")"
  }

  function Ps9(A) {
    let B = "lcase month vartype instrrev ubound setlocale getobject rgb getref string weekdayname rnd dateadd monthname now day minute isarray cbool round formatcurrency conversions csng timevalue second year space abs clng timeserial fixs len asc isempty maths dateserial atn timer isobject filter weekday datevalue ccur isdate instr datediff formatdatetime replace isnull right sgn array snumeric log cdbl hex chr lbound msgbox ucase getlocale cos cdate cbyte rtrim join hour oct typename trim strcomp int createobject loadpicture tan formatnumber mid split  cint sin datepart ltrim sqr time derived eval date formatpercent exp inputbox left ascw chrw regexp cstr err".split(" "),
      Q = ["server", "response", "request", "scriptengine", "scriptenginebuildversion", "scriptengineminorversion", "scriptenginemajorversion"],
      I = {
        begin: Os9(Ts9(...B), "\\s*\\("),
        relevance: 0,
        keywords: {
          built_in: B
        }
      };
    return {
      name: "VBScript",
      aliases: ["vbs"],
      case_insensitive: !0,
      keywords: {
        keyword: "call class const dim do loop erase execute executeglobal exit for each next function if then else on error option explicit new private property let get public randomize redim rem select case set stop sub while wend with end to elseif is or xor and not class_initialize class_terminate default preserve in me byval byref step resume goto",
        built_in: Q,
        literal: "true false null nothing empty"
      },
      illegal: "//",
      contains: [I, A.inherit(A.QUOTE_STRING_MODE, {
        contains: [{
          begin: '""'
        }]
      }), A.COMMENT(/'/, /$/, {
        relevance: 0
      }), A.C_NUMBER_MODE]
    }
  }
  sxA.exports = Ps9
})
// @from(Start 2258941, End 2259188)
txA = z((MA8, oxA) => {
  function Ss9(A) {
    return {
      name: "VBScript in HTML",
      subLanguage: "xml",
      contains: [{
        begin: "<%",
        end: "%>",
        subLanguage: "vbscript"
      }]
    }
  }
  oxA.exports = Ss9
})
// @from(Start 2259194, End 2264450)
AfA = z((LA8, exA) => {
  function _s9(A) {
    return {
      name: "Verilog",
      aliases: ["v", "sv", "svh"],
      case_insensitive: !1,
      keywords: {
        $pattern: /[\w\$]+/,
        keyword: "accept_on alias always always_comb always_ff always_latch and assert assign assume automatic before begin bind bins binsof bit break buf|0 bufif0 bufif1 byte case casex casez cell chandle checker class clocking cmos config const constraint context continue cover covergroup coverpoint cross deassign default defparam design disable dist do edge else end endcase endchecker endclass endclocking endconfig endfunction endgenerate endgroup endinterface endmodule endpackage endprimitive endprogram endproperty endspecify endsequence endtable endtask enum event eventually expect export extends extern final first_match for force foreach forever fork forkjoin function generate|5 genvar global highz0 highz1 if iff ifnone ignore_bins illegal_bins implements implies import incdir include initial inout input inside instance int integer interconnect interface intersect join join_any join_none large let liblist library local localparam logic longint macromodule matches medium modport module nand negedge nettype new nexttime nmos nor noshowcancelled not notif0 notif1 or output package packed parameter pmos posedge primitive priority program property protected pull0 pull1 pulldown pullup pulsestyle_ondetect pulsestyle_onevent pure rand randc randcase randsequence rcmos real realtime ref reg reject_on release repeat restrict return rnmos rpmos rtran rtranif0 rtranif1 s_always s_eventually s_nexttime s_until s_until_with scalared sequence shortint shortreal showcancelled signed small soft solve specify specparam static string strong strong0 strong1 struct super supply0 supply1 sync_accept_on sync_reject_on table tagged task this throughout time timeprecision timeunit tran tranif0 tranif1 tri tri0 tri1 triand trior trireg type typedef union unique unique0 unsigned until until_with untyped use uwire var vectored virtual void wait wait_order wand weak weak0 weak1 while wildcard wire with within wor xnor xor",
        literal: "null",
        built_in: "$finish $stop $exit $fatal $error $warning $info $realtime $time $printtimescale $bitstoreal $bitstoshortreal $itor $signed $cast $bits $stime $timeformat $realtobits $shortrealtobits $rtoi $unsigned $asserton $assertkill $assertpasson $assertfailon $assertnonvacuouson $assertoff $assertcontrol $assertpassoff $assertfailoff $assertvacuousoff $isunbounded $sampled $fell $changed $past_gclk $fell_gclk $changed_gclk $rising_gclk $steady_gclk $coverage_control $coverage_get $coverage_save $set_coverage_db_name $rose $stable $past $rose_gclk $stable_gclk $future_gclk $falling_gclk $changing_gclk $display $coverage_get_max $coverage_merge $get_coverage $load_coverage_db $typename $unpacked_dimensions $left $low $increment $clog2 $ln $log10 $exp $sqrt $pow $floor $ceil $sin $cos $tan $countbits $onehot $isunknown $fatal $warning $dimensions $right $high $size $asin $acos $atan $atan2 $hypot $sinh $cosh $tanh $asinh $acosh $atanh $countones $onehot0 $error $info $random $dist_chi_square $dist_erlang $dist_exponential $dist_normal $dist_poisson $dist_t $dist_uniform $q_initialize $q_remove $q_exam $async$and$array $async$nand$array $async$or$array $async$nor$array $sync$and$array $sync$nand$array $sync$or$array $sync$nor$array $q_add $q_full $psprintf $async$and$plane $async$nand$plane $async$or$plane $async$nor$plane $sync$and$plane $sync$nand$plane $sync$or$plane $sync$nor$plane $system $display $displayb $displayh $displayo $strobe $strobeb $strobeh $strobeo $write $readmemb $readmemh $writememh $value$plusargs $dumpvars $dumpon $dumplimit $dumpports $dumpportson $dumpportslimit $writeb $writeh $writeo $monitor $monitorb $monitorh $monitoro $writememb $dumpfile $dumpoff $dumpall $dumpflush $dumpportsoff $dumpportsall $dumpportsflush $fclose $fdisplay $fdisplayb $fdisplayh $fdisplayo $fstrobe $fstrobeb $fstrobeh $fstrobeo $swrite $swriteb $swriteh $swriteo $fscanf $fread $fseek $fflush $feof $fopen $fwrite $fwriteb $fwriteh $fwriteo $fmonitor $fmonitorb $fmonitorh $fmonitoro $sformat $sformatf $fgetc $ungetc $fgets $sscanf $rewind $ftell $ferror"
      },
      contains: [A.C_BLOCK_COMMENT_MODE, A.C_LINE_COMMENT_MODE, A.QUOTE_STRING_MODE, {
        className: "number",
        contains: [A.BACKSLASH_ESCAPE],
        variants: [{
          begin: "\\b((\\d+'(b|h|o|d|B|H|O|D))[0-9xzXZa-fA-F_]+)"
        }, {
          begin: "\\B(('(b|h|o|d|B|H|O|D))[0-9xzXZa-fA-F_]+)"
        }, {
          begin: "\\b([0-9_])+",
          relevance: 0
        }]
      }, {
        className: "variable",
        variants: [{
          begin: "#\\((?!parameter).+\\)"
        }, {
          begin: "\\.\\w+",
          relevance: 0
        }]
      }, {
        className: "meta",
        begin: "`",
        end: "$",
        keywords: {
          "meta-keyword": "define __FILE__ __LINE__ begin_keywords celldefine default_nettype define else elsif end_keywords endcelldefine endif ifdef ifndef include line nounconnected_drive pragma resetall timescale unconnected_drive undef undefineall"
        },
        relevance: 0
      }]
    }
  }
  exA.exports = _s9
})
// @from(Start 2264456, End 2266414)
QfA = z((RA8, BfA) => {
  function js9(A) {
    let Q = "[eE][-+]?\\d(_|\\d)*",
      I = "\\d(_|\\d)*(\\.\\d(_|\\d)*)?(" + Q + ")?",
      G = "\\w+",
      D = "\\b(" + ("\\d(_|\\d)*#\\w+(\\.\\w+)?#(" + Q + ")?") + "|" + I + ")";
    return {
      name: "VHDL",
      case_insensitive: !0,
      keywords: {
        keyword: "abs access after alias all and architecture array assert assume assume_guarantee attribute begin block body buffer bus case component configuration constant context cover disconnect downto default else elsif end entity exit fairness file for force function generate generic group guarded if impure in inertial inout is label library linkage literal loop map mod nand new next nor not null of on open or others out package parameter port postponed procedure process property protected pure range record register reject release rem report restrict restrict_guarantee return rol ror select sequence severity shared signal sla sll sra srl strong subtype then to transport type unaffected units until use variable view vmode vprop vunit wait when while with xnor xor",
        built_in: "boolean bit character integer time delay_length natural positive string bit_vector file_open_kind file_open_status std_logic std_logic_vector unsigned signed boolean_vector integer_vector std_ulogic std_ulogic_vector unresolved_unsigned u_unsigned unresolved_signed u_signed real_vector time_vector",
        literal: "false true note warning error failure line text side width"
      },
      illegal: /\{/,
      contains: [A.C_BLOCK_COMMENT_MODE, A.COMMENT("--", "$"), A.QUOTE_STRING_MODE, {
        className: "number",
        begin: D,
        relevance: 0
      }, {
        className: "string",
        begin: "'(U|X|0|1|Z|W|L|H|-)'",
        contains: [A.BACKSLASH_ESCAPE]
      }, {
        className: "symbol",
        begin: "'[A-Za-z](_?[A-Za-z0-9])*",
        contains: [A.BACKSLASH_ESCAPE]
      }]
    }
  }
  BfA.exports = js9
})
// @from(Start 2266420, End 2275339)
GfA = z((OA8, IfA) => {
  function ys9(A) {
    return {
      name: "Vim Script",
      keywords: {
        $pattern: /[!#@\w]+/,
        keyword: "N|0 P|0 X|0 a|0 ab abc abo al am an|0 ar arga argd arge argdo argg argl argu as au aug aun b|0 bN ba bad bd be bel bf bl bm bn bo bp br brea breaka breakd breakl bro bufdo buffers bun bw c|0 cN cNf ca cabc caddb cad caddf cal cat cb cc ccl cd ce cex cf cfir cgetb cgete cg changes chd che checkt cl cla clo cm cmapc cme cn cnew cnf cno cnorea cnoreme co col colo com comc comp con conf cope cp cpf cq cr cs cst cu cuna cunme cw delm deb debugg delc delf dif diffg diffo diffp diffpu diffs diffthis dig di dl dell dj dli do doautoa dp dr ds dsp e|0 ea ec echoe echoh echom echon el elsei em en endfo endf endt endw ene ex exe exi exu f|0 files filet fin fina fini fir fix fo foldc foldd folddoc foldo for fu go gr grepa gu gv ha helpf helpg helpt hi hid his ia iabc if ij il im imapc ime ino inorea inoreme int is isp iu iuna iunme j|0 ju k|0 keepa kee keepj lN lNf l|0 lad laddb laddf la lan lat lb lc lch lcl lcs le lefta let lex lf lfir lgetb lgete lg lgr lgrepa lh ll lla lli lmak lm lmapc lne lnew lnf ln loadk lo loc lockv lol lope lp lpf lr ls lt lu lua luad luaf lv lvimgrepa lw m|0 ma mak map mapc marks mat me menut mes mk mks mksp mkv mkvie mod mz mzf nbc nb nbs new nm nmapc nme nn nnoreme noa no noh norea noreme norm nu nun nunme ol o|0 om omapc ome on ono onoreme opt ou ounme ow p|0 profd prof pro promptr pc ped pe perld po popu pp pre prev ps pt ptN ptf ptj ptl ptn ptp ptr pts pu pw py3 python3 py3d py3f py pyd pyf quita qa rec red redi redr redraws reg res ret retu rew ri rightb rub rubyd rubyf rund ru rv sN san sa sal sav sb sbN sba sbf sbl sbm sbn sbp sbr scrip scripte scs se setf setg setl sf sfir sh sim sig sil sl sla sm smap smapc sme sn sni sno snor snoreme sor so spelld spe spelli spellr spellu spellw sp spr sre st sta startg startr star stopi stj sts sun sunm sunme sus sv sw sy synti sync tN tabN tabc tabdo tabe tabf tabfir tabl tabm tabnew tabn tabo tabp tabr tabs tab ta tags tc tcld tclf te tf th tj tl tm tn to tp tr try ts tu u|0 undoj undol una unh unl unlo unm unme uns up ve verb vert vim vimgrepa vi viu vie vm vmapc vme vne vn vnoreme vs vu vunme windo w|0 wN wa wh wi winc winp wn wp wq wqa ws wu wv x|0 xa xmapc xm xme xn xnoreme xu xunme y|0 z|0 ~ Next Print append abbreviate abclear aboveleft all amenu anoremenu args argadd argdelete argedit argglobal arglocal argument ascii autocmd augroup aunmenu buffer bNext ball badd bdelete behave belowright bfirst blast bmodified bnext botright bprevious brewind break breakadd breakdel breaklist browse bunload bwipeout change cNext cNfile cabbrev cabclear caddbuffer caddexpr caddfile call catch cbuffer cclose center cexpr cfile cfirst cgetbuffer cgetexpr cgetfile chdir checkpath checktime clist clast close cmap cmapclear cmenu cnext cnewer cnfile cnoremap cnoreabbrev cnoremenu copy colder colorscheme command comclear compiler continue confirm copen cprevious cpfile cquit crewind cscope cstag cunmap cunabbrev cunmenu cwindow delete delmarks debug debuggreedy delcommand delfunction diffupdate diffget diffoff diffpatch diffput diffsplit digraphs display deletel djump dlist doautocmd doautoall deletep drop dsearch dsplit edit earlier echo echoerr echohl echomsg else elseif emenu endif endfor endfunction endtry endwhile enew execute exit exusage file filetype find finally finish first fixdel fold foldclose folddoopen folddoclosed foldopen function global goto grep grepadd gui gvim hardcopy help helpfind helpgrep helptags highlight hide history insert iabbrev iabclear ijump ilist imap imapclear imenu inoremap inoreabbrev inoremenu intro isearch isplit iunmap iunabbrev iunmenu join jumps keepalt keepmarks keepjumps lNext lNfile list laddexpr laddbuffer laddfile last language later lbuffer lcd lchdir lclose lcscope left leftabove lexpr lfile lfirst lgetbuffer lgetexpr lgetfile lgrep lgrepadd lhelpgrep llast llist lmake lmap lmapclear lnext lnewer lnfile lnoremap loadkeymap loadview lockmarks lockvar lolder lopen lprevious lpfile lrewind ltag lunmap luado luafile lvimgrep lvimgrepadd lwindow move mark make mapclear match menu menutranslate messages mkexrc mksession mkspell mkvimrc mkview mode mzscheme mzfile nbclose nbkey nbsart next nmap nmapclear nmenu nnoremap nnoremenu noautocmd noremap nohlsearch noreabbrev noremenu normal number nunmap nunmenu oldfiles open omap omapclear omenu only onoremap onoremenu options ounmap ounmenu ownsyntax print profdel profile promptfind promptrepl pclose pedit perl perldo pop popup ppop preserve previous psearch ptag ptNext ptfirst ptjump ptlast ptnext ptprevious ptrewind ptselect put pwd py3do py3file python pydo pyfile quit quitall qall read recover redo redir redraw redrawstatus registers resize retab return rewind right rightbelow ruby rubydo rubyfile rundo runtime rviminfo substitute sNext sandbox sargument sall saveas sbuffer sbNext sball sbfirst sblast sbmodified sbnext sbprevious sbrewind scriptnames scriptencoding scscope set setfiletype setglobal setlocal sfind sfirst shell simalt sign silent sleep slast smagic smapclear smenu snext sniff snomagic snoremap snoremenu sort source spelldump spellgood spellinfo spellrepall spellundo spellwrong split sprevious srewind stop stag startgreplace startreplace startinsert stopinsert stjump stselect sunhide sunmap sunmenu suspend sview swapname syntax syntime syncbind tNext tabNext tabclose tabedit tabfind tabfirst tablast tabmove tabnext tabonly tabprevious tabrewind tag tcl tcldo tclfile tearoff tfirst throw tjump tlast tmenu tnext topleft tprevious trewind tselect tunmenu undo undojoin undolist unabbreviate unhide unlet unlockvar unmap unmenu unsilent update vglobal version verbose vertical vimgrep vimgrepadd visual viusage view vmap vmapclear vmenu vnew vnoremap vnoremenu vsplit vunmap vunmenu write wNext wall while winsize wincmd winpos wnext wprevious wqall wsverb wundo wviminfo xit xall xmapclear xmap xmenu xnoremap xnoremenu xunmap xunmenu yank",
        built_in: "synIDtrans atan2 range matcharg did_filetype asin feedkeys xor argv complete_check add getwinposx getqflist getwinposy screencol clearmatches empty extend getcmdpos mzeval garbagecollect setreg ceil sqrt diff_hlID inputsecret get getfperm getpid filewritable shiftwidth max sinh isdirectory synID system inputrestore winline atan visualmode inputlist tabpagewinnr round getregtype mapcheck hasmapto histdel argidx findfile sha256 exists toupper getcmdline taglist string getmatches bufnr strftime winwidth bufexists strtrans tabpagebuflist setcmdpos remote_read printf setloclist getpos getline bufwinnr float2nr len getcmdtype diff_filler luaeval resolve libcallnr foldclosedend reverse filter has_key bufname str2float strlen setline getcharmod setbufvar index searchpos shellescape undofile foldclosed setqflist buflisted strchars str2nr virtcol floor remove undotree remote_expr winheight gettabwinvar reltime cursor tabpagenr finddir localtime acos getloclist search tanh matchend rename gettabvar strdisplaywidth type abs py3eval setwinvar tolower wildmenumode log10 spellsuggest bufloaded synconcealed nextnonblank server2client complete settabwinvar executable input wincol setmatches getftype hlID inputsave searchpair or screenrow line settabvar histadd deepcopy strpart remote_peek and eval getftime submatch screenchar winsaveview matchadd mkdir screenattr getfontname libcall reltimestr getfsize winnr invert pow getbufline byte2line soundfold repeat fnameescape tagfiles sin strwidth spellbadword trunc maparg log lispindent hostname setpos globpath remote_foreground getchar synIDattr fnamemodify cscope_connection stridx winbufnr indent min complete_add nr2char searchpairpos inputdialog values matchlist items hlexists strridx browsedir expand fmod pathshorten line2byte argc count getwinvar glob foldtextresult getreg foreground cosh matchdelete has char2nr simplify histget searchdecl iconv winrestcmd pumvisible writefile foldlevel haslocaldir keys cos matchstr foldtext histnr tan tempname getcwd byteidx getbufvar islocked escape eventhandler remote_send serverlist winrestview synstack pyeval prevnonblank readfile cindent filereadable changenr exp"
      },
      illegal: /;/,
      contains: [A.NUMBER_MODE, {
        className: "string",
        begin: "'",
        end: "'",
        illegal: "\\n"
      }, {
        className: "string",
        begin: /"(\\"|\n\\|[^"\n])*"/
      }, A.COMMENT('"', "$"), {
        className: "variable",
        begin: /[bwtglsav]:[\w\d_]*/
      }, {
        className: "function",
        beginKeywords: "function function!",
        end: "$",
        relevance: 0,
        contains: [A.TITLE_MODE, {
          className: "params",
          begin: "\\(",
          end: "\\)"
        }]
      }, {
        className: "symbol",
        begin: /<[\w-]+>/
      }]
    }
  }
  IfA.exports = ys9
})
// @from(Start 2275345, End 2294927)
DfA = z((TA8, ZfA) => {
  function ks9(A) {
    return {
      name: "Intel x86 Assembly",
      case_insensitive: !0,
      keywords: {
        $pattern: "[.%]?" + A.IDENT_RE,
        keyword: "lock rep repe repz repne repnz xaquire xrelease bnd nobnd aaa aad aam aas adc add and arpl bb0_reset bb1_reset bound bsf bsr bswap bt btc btr bts call cbw cdq cdqe clc cld cli clts cmc cmp cmpsb cmpsd cmpsq cmpsw cmpxchg cmpxchg486 cmpxchg8b cmpxchg16b cpuid cpu_read cpu_write cqo cwd cwde daa das dec div dmint emms enter equ f2xm1 fabs fadd faddp fbld fbstp fchs fclex fcmovb fcmovbe fcmove fcmovnb fcmovnbe fcmovne fcmovnu fcmovu fcom fcomi fcomip fcomp fcompp fcos fdecstp fdisi fdiv fdivp fdivr fdivrp femms feni ffree ffreep fiadd ficom ficomp fidiv fidivr fild fimul fincstp finit fist fistp fisttp fisub fisubr fld fld1 fldcw fldenv fldl2e fldl2t fldlg2 fldln2 fldpi fldz fmul fmulp fnclex fndisi fneni fninit fnop fnsave fnstcw fnstenv fnstsw fpatan fprem fprem1 fptan frndint frstor fsave fscale fsetpm fsin fsincos fsqrt fst fstcw fstenv fstp fstsw fsub fsubp fsubr fsubrp ftst fucom fucomi fucomip fucomp fucompp fxam fxch fxtract fyl2x fyl2xp1 hlt ibts icebp idiv imul in inc incbin insb insd insw int int01 int1 int03 int3 into invd invpcid invlpg invlpga iret iretd iretq iretw jcxz jecxz jrcxz jmp jmpe lahf lar lds lea leave les lfence lfs lgdt lgs lidt lldt lmsw loadall loadall286 lodsb lodsd lodsq lodsw loop loope loopne loopnz loopz lsl lss ltr mfence monitor mov movd movq movsb movsd movsq movsw movsx movsxd movzx mul mwait neg nop not or out outsb outsd outsw packssdw packsswb packuswb paddb paddd paddsb paddsiw paddsw paddusb paddusw paddw pand pandn pause paveb pavgusb pcmpeqb pcmpeqd pcmpeqw pcmpgtb pcmpgtd pcmpgtw pdistib pf2id pfacc pfadd pfcmpeq pfcmpge pfcmpgt pfmax pfmin pfmul pfrcp pfrcpit1 pfrcpit2 pfrsqit1 pfrsqrt pfsub pfsubr pi2fd pmachriw pmaddwd pmagw pmulhriw pmulhrwa pmulhrwc pmulhw pmullw pmvgezb pmvlzb pmvnzb pmvzb pop popa popad popaw popf popfd popfq popfw por prefetch prefetchw pslld psllq psllw psrad psraw psrld psrlq psrlw psubb psubd psubsb psubsiw psubsw psubusb psubusw psubw punpckhbw punpckhdq punpckhwd punpcklbw punpckldq punpcklwd push pusha pushad pushaw pushf pushfd pushfq pushfw pxor rcl rcr rdshr rdmsr rdpmc rdtsc rdtscp ret retf retn rol ror rdm rsdc rsldt rsm rsts sahf sal salc sar sbb scasb scasd scasq scasw sfence sgdt shl shld shr shrd sidt sldt skinit smi smint smintold smsw stc std sti stosb stosd stosq stosw str sub svdc svldt svts swapgs syscall sysenter sysexit sysret test ud0 ud1 ud2b ud2 ud2a umov verr verw fwait wbinvd wrshr wrmsr xadd xbts xchg xlatb xlat xor cmove cmovz cmovne cmovnz cmova cmovnbe cmovae cmovnb cmovb cmovnae cmovbe cmovna cmovg cmovnle cmovge cmovnl cmovl cmovnge cmovle cmovng cmovc cmovnc cmovo cmovno cmovs cmovns cmovp cmovpe cmovnp cmovpo je jz jne jnz ja jnbe jae jnb jb jnae jbe jna jg jnle jge jnl jl jnge jle jng jc jnc jo jno js jns jpo jnp jpe jp sete setz setne setnz seta setnbe setae setnb setnc setb setnae setcset setbe setna setg setnle setge setnl setl setnge setle setng sets setns seto setno setpe setp setpo setnp addps addss andnps andps cmpeqps cmpeqss cmpleps cmpless cmpltps cmpltss cmpneqps cmpneqss cmpnleps cmpnless cmpnltps cmpnltss cmpordps cmpordss cmpunordps cmpunordss cmpps cmpss comiss cvtpi2ps cvtps2pi cvtsi2ss cvtss2si cvttps2pi cvttss2si divps divss ldmxcsr maxps maxss minps minss movaps movhps movlhps movlps movhlps movmskps movntps movss movups mulps mulss orps rcpps rcpss rsqrtps rsqrtss shufps sqrtps sqrtss stmxcsr subps subss ucomiss unpckhps unpcklps xorps fxrstor fxrstor64 fxsave fxsave64 xgetbv xsetbv xsave xsave64 xsaveopt xsaveopt64 xrstor xrstor64 prefetchnta prefetcht0 prefetcht1 prefetcht2 maskmovq movntq pavgb pavgw pextrw pinsrw pmaxsw pmaxub pminsw pminub pmovmskb pmulhuw psadbw pshufw pf2iw pfnacc pfpnacc pi2fw pswapd maskmovdqu clflush movntdq movnti movntpd movdqa movdqu movdq2q movq2dq paddq pmuludq pshufd pshufhw pshuflw pslldq psrldq psubq punpckhqdq punpcklqdq addpd addsd andnpd andpd cmpeqpd cmpeqsd cmplepd cmplesd cmpltpd cmpltsd cmpneqpd cmpneqsd cmpnlepd cmpnlesd cmpnltpd cmpnltsd cmpordpd cmpordsd cmpunordpd cmpunordsd cmppd comisd cvtdq2pd cvtdq2ps cvtpd2dq cvtpd2pi cvtpd2ps cvtpi2pd cvtps2dq cvtps2pd cvtsd2si cvtsd2ss cvtsi2sd cvtss2sd cvttpd2pi cvttpd2dq cvttps2dq cvttsd2si divpd divsd maxpd maxsd minpd minsd movapd movhpd movlpd movmskpd movupd mulpd mulsd orpd shufpd sqrtpd sqrtsd subpd subsd ucomisd unpckhpd unpcklpd xorpd addsubpd addsubps haddpd haddps hsubpd hsubps lddqu movddup movshdup movsldup clgi stgi vmcall vmclear vmfunc vmlaunch vmload vmmcall vmptrld vmptrst vmread vmresume vmrun vmsave vmwrite vmxoff vmxon invept invvpid pabsb pabsw pabsd palignr phaddw phaddd phaddsw phsubw phsubd phsubsw pmaddubsw pmulhrsw pshufb psignb psignw psignd extrq insertq movntsd movntss lzcnt blendpd blendps blendvpd blendvps dppd dpps extractps insertps movntdqa mpsadbw packusdw pblendvb pblendw pcmpeqq pextrb pextrd pextrq phminposuw pinsrb pinsrd pinsrq pmaxsb pmaxsd pmaxud pmaxuw pminsb pminsd pminud pminuw pmovsxbw pmovsxbd pmovsxbq pmovsxwd pmovsxwq pmovsxdq pmovzxbw pmovzxbd pmovzxbq pmovzxwd pmovzxwq pmovzxdq pmuldq pmulld ptest roundpd roundps roundsd roundss crc32 pcmpestri pcmpestrm pcmpistri pcmpistrm pcmpgtq popcnt getsec pfrcpv pfrsqrtv movbe aesenc aesenclast aesdec aesdeclast aesimc aeskeygenassist vaesenc vaesenclast vaesdec vaesdeclast vaesimc vaeskeygenassist vaddpd vaddps vaddsd vaddss vaddsubpd vaddsubps vandpd vandps vandnpd vandnps vblendpd vblendps vblendvpd vblendvps vbroadcastss vbroadcastsd vbroadcastf128 vcmpeq_ospd vcmpeqpd vcmplt_ospd vcmpltpd vcmple_ospd vcmplepd vcmpunord_qpd vcmpunordpd vcmpneq_uqpd vcmpneqpd vcmpnlt_uspd vcmpnltpd vcmpnle_uspd vcmpnlepd vcmpord_qpd vcmpordpd vcmpeq_uqpd vcmpnge_uspd vcmpngepd vcmpngt_uspd vcmpngtpd vcmpfalse_oqpd vcmpfalsepd vcmpneq_oqpd vcmpge_ospd vcmpgepd vcmpgt_ospd vcmpgtpd vcmptrue_uqpd vcmptruepd vcmplt_oqpd vcmple_oqpd vcmpunord_spd vcmpneq_uspd vcmpnlt_uqpd vcmpnle_uqpd vcmpord_spd vcmpeq_uspd vcmpnge_uqpd vcmpngt_uqpd vcmpfalse_ospd vcmpneq_ospd vcmpge_oqpd vcmpgt_oqpd vcmptrue_uspd vcmppd vcmpeq_osps vcmpeqps vcmplt_osps vcmpltps vcmple_osps vcmpleps vcmpunord_qps vcmpunordps vcmpneq_uqps vcmpneqps vcmpnlt_usps vcmpnltps vcmpnle_usps vcmpnleps vcmpord_qps vcmpordps vcmpeq_uqps vcmpnge_usps vcmpngeps vcmpngt_usps vcmpngtps vcmpfalse_oqps vcmpfalseps vcmpneq_oqps vcmpge_osps vcmpgeps vcmpgt_osps vcmpgtps vcmptrue_uqps vcmptrueps vcmplt_oqps vcmple_oqps vcmpunord_sps vcmpneq_usps vcmpnlt_uqps vcmpnle_uqps vcmpord_sps vcmpeq_usps vcmpnge_uqps vcmpngt_uqps vcmpfalse_osps vcmpneq_osps vcmpge_oqps vcmpgt_oqps vcmptrue_usps vcmpps vcmpeq_ossd vcmpeqsd vcmplt_ossd vcmpltsd vcmple_ossd vcmplesd vcmpunord_qsd vcmpunordsd vcmpneq_uqsd vcmpneqsd vcmpnlt_ussd vcmpnltsd vcmpnle_ussd vcmpnlesd vcmpord_qsd vcmpordsd vcmpeq_uqsd vcmpnge_ussd vcmpngesd vcmpngt_ussd vcmpngtsd vcmpfalse_oqsd vcmpfalsesd vcmpneq_oqsd vcmpge_ossd vcmpgesd vcmpgt_ossd vcmpgtsd vcmptrue_uqsd vcmptruesd vcmplt_oqsd vcmple_oqsd vcmpunord_ssd vcmpneq_ussd vcmpnlt_uqsd vcmpnle_uqsd vcmpord_ssd vcmpeq_ussd vcmpnge_uqsd vcmpngt_uqsd vcmpfalse_ossd vcmpneq_ossd vcmpge_oqsd vcmpgt_oqsd vcmptrue_ussd vcmpsd vcmpeq_osss vcmpeqss vcmplt_osss vcmpltss vcmple_osss vcmpless vcmpunord_qss vcmpunordss vcmpneq_uqss vcmpneqss vcmpnlt_usss vcmpnltss vcmpnle_usss vcmpnless vcmpord_qss vcmpordss vcmpeq_uqss vcmpnge_usss vcmpngess vcmpngt_usss vcmpngtss vcmpfalse_oqss vcmpfalsess vcmpneq_oqss vcmpge_osss vcmpgess vcmpgt_osss vcmpgtss vcmptrue_uqss vcmptruess vcmplt_oqss vcmple_oqss vcmpunord_sss vcmpneq_usss vcmpnlt_uqss vcmpnle_uqss vcmpord_sss vcmpeq_usss vcmpnge_uqss vcmpngt_uqss vcmpfalse_osss vcmpneq_osss vcmpge_oqss vcmpgt_oqss vcmptrue_usss vcmpss vcomisd vcomiss vcvtdq2pd vcvtdq2ps vcvtpd2dq vcvtpd2ps vcvtps2dq vcvtps2pd vcvtsd2si vcvtsd2ss vcvtsi2sd vcvtsi2ss vcvtss2sd vcvtss2si vcvttpd2dq vcvttps2dq vcvttsd2si vcvttss2si vdivpd vdivps vdivsd vdivss vdppd vdpps vextractf128 vextractps vhaddpd vhaddps vhsubpd vhsubps vinsertf128 vinsertps vlddqu vldqqu vldmxcsr vmaskmovdqu vmaskmovps vmaskmovpd vmaxpd vmaxps vmaxsd vmaxss vminpd vminps vminsd vminss vmovapd vmovaps vmovd vmovq vmovddup vmovdqa vmovqqa vmovdqu vmovqqu vmovhlps vmovhpd vmovhps vmovlhps vmovlpd vmovlps vmovmskpd vmovmskps vmovntdq vmovntqq vmovntdqa vmovntpd vmovntps vmovsd vmovshdup vmovsldup vmovss vmovupd vmovups vmpsadbw vmulpd vmulps vmulsd vmulss vorpd vorps vpabsb vpabsw vpabsd vpacksswb vpackssdw vpackuswb vpackusdw vpaddb vpaddw vpaddd vpaddq vpaddsb vpaddsw vpaddusb vpaddusw vpalignr vpand vpandn vpavgb vpavgw vpblendvb vpblendw vpcmpestri vpcmpestrm vpcmpistri vpcmpistrm vpcmpeqb vpcmpeqw vpcmpeqd vpcmpeqq vpcmpgtb vpcmpgtw vpcmpgtd vpcmpgtq vpermilpd vpermilps vperm2f128 vpextrb vpextrw vpextrd vpextrq vphaddw vphaddd vphaddsw vphminposuw vphsubw vphsubd vphsubsw vpinsrb vpinsrw vpinsrd vpinsrq vpmaddwd vpmaddubsw vpmaxsb vpmaxsw vpmaxsd vpmaxub vpmaxuw vpmaxud vpminsb vpminsw vpminsd vpminub vpminuw vpminud vpmovmskb vpmovsxbw vpmovsxbd vpmovsxbq vpmovsxwd vpmovsxwq vpmovsxdq vpmovzxbw vpmovzxbd vpmovzxbq vpmovzxwd vpmovzxwq vpmovzxdq vpmulhuw vpmulhrsw vpmulhw vpmullw vpmulld vpmuludq vpmuldq vpor vpsadbw vpshufb vpshufd vpshufhw vpshuflw vpsignb vpsignw vpsignd vpslldq vpsrldq vpsllw vpslld vpsllq vpsraw vpsrad vpsrlw vpsrld vpsrlq vptest vpsubb vpsubw vpsubd vpsubq vpsubsb vpsubsw vpsubusb vpsubusw vpunpckhbw vpunpckhwd vpunpckhdq vpunpckhqdq vpunpcklbw vpunpcklwd vpunpckldq vpunpcklqdq vpxor vrcpps vrcpss vrsqrtps vrsqrtss vroundpd vroundps vroundsd vroundss vshufpd vshufps vsqrtpd vsqrtps vsqrtsd vsqrtss vstmxcsr vsubpd vsubps vsubsd vsubss vtestps vtestpd vucomisd vucomiss vunpckhpd vunpckhps vunpcklpd vunpcklps vxorpd vxorps vzeroall vzeroupper pclmullqlqdq pclmulhqlqdq pclmullqhqdq pclmulhqhqdq pclmulqdq vpclmullqlqdq vpclmulhqlqdq vpclmullqhqdq vpclmulhqhqdq vpclmulqdq vfmadd132ps vfmadd132pd vfmadd312ps vfmadd312pd vfmadd213ps vfmadd213pd vfmadd123ps vfmadd123pd vfmadd231ps vfmadd231pd vfmadd321ps vfmadd321pd vfmaddsub132ps vfmaddsub132pd vfmaddsub312ps vfmaddsub312pd vfmaddsub213ps vfmaddsub213pd vfmaddsub123ps vfmaddsub123pd vfmaddsub231ps vfmaddsub231pd vfmaddsub321ps vfmaddsub321pd vfmsub132ps vfmsub132pd vfmsub312ps vfmsub312pd vfmsub213ps vfmsub213pd vfmsub123ps vfmsub123pd vfmsub231ps vfmsub231pd vfmsub321ps vfmsub321pd vfmsubadd132ps vfmsubadd132pd vfmsubadd312ps vfmsubadd312pd vfmsubadd213ps vfmsubadd213pd vfmsubadd123ps vfmsubadd123pd vfmsubadd231ps vfmsubadd231pd vfmsubadd321ps vfmsubadd321pd vfnmadd132ps vfnmadd132pd vfnmadd312ps vfnmadd312pd vfnmadd213ps vfnmadd213pd vfnmadd123ps vfnmadd123pd vfnmadd231ps vfnmadd231pd vfnmadd321ps vfnmadd321pd vfnmsub132ps vfnmsub132pd vfnmsub312ps vfnmsub312pd vfnmsub213ps vfnmsub213pd vfnmsub123ps vfnmsub123pd vfnmsub231ps vfnmsub231pd vfnmsub321ps vfnmsub321pd vfmadd132ss vfmadd132sd vfmadd312ss vfmadd312sd vfmadd213ss vfmadd213sd vfmadd123ss vfmadd123sd vfmadd231ss vfmadd231sd vfmadd321ss vfmadd321sd vfmsub132ss vfmsub132sd vfmsub312ss vfmsub312sd vfmsub213ss vfmsub213sd vfmsub123ss vfmsub123sd vfmsub231ss vfmsub231sd vfmsub321ss vfmsub321sd vfnmadd132ss vfnmadd132sd vfnmadd312ss vfnmadd312sd vfnmadd213ss vfnmadd213sd vfnmadd123ss vfnmadd123sd vfnmadd231ss vfnmadd231sd vfnmadd321ss vfnmadd321sd vfnmsub132ss vfnmsub132sd vfnmsub312ss vfnmsub312sd vfnmsub213ss vfnmsub213sd vfnmsub123ss vfnmsub123sd vfnmsub231ss vfnmsub231sd vfnmsub321ss vfnmsub321sd rdfsbase rdgsbase rdrand wrfsbase wrgsbase vcvtph2ps vcvtps2ph adcx adox rdseed clac stac xstore xcryptecb xcryptcbc xcryptctr xcryptcfb xcryptofb montmul xsha1 xsha256 llwpcb slwpcb lwpval lwpins vfmaddpd vfmaddps vfmaddsd vfmaddss vfmaddsubpd vfmaddsubps vfmsubaddpd vfmsubaddps vfmsubpd vfmsubps vfmsubsd vfmsubss vfnmaddpd vfnmaddps vfnmaddsd vfnmaddss vfnmsubpd vfnmsubps vfnmsubsd vfnmsubss vfrczpd vfrczps vfrczsd vfrczss vpcmov vpcomb vpcomd vpcomq vpcomub vpcomud vpcomuq vpcomuw vpcomw vphaddbd vphaddbq vphaddbw vphadddq vphaddubd vphaddubq vphaddubw vphaddudq vphadduwd vphadduwq vphaddwd vphaddwq vphsubbw vphsubdq vphsubwd vpmacsdd vpmacsdqh vpmacsdql vpmacssdd vpmacssdqh vpmacssdql vpmacsswd vpmacssww vpmacswd vpmacsww vpmadcsswd vpmadcswd vpperm vprotb vprotd vprotq vprotw vpshab vpshad vpshaq vpshaw vpshlb vpshld vpshlq vpshlw vbroadcasti128 vpblendd vpbroadcastb vpbroadcastw vpbroadcastd vpbroadcastq vpermd vpermpd vpermps vpermq vperm2i128 vextracti128 vinserti128 vpmaskmovd vpmaskmovq vpsllvd vpsllvq vpsravd vpsrlvd vpsrlvq vgatherdpd vgatherqpd vgatherdps vgatherqps vpgatherdd vpgatherqd vpgatherdq vpgatherqq xabort xbegin xend xtest andn bextr blci blcic blsi blsic blcfill blsfill blcmsk blsmsk blsr blcs bzhi mulx pdep pext rorx sarx shlx shrx tzcnt tzmsk t1mskc valignd valignq vblendmpd vblendmps vbroadcastf32x4 vbroadcastf64x4 vbroadcasti32x4 vbroadcasti64x4 vcompresspd vcompressps vcvtpd2udq vcvtps2udq vcvtsd2usi vcvtss2usi vcvttpd2udq vcvttps2udq vcvttsd2usi vcvttss2usi vcvtudq2pd vcvtudq2ps vcvtusi2sd vcvtusi2ss vexpandpd vexpandps vextractf32x4 vextractf64x4 vextracti32x4 vextracti64x4 vfixupimmpd vfixupimmps vfixupimmsd vfixupimmss vgetexppd vgetexpps vgetexpsd vgetexpss vgetmantpd vgetmantps vgetmantsd vgetmantss vinsertf32x4 vinsertf64x4 vinserti32x4 vinserti64x4 vmovdqa32 vmovdqa64 vmovdqu32 vmovdqu64 vpabsq vpandd vpandnd vpandnq vpandq vpblendmd vpblendmq vpcmpltd vpcmpled vpcmpneqd vpcmpnltd vpcmpnled vpcmpd vpcmpltq vpcmpleq vpcmpneqq vpcmpnltq vpcmpnleq vpcmpq vpcmpequd vpcmpltud vpcmpleud vpcmpnequd vpcmpnltud vpcmpnleud vpcmpud vpcmpequq vpcmpltuq vpcmpleuq vpcmpnequq vpcmpnltuq vpcmpnleuq vpcmpuq vpcompressd vpcompressq vpermi2d vpermi2pd vpermi2ps vpermi2q vpermt2d vpermt2pd vpermt2ps vpermt2q vpexpandd vpexpandq vpmaxsq vpmaxuq vpminsq vpminuq vpmovdb vpmovdw vpmovqb vpmovqd vpmovqw vpmovsdb vpmovsdw vpmovsqb vpmovsqd vpmovsqw vpmovusdb vpmovusdw vpmovusqb vpmovusqd vpmovusqw vpord vporq vprold vprolq vprolvd vprolvq vprord vprorq vprorvd vprorvq vpscatterdd vpscatterdq vpscatterqd vpscatterqq vpsraq vpsravq vpternlogd vpternlogq vptestmd vptestmq vptestnmd vptestnmq vpxord vpxorq vrcp14pd vrcp14ps vrcp14sd vrcp14ss vrndscalepd vrndscaleps vrndscalesd vrndscaless vrsqrt14pd vrsqrt14ps vrsqrt14sd vrsqrt14ss vscalefpd vscalefps vscalefsd vscalefss vscatterdpd vscatterdps vscatterqpd vscatterqps vshuff32x4 vshuff64x2 vshufi32x4 vshufi64x2 kandnw kandw kmovw knotw kortestw korw kshiftlw kshiftrw kunpckbw kxnorw kxorw vpbroadcastmb2q vpbroadcastmw2d vpconflictd vpconflictq vplzcntd vplzcntq vexp2pd vexp2ps vrcp28pd vrcp28ps vrcp28sd vrcp28ss vrsqrt28pd vrsqrt28ps vrsqrt28sd vrsqrt28ss vgatherpf0dpd vgatherpf0dps vgatherpf0qpd vgatherpf0qps vgatherpf1dpd vgatherpf1dps vgatherpf1qpd vgatherpf1qps vscatterpf0dpd vscatterpf0dps vscatterpf0qpd vscatterpf0qps vscatterpf1dpd vscatterpf1dps vscatterpf1qpd vscatterpf1qps prefetchwt1 bndmk bndcl bndcu bndcn bndmov bndldx bndstx sha1rnds4 sha1nexte sha1msg1 sha1msg2 sha256rnds2 sha256msg1 sha256msg2 hint_nop0 hint_nop1 hint_nop2 hint_nop3 hint_nop4 hint_nop5 hint_nop6 hint_nop7 hint_nop8 hint_nop9 hint_nop10 hint_nop11 hint_nop12 hint_nop13 hint_nop14 hint_nop15 hint_nop16 hint_nop17 hint_nop18 hint_nop19 hint_nop20 hint_nop21 hint_nop22 hint_nop23 hint_nop24 hint_nop25 hint_nop26 hint_nop27 hint_nop28 hint_nop29 hint_nop30 hint_nop31 hint_nop32 hint_nop33 hint_nop34 hint_nop35 hint_nop36 hint_nop37 hint_nop38 hint_nop39 hint_nop40 hint_nop41 hint_nop42 hint_nop43 hint_nop44 hint_nop45 hint_nop46 hint_nop47 hint_nop48 hint_nop49 hint_nop50 hint_nop51 hint_nop52 hint_nop53 hint_nop54 hint_nop55 hint_nop56 hint_nop57 hint_nop58 hint_nop59 hint_nop60 hint_nop61 hint_nop62 hint_nop63",
        built_in: "ip eip rip al ah bl bh cl ch dl dh sil dil bpl spl r8b r9b r10b r11b r12b r13b r14b r15b ax bx cx dx si di bp sp r8w r9w r10w r11w r12w r13w r14w r15w eax ebx ecx edx esi edi ebp esp eip r8d r9d r10d r11d r12d r13d r14d r15d rax rbx rcx rdx rsi rdi rbp rsp r8 r9 r10 r11 r12 r13 r14 r15 cs ds es fs gs ss st st0 st1 st2 st3 st4 st5 st6 st7 mm0 mm1 mm2 mm3 mm4 mm5 mm6 mm7 xmm0  xmm1  xmm2  xmm3  xmm4  xmm5  xmm6  xmm7  xmm8  xmm9 xmm10  xmm11 xmm12 xmm13 xmm14 xmm15 xmm16 xmm17 xmm18 xmm19 xmm20 xmm21 xmm22 xmm23 xmm24 xmm25 xmm26 xmm27 xmm28 xmm29 xmm30 xmm31 ymm0  ymm1  ymm2  ymm3  ymm4  ymm5  ymm6  ymm7  ymm8  ymm9 ymm10  ymm11 ymm12 ymm13 ymm14 ymm15 ymm16 ymm17 ymm18 ymm19 ymm20 ymm21 ymm22 ymm23 ymm24 ymm25 ymm26 ymm27 ymm28 ymm29 ymm30 ymm31 zmm0  zmm1  zmm2  zmm3  zmm4  zmm5  zmm6  zmm7  zmm8  zmm9 zmm10  zmm11 zmm12 zmm13 zmm14 zmm15 zmm16 zmm17 zmm18 zmm19 zmm20 zmm21 zmm22 zmm23 zmm24 zmm25 zmm26 zmm27 zmm28 zmm29 zmm30 zmm31 k0 k1 k2 k3 k4 k5 k6 k7 bnd0 bnd1 bnd2 bnd3 cr0 cr1 cr2 cr3 cr4 cr8 dr0 dr1 dr2 dr3 dr8 tr3 tr4 tr5 tr6 tr7 r0 r1 r2 r3 r4 r5 r6 r7 r0b r1b r2b r3b r4b r5b r6b r7b r0w r1w r2w r3w r4w r5w r6w r7w r0d r1d r2d r3d r4d r5d r6d r7d r0h r1h r2h r3h r0l r1l r2l r3l r4l r5l r6l r7l r8l r9l r10l r11l r12l r13l r14l r15l db dw dd dq dt ddq do dy dz resb resw resd resq rest resdq reso resy resz incbin equ times byte word dword qword nosplit rel abs seg wrt strict near far a32 ptr",
        meta: "%define %xdefine %+ %undef %defstr %deftok %assign %strcat %strlen %substr %rotate %elif %else %endif %if %ifmacro %ifctx %ifidn %ifidni %ifid %ifnum %ifstr %iftoken %ifempty %ifenv %error %warning %fatal %rep %endrep %include %push %pop %repl %pathsearch %depend %use %arg %stacksize %local %line %comment %endcomment .nolist __FILE__ __LINE__ __SECT__  __BITS__ __OUTPUT_FORMAT__ __DATE__ __TIME__ __DATE_NUM__ __TIME_NUM__ __UTC_DATE__ __UTC_TIME__ __UTC_DATE_NUM__ __UTC_TIME_NUM__  __PASS__ struc endstruc istruc at iend align alignb sectalign daz nodaz up down zero default option assume public bits use16 use32 use64 default section segment absolute extern global common cpu float __utf16__ __utf16le__ __utf16be__ __utf32__ __utf32le__ __utf32be__ __float8__ __float16__ __float32__ __float64__ __float80m__ __float80e__ __float128l__ __float128h__ __Infinity__ __QNaN__ __SNaN__ Inf NaN QNaN SNaN float8 float16 float32 float64 float80m float80e float128l float128h __FLOAT_DAZ__ __FLOAT_ROUND__ __FLOAT__"
      },
      contains: [A.COMMENT(";", "$", {
        relevance: 0
      }), {
        className: "number",
        variants: [{
          begin: "\\b(?:([0-9][0-9_]*)?\\.[0-9_]*(?:[eE][+-]?[0-9_]+)?|(0[Xx])?[0-9][0-9_]*(\\.[0-9_]*)?(?:[pP](?:[+-]?[0-9_]+)?)?)\\b",
          relevance: 0
        }, {
          begin: "\\$[0-9][0-9A-Fa-f]*",
          relevance: 0
        }, {
          begin: "\\b(?:[0-9A-Fa-f][0-9A-Fa-f_]*[Hh]|[0-9][0-9_]*[DdTt]?|[0-7][0-7_]*[QqOo]|[0-1][0-1_]*[BbYy])\\b"
        }, {
          begin: "\\b(?:0[Xx][0-9A-Fa-f_]+|0[DdTt][0-9_]+|0[QqOo][0-7_]+|0[BbYy][0-1_]+)\\b"
        }]
      }, A.QUOTE_STRING_MODE, {
        className: "string",
        variants: [{
          begin: "'",
          end: "[^\\\\]'"
        }, {
          begin: "`",
          end: "[^\\\\]`"
        }],
        relevance: 0
      }, {
        className: "symbol",
        variants: [{
          begin: "^\\s*[A-Za-z._?][A-Za-z0-9_$#@~.?]*(:|\\s+label)"
        }, {
          begin: "^\\s*%%[A-Za-z0-9_$#@~.?]*:"
        }],
        relevance: 0
      }, {
        className: "subst",
        begin: "%[0-9]+",
        relevance: 0
      }, {
        className: "subst",
        begin: "%!S+",
        relevance: 0
      }, {
        className: "meta",
        begin: /^\s*\.[\w_-]+/
      }]
    }
  }
  ZfA.exports = ks9
})
// @from(Start 2294933, End 2297064)
WfA = z((PA8, YfA) => {
  function xs9(A) {
    let Q = {
        $pattern: /[a-zA-Z][a-zA-Z0-9_?]*/,
        keyword: "if then else do while until for loop import with is as where when by data constant integer real text name boolean symbol infix prefix postfix block tree",
        literal: "true false nil",
        built_in: "in mod rem and or xor not abs sign floor ceil sqrt sin cos tan asin acos atan exp expm1 log log2 log10 log1p pi at text_length text_range text_find text_replace contains page slide basic_slide title_slide title subtitle fade_in fade_out fade_at clear_color color line_color line_width texture_wrap texture_transform texture scale_?x scale_?y scale_?z? translate_?x translate_?y translate_?z? rotate_?x rotate_?y rotate_?z? rectangle circle ellipse sphere path line_to move_to quad_to curve_to theme background contents locally time mouse_?x mouse_?y mouse_buttons " + "ObjectLoader Animate MovieCredits Slides Filters Shading Materials LensFlare Mapping VLCAudioVideo StereoDecoder PointCloud NetworkAccess RemoteControl RegExp ChromaKey Snowfall NodeJS Speech Charts"
      },
      I = {
        className: "string",
        begin: '"',
        end: '"',
        illegal: "\\n"
      },
      G = {
        className: "string",
        begin: "'",
        end: "'",
        illegal: "\\n"
      },
      Z = {
        className: "string",
        begin: "<<",
        end: ">>"
      },
      D = {
        className: "number",
        begin: "[0-9]+#[0-9A-Z_]+(\\.[0-9-A-Z_]+)?#?([Ee][+-]?[0-9]+)?"
      },
      Y = {
        beginKeywords: "import",
        end: "$",
        keywords: Q,
        contains: [I]
      },
      W = {
        className: "function",
        begin: /[a-z][^\n]*->/,
        returnBegin: !0,
        end: /->/,
        contains: [A.inherit(A.TITLE_MODE, {
          starts: {
            endsWithParent: !0,
            keywords: Q
          }
        })]
      };
    return {
      name: "XL",
      aliases: ["tao"],
      keywords: Q,
      contains: [A.C_LINE_COMMENT_MODE, A.C_BLOCK_COMMENT_MODE, I, G, Z, W, Y, D, A.NUMBER_MODE]
    }
  }
  YfA.exports = xs9
})
// @from(Start 2297070, End 2303346)
FfA = z((SA8, JfA) => {
  function fs9(A) {
    return {
      name: "XQuery",
      aliases: ["xpath", "xq"],
      case_insensitive: !1,
      illegal: /(proc)|(abstract)|(extends)|(until)|(#)/,
      keywords: {
        $pattern: /[a-zA-Z$][a-zA-Z0-9_:-]*/,
        keyword: "module schema namespace boundary-space preserve no-preserve strip default collation base-uri ordering context decimal-format decimal-separator copy-namespaces empty-sequence except exponent-separator external grouping-separator inherit no-inherit lax minus-sign per-mille percent schema-attribute schema-element strict unordered zero-digit declare import option function validate variable for at in let where order group by return if then else tumbling sliding window start when only end previous next stable ascending descending allowing empty greatest least some every satisfies switch case typeswitch try catch and or to union intersect instance of treat as castable cast map array delete insert into replace value rename copy modify update",
        type: "item document-node node attribute document element comment namespace namespace-node processing-instruction text construction xs:anyAtomicType xs:untypedAtomic xs:duration xs:time xs:decimal xs:float xs:double xs:gYearMonth xs:gYear xs:gMonthDay xs:gMonth xs:gDay xs:boolean xs:base64Binary xs:hexBinary xs:anyURI xs:QName xs:NOTATION xs:dateTime xs:dateTimeStamp xs:date xs:string xs:normalizedString xs:token xs:language xs:NMTOKEN xs:Name xs:NCName xs:ID xs:IDREF xs:ENTITY xs:integer xs:nonPositiveInteger xs:negativeInteger xs:long xs:int xs:short xs:byte xs:nonNegativeInteger xs:unisignedLong xs:unsignedInt xs:unsignedShort xs:unsignedByte xs:positiveInteger xs:yearMonthDuration xs:dayTimeDuration",
        literal: "eq ne lt le gt ge is self:: child:: descendant:: descendant-or-self:: attribute:: following:: following-sibling:: parent:: ancestor:: ancestor-or-self:: preceding:: preceding-sibling:: NaN"
      },
      contains: [{
        className: "variable",
        begin: /[$][\w\-:]+/
      }, {
        className: "built_in",
        variants: [{
          begin: /\barray:/,
          end: /(?:append|filter|flatten|fold-(?:left|right)|for-each(?:-pair)?|get|head|insert-before|join|put|remove|reverse|size|sort|subarray|tail)\b/
        }, {
          begin: /\bmap:/,
          end: /(?:contains|entry|find|for-each|get|keys|merge|put|remove|size)\b/
        }, {
          begin: /\bmath:/,
          end: /(?:a(?:cos|sin|tan[2]?)|cos|exp(?:10)?|log(?:10)?|pi|pow|sin|sqrt|tan)\b/
        }, {
          begin: /\bop:/,
          end: /\(/,
          excludeEnd: !0
        }, {
          begin: /\bfn:/,
          end: /\(/,
          excludeEnd: !0
        }, {
          begin: /[^</$:'"-]\b(?:abs|accumulator-(?:after|before)|adjust-(?:date(?:Time)?|time)-to-timezone|analyze-string|apply|available-(?:environment-variables|system-properties)|avg|base-uri|boolean|ceiling|codepoints?-(?:equal|to-string)|collation-key|collection|compare|concat|contains(?:-token)?|copy-of|count|current(?:-)?(?:date(?:Time)?|time|group(?:ing-key)?|output-uri|merge-(?:group|key))?data|dateTime|days?-from-(?:date(?:Time)?|duration)|deep-equal|default-(?:collation|language)|distinct-values|document(?:-uri)?|doc(?:-available)?|element-(?:available|with-id)|empty|encode-for-uri|ends-with|environment-variable|error|escape-html-uri|exactly-one|exists|false|filter|floor|fold-(?:left|right)|for-each(?:-pair)?|format-(?:date(?:Time)?|time|integer|number)|function-(?:arity|available|lookup|name)|generate-id|has-children|head|hours-from-(?:dateTime|duration|time)|id(?:ref)?|implicit-timezone|in-scope-prefixes|index-of|innermost|insert-before|iri-to-uri|json-(?:doc|to-xml)|key|lang|last|load-xquery-module|local-name(?:-from-QName)?|(?:lower|upper)-case|matches|max|minutes-from-(?:dateTime|duration|time)|min|months?-from-(?:date(?:Time)?|duration)|name(?:space-uri-?(?:for-prefix|from-QName)?)?|nilled|node-name|normalize-(?:space|unicode)|not|number|one-or-more|outermost|parse-(?:ietf-date|json)|path|position|(?:prefix-from-)?QName|random-number-generator|regex-group|remove|replace|resolve-(?:QName|uri)|reverse|root|round(?:-half-to-even)?|seconds-from-(?:dateTime|duration|time)|snapshot|sort|starts-with|static-base-uri|stream-available|string-?(?:join|length|to-codepoints)?|subsequence|substring-?(?:after|before)?|sum|system-property|tail|timezone-from-(?:date(?:Time)?|time)|tokenize|trace|trans(?:form|late)|true|type-available|unordered|unparsed-(?:entity|text)?-?(?:public-id|uri|available|lines)?|uri-collection|xml-to-json|years?-from-(?:date(?:Time)?|duration)|zero-or-one)\b/
        }, {
          begin: /\blocal:/,
          end: /\(/,
          excludeEnd: !0
        }, {
          begin: /\bzip:/,
          end: /(?:zip-file|(?:xml|html|text|binary)-entry| (?:update-)?entries)\b/
        }, {
          begin: /\b(?:util|db|functx|app|xdmp|xmldb):/,
          end: /\(/,
          excludeEnd: !0
        }]
      }, {
        className: "string",
        variants: [{
          begin: /"/,
          end: /"/,
          contains: [{
            begin: /""/,
            relevance: 0
          }]
        }, {
          begin: /'/,
          end: /'/,
          contains: [{
            begin: /''/,
            relevance: 0
          }]
        }]
      }, {
        className: "number",
        begin: /(\b0[0-7_]+)|(\b0x[0-9a-fA-F_]+)|(\b[1-9][0-9_]*(\.[0-9_]+)?)|[0_]\b/,
        relevance: 0
      }, {
        className: "comment",
        begin: /\(:/,
        end: /:\)/,
        relevance: 10,
        contains: [{
          className: "doctag",
          begin: /@\w+/
        }]
      }, {
        className: "meta",
        begin: /%[\w\-:]+/
      }, {
        className: "title",
        begin: /\bxquery version "[13]\.[01]"\s?(?:encoding ".+")?/,
        end: /;/
      }, {
        beginKeywords: "element attribute comment document processing-instruction",
        end: /\{/,
        excludeEnd: !0
      }, {
        begin: /<([\w._:-]+)(\s+\S*=('|").*('|"))?>/,
        end: /(\/[\w._:-]+>)/,
        subLanguage: "xml",
        contains: [{
          begin: /\{/,
          end: /\}/,
          subLanguage: "xquery"
        }, "self"]
      }]
    }
  }
  JfA.exports = fs9
})
// @from(Start 2303352, End 2305573)
VfA = z((_A8, XfA) => {
  function vs9(A) {
    let B = {
        className: "string",
        contains: [A.BACKSLASH_ESCAPE],
        variants: [A.inherit(A.APOS_STRING_MODE, {
          illegal: null
        }), A.inherit(A.QUOTE_STRING_MODE, {
          illegal: null
        })]
      },
      Q = A.UNDERSCORE_TITLE_MODE,
      I = {
        variants: [A.BINARY_NUMBER_MODE, A.C_NUMBER_MODE]
      },
      G = "namespace class interface use extends function return abstract final public protected private static deprecated throw try catch Exception echo empty isset instanceof unset let var new const self require if else elseif switch case default do while loop for continue break likely unlikely __LINE__ __FILE__ __DIR__ __FUNCTION__ __CLASS__ __TRAIT__ __METHOD__ __NAMESPACE__ array boolean float double integer object resource string char long unsigned bool int uint ulong uchar true false null undefined";
    return {
      name: "Zephir",
      aliases: ["zep"],
      keywords: G,
      contains: [A.C_LINE_COMMENT_MODE, A.COMMENT(/\/\*/, /\*\//, {
        contains: [{
          className: "doctag",
          begin: /@[A-Za-z]+/
        }]
      }), {
        className: "string",
        begin: /<<<['"]?\w+['"]?$/,
        end: /^\w+;/,
        contains: [A.BACKSLASH_ESCAPE]
      }, {
        begin: /(::|->)+[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/
      }, {
        className: "function",
        beginKeywords: "function fn",
        end: /[;{]/,
        excludeEnd: !0,
        illegal: /\$|\[|%/,
        contains: [Q, {
          className: "params",
          begin: /\(/,
          end: /\)/,
          keywords: G,
          contains: ["self", A.C_BLOCK_COMMENT_MODE, B, I]
        }]
      }, {
        className: "class",
        beginKeywords: "class interface",
        end: /\{/,
        excludeEnd: !0,
        illegal: /[:($"]/,
        contains: [{
          beginKeywords: "extends implements"
        }, Q]
      }, {
        beginKeywords: "namespace",
        end: /;/,
        illegal: /[.']/,
        contains: [Q]
      }, {
        beginKeywords: "use",
        end: /;/,
        contains: [Q]
      }, {
        begin: /=>/
      }, B, I]
    }
  }
  XfA.exports = vs9
})
// @from(Start 2305579, End 2313240)
oT1 = z((jA8, CfA) => {
  var FA = TTA();
  FA.registerLanguage("1c", STA());
  FA.registerLanguage("abnf", jTA());
  FA.registerLanguage("accesslog", xTA());
  FA.registerLanguage("actionscript", vTA());
  FA.registerLanguage("ada", gTA());
  FA.registerLanguage("angelscript", mTA());
  FA.registerLanguage("apache", uTA());
  FA.registerLanguage("applescript", nTA());
  FA.registerLanguage("arcade", sTA());
  FA.registerLanguage("arduino", oTA());
  FA.registerLanguage("armasm", eTA());
  FA.registerLanguage("xml", IPA());
  FA.registerLanguage("asciidoc", DPA());
  FA.registerLanguage("aspectj", WPA());
  FA.registerLanguage("autohotkey", FPA());
  FA.registerLanguage("autoit", VPA());
  FA.registerLanguage("avrasm", KPA());
  FA.registerLanguage("awk", zPA());
  FA.registerLanguage("axapta", EPA());
  FA.registerLanguage("bash", NPA());
  FA.registerLanguage("basic", qPA());
  FA.registerLanguage("bnf", LPA());
  FA.registerLanguage("brainfuck", OPA());
  FA.registerLanguage("c-like", PPA());
  FA.registerLanguage("c", _PA());
  FA.registerLanguage("cal", yPA());
  FA.registerLanguage("capnproto", xPA());
  FA.registerLanguage("ceylon", vPA());
  FA.registerLanguage("clean", gPA());
  FA.registerLanguage("clojure", mPA());
  FA.registerLanguage("clojure-repl", uPA());
  FA.registerLanguage("cmake", cPA());
  FA.registerLanguage("coffeescript", iPA());
  FA.registerLanguage("coq", aPA());
  FA.registerLanguage("cos", rPA());
  FA.registerLanguage("cpp", tPA());
  FA.registerLanguage("crmsh", ASA());
  FA.registerLanguage("crystal", QSA());
  FA.registerLanguage("csharp", GSA());
  FA.registerLanguage("csp", DSA());
  FA.registerLanguage("css", WSA());
  FA.registerLanguage("d", FSA());
  FA.registerLanguage("markdown", VSA());
  FA.registerLanguage("dart", KSA());
  FA.registerLanguage("delphi", zSA());
  FA.registerLanguage("diff", ESA());
  FA.registerLanguage("django", NSA());
  FA.registerLanguage("dns", qSA());
  FA.registerLanguage("dockerfile", LSA());
  FA.registerLanguage("dos", OSA());
  FA.registerLanguage("dsconfig", PSA());
  FA.registerLanguage("dts", _SA());
  FA.registerLanguage("dust", ySA());
  FA.registerLanguage("ebnf", xSA());
  FA.registerLanguage("elixir", vSA());
  FA.registerLanguage("elm", gSA());
  FA.registerLanguage("ruby", dSA());
  FA.registerLanguage("erb", pSA());
  FA.registerLanguage("erlang-repl", lSA());
  FA.registerLanguage("erlang", nSA());
  FA.registerLanguage("excel", sSA());
  FA.registerLanguage("fix", oSA());
  FA.registerLanguage("flix", eSA());
  FA.registerLanguage("fortran", B_A());
  FA.registerLanguage("fsharp", I_A());
  FA.registerLanguage("gams", Z_A());
  FA.registerLanguage("gauss", Y_A());
  FA.registerLanguage("gcode", J_A());
  FA.registerLanguage("gherkin", X_A());
  FA.registerLanguage("glsl", C_A());
  FA.registerLanguage("gml", H_A());
  FA.registerLanguage("go", w_A());
  FA.registerLanguage("golo", U_A());
  FA.registerLanguage("gradle", $_A());
  FA.registerLanguage("groovy", M_A());
  FA.registerLanguage("haml", R_A());
  FA.registerLanguage("handlebars", P_A());
  FA.registerLanguage("haskell", __A());
  FA.registerLanguage("haxe", y_A());
  FA.registerLanguage("hsp", x_A());
  FA.registerLanguage("htmlbars", b_A());
  FA.registerLanguage("http", h_A());
  FA.registerLanguage("hy", d_A());
  FA.registerLanguage("inform7", p_A());
  FA.registerLanguage("ini", n_A());
  FA.registerLanguage("irpf90", s_A());
  FA.registerLanguage("isbl", o_A());
  FA.registerLanguage("java", e_A());
  FA.registerLanguage("javascript", QjA());
  FA.registerLanguage("jboss-cli", GjA());
  FA.registerLanguage("json", DjA());
  FA.registerLanguage("julia", WjA());
  FA.registerLanguage("julia-repl", FjA());
  FA.registerLanguage("kotlin", VjA());
  FA.registerLanguage("lasso", KjA());
  FA.registerLanguage("latex", zjA());
  FA.registerLanguage("ldif", EjA());
  FA.registerLanguage("leaf", NjA());
  FA.registerLanguage("less", LjA());
  FA.registerLanguage("lisp", OjA());
  FA.registerLanguage("livecodeserver", PjA());
  FA.registerLanguage("livescript", _jA());
  FA.registerLanguage("llvm", yjA());
  FA.registerLanguage("lsl", xjA());
  FA.registerLanguage("lua", vjA());
  FA.registerLanguage("makefile", gjA());
  FA.registerLanguage("mathematica", pjA());
  FA.registerLanguage("matlab", ljA());
  FA.registerLanguage("maxima", njA());
  FA.registerLanguage("mel", sjA());
  FA.registerLanguage("mercury", ojA());
  FA.registerLanguage("mipsasm", ejA());
  FA.registerLanguage("mizar", ByA());
  FA.registerLanguage("perl", ZyA());
  FA.registerLanguage("mojolicious", YyA());
  FA.registerLanguage("monkey", JyA());
  FA.registerLanguage("moonscript", XyA());
  FA.registerLanguage("n1ql", CyA());
  FA.registerLanguage("nginx", HyA());
  FA.registerLanguage("nim", wyA());
  FA.registerLanguage("nix", UyA());
  FA.registerLanguage("node-repl", $yA());
  FA.registerLanguage("nsis", MyA());
  FA.registerLanguage("objectivec", RyA());
  FA.registerLanguage("ocaml", TyA());
  FA.registerLanguage("openscad", SyA());
  FA.registerLanguage("oxygene", jyA());
  FA.registerLanguage("parser3", kyA());
  FA.registerLanguage("pf", fyA());
  FA.registerLanguage("pgsql", byA());
  FA.registerLanguage("php", hyA());
  FA.registerLanguage("php-template", dyA());
  FA.registerLanguage("plaintext", pyA());
  FA.registerLanguage("pony", lyA());
  FA.registerLanguage("powershell", nyA());
  FA.registerLanguage("processing", syA());
  FA.registerLanguage("profile", oyA());
  FA.registerLanguage("prolog", eyA());
  FA.registerLanguage("properties", BkA());
  FA.registerLanguage("protobuf", IkA());
  FA.registerLanguage("puppet", ZkA());
  FA.registerLanguage("purebasic", YkA());
  FA.registerLanguage("python", JkA());
  FA.registerLanguage("python-repl", XkA());
  FA.registerLanguage("q", CkA());
  FA.registerLanguage("qml", HkA());
  FA.registerLanguage("r", wkA());
  FA.registerLanguage("reasonml", UkA());
  FA.registerLanguage("rib", $kA());
  FA.registerLanguage("roboconf", MkA());
  FA.registerLanguage("routeros", RkA());
  FA.registerLanguage("rsl", TkA());
  FA.registerLanguage("ruleslanguage", SkA());
  FA.registerLanguage("rust", jkA());
  FA.registerLanguage("sas", kkA());
  FA.registerLanguage("scala", fkA());
  FA.registerLanguage("scheme", bkA());
  FA.registerLanguage("scilab", hkA());
  FA.registerLanguage("scss", dkA());
  FA.registerLanguage("shell", pkA());
  FA.registerLanguage("smali", lkA());
  FA.registerLanguage("smalltalk", nkA());
  FA.registerLanguage("sml", skA());
  FA.registerLanguage("sqf", okA());
  FA.registerLanguage("sql_more", ekA());
  FA.registerLanguage("sql", QxA());
  FA.registerLanguage("stan", GxA());
  FA.registerLanguage("stata", DxA());
  FA.registerLanguage("step21", WxA());
  FA.registerLanguage("stylus", FxA());
  FA.registerLanguage("subunit", VxA());
  FA.registerLanguage("swift", $xA());
  FA.registerLanguage("taggerscript", MxA());
  FA.registerLanguage("yaml", RxA());
  FA.registerLanguage("tap", TxA());
  FA.registerLanguage("tcl", _xA());
  FA.registerLanguage("thrift", yxA());
  FA.registerLanguage("tp", xxA());
  FA.registerLanguage("twig", vxA());
  FA.registerLanguage("typescript", uxA());
  FA.registerLanguage("vala", cxA());
  FA.registerLanguage("vbnet", nxA());
  FA.registerLanguage("vbscript", rxA());
  FA.registerLanguage("vbscript-html", txA());
  FA.registerLanguage("verilog", AfA());
  FA.registerLanguage("vhdl", QfA());
  FA.registerLanguage("vim", GfA());
  FA.registerLanguage("x86asm", DfA());
  FA.registerLanguage("xl", WfA());
  FA.registerLanguage("xquery", FfA());
  FA.registerLanguage("zephir", VfA());
  CfA.exports = FA
})
// @from(Start 2313246, End 2319412)
rvA = z((Ht9) => {
  function xP1(A, B) {
    var Q = A.length;
    A.push(B);
    A: for (; 0 < Q;) {
      var I = Q - 1 >>> 1,
        G = A[I];
      if (0 < e81(G, B)) A[I] = B, A[Q] = G, Q = I;
      else break A
    }
  }

  function zC(A) {
    return A.length === 0 ? null : A[0]
  }

  function IB1(A) {
    if (A.length === 0) return null;
    var B = A[0],
      Q = A.pop();
    if (Q !== B) {
      A[0] = Q;
      A: for (var I = 0, G = A.length, Z = G >>> 1; I < Z;) {
        var D = 2 * (I + 1) - 1,
          Y = A[D],
          W = D + 1,
          J = A[W];
        if (0 > e81(Y, Q)) W < G && 0 > e81(J, Y) ? (A[I] = J, A[W] = Q, I = W) : (A[I] = Y, A[D] = Q, I = D);
        else if (W < G && 0 > e81(J, Q)) A[I] = J, A[W] = Q, I = W;
        else break A
      }
    }
    return B
  }

  function e81(A, B) {
    var Q = A.sortIndex - B.sortIndex;
    return Q !== 0 ? Q : A.id - B.id
  }
  if (typeof performance === "object" && typeof performance.now === "function") fP1 = performance, Ht9.unstable_now = function() {
    return fP1.now()
  };
  else AB1 = Date, vP1 = AB1.now(), Ht9.unstable_now = function() {
    return AB1.now() - vP1
  };
  var fP1, AB1, vP1, Lz = [],
    QL = [],
    Kt9 = 1,
    BX = null,
    EZ = 3,
    GB1 = !1,
    RS = !1,
    Dn = !1,
    lvA = typeof setTimeout === "function" ? setTimeout : null,
    ivA = typeof clearTimeout === "function" ? clearTimeout : null,
    cvA = typeof setImmediate !== "undefined" ? setImmediate : null;
  typeof navigator !== "undefined" && navigator.scheduling !== void 0 && navigator.scheduling.isInputPending !== void 0 && navigator.scheduling.isInputPending.bind(navigator.scheduling);

  function bP1(A) {
    for (var B = zC(QL); B !== null;) {
      if (B.callback === null) IB1(QL);
      else if (B.startTime <= A) IB1(QL), B.sortIndex = B.expirationTime, xP1(Lz, B);
      else break;
      B = zC(QL)
    }
  }

  function hP1(A) {
    if (Dn = !1, bP1(A), !RS)
      if (zC(Lz) !== null) RS = !0, dP1(mP1);
      else {
        var B = zC(QL);
        B !== null && uP1(hP1, B.startTime - A)
      }
  }

  function mP1(A, B) {
    RS = !1, Dn && (Dn = !1, ivA(Yn), Yn = -1), GB1 = !0;
    var Q = EZ;
    try {
      bP1(B);
      for (BX = zC(Lz); BX !== null && (!(BX.expirationTime > B) || A && !svA());) {
        var I = BX.callback;
        if (typeof I === "function") {
          BX.callback = null, EZ = BX.priorityLevel;
          var G = I(BX.expirationTime <= B);
          B = Ht9.unstable_now(), typeof G === "function" ? BX.callback = G : BX === zC(Lz) && IB1(Lz), bP1(B)
        } else IB1(Lz);
        BX = zC(Lz)
      }
      if (BX !== null) var Z = !0;
      else {
        var D = zC(QL);
        D !== null && uP1(hP1, D.startTime - B), Z = !1
      }
      return Z
    } finally {
      BX = null, EZ = Q, GB1 = !1
    }
  }
  var ZB1 = !1,
    BB1 = null,
    Yn = -1,
    nvA = 5,
    avA = -1;

  function svA() {
    return Ht9.unstable_now() - avA < nvA ? !1 : !0
  }

  function kP1() {
    if (BB1 !== null) {
      var A = Ht9.unstable_now();
      avA = A;
      var B = !0;
      try {
        B = BB1(!0, A)
      } finally {
        B ? Zn() : (ZB1 = !1, BB1 = null)
      }
    } else ZB1 = !1
  }
  var Zn;
  if (typeof cvA === "function") Zn = function() {
    cvA(kP1)
  };
  else if (typeof MessageChannel !== "undefined") QB1 = new MessageChannel, gP1 = QB1.port2, QB1.port1.onmessage = kP1, Zn = function() {
    gP1.postMessage(null)
  };
  else Zn = function() {
    lvA(kP1, 0)
  };
  var QB1, gP1;

  function dP1(A) {
    BB1 = A, ZB1 || (ZB1 = !0, Zn())
  }

  function uP1(A, B) {
    Yn = lvA(function() {
      A(Ht9.unstable_now())
    }, B)
  }
  Ht9.unstable_IdlePriority = 5;
  Ht9.unstable_ImmediatePriority = 1;
  Ht9.unstable_LowPriority = 4;
  Ht9.unstable_NormalPriority = 3;
  Ht9.unstable_Profiling = null;
  Ht9.unstable_UserBlockingPriority = 2;
  Ht9.unstable_cancelCallback = function(A) {
    A.callback = null
  };
  Ht9.unstable_continueExecution = function() {
    RS || GB1 || (RS = !0, dP1(mP1))
  };
  Ht9.unstable_forceFrameRate = function(A) {
    0 > A || 125 < A ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : nvA = 0 < A ? Math.floor(1000 / A) : 5
  };
  Ht9.unstable_getCurrentPriorityLevel = function() {
    return EZ
  };
  Ht9.unstable_getFirstCallbackNode = function() {
    return zC(Lz)
  };
  Ht9.unstable_next = function(A) {
    switch (EZ) {
      case 1:
      case 2:
      case 3:
        var B = 3;
        break;
      default:
        B = EZ
    }
    var Q = EZ;
    EZ = B;
    try {
      return A()
    } finally {
      EZ = Q
    }
  };
  Ht9.unstable_pauseExecution = function() {};
  Ht9.unstable_requestPaint = function() {};
  Ht9.unstable_runWithPriority = function(A, B) {
    switch (A) {
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
        break;
      default:
        A = 3
    }
    var Q = EZ;
    EZ = A;
    try {
      return B()
    } finally {
      EZ = Q
    }
  };
  Ht9.unstable_scheduleCallback = function(A, B, Q) {
    var I = Ht9.unstable_now();
    switch (typeof Q === "object" && Q !== null ? (Q = Q.delay, Q = typeof Q === "number" && 0 < Q ? I + Q : I) : Q = I, A) {
      case 1:
        var G = -1;
        break;
      case 2:
        G = 250;
        break;
      case 5:
        G = 1073741823;
        break;
      case 4:
        G = 1e4;
        break;
      default:
        G = 5000
    }
    return G = Q + G, A = {
      id: Kt9++,
      callback: B,
      priorityLevel: A,
      startTime: Q,
      expirationTime: G,
      sortIndex: -1
    }, Q > I ? (A.sortIndex = Q, xP1(QL, A), zC(Lz) === null && A === zC(QL) && (Dn ? (ivA(Yn), Yn = -1) : Dn = !0, uP1(hP1, Q - I))) : (A.sortIndex = G, xP1(Lz, A), RS || GB1 || (RS = !0, dP1(mP1))), A
  };
  Ht9.unstable_shouldYield = svA;
  Ht9.unstable_wrapCallback = function(A) {
    var B = EZ;
    return function() {
      var Q = EZ;
      EZ = B;
      try {
        return A.apply(this, arguments)
      } finally {
        EZ = Q
      }
    }
  }
})
// @from(Start 2319418, End 2474924)
tvA = z((l28, ovA) => {
  var pP1 = I1(U1(), 1),
    b7 = I1(rvA(), 1);
  ovA.exports = function A(B) {
    var Q = {},
      I = Object.assign;

    function G(w) {
      for (var U = "https://reactjs.org/docs/error-decoder.html?invariant=" + w, S = 1; S < arguments.length; S++) U += "&args[]=" + encodeURIComponent(arguments[S]);
      return "Minified React error #" + w + "; visit " + U + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."
    }
    var Z = pP1.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
      D = Symbol.for("react.element"),
      Y = Symbol.for("react.portal"),
      W = Symbol.for("react.fragment"),
      J = Symbol.for("react.strict_mode"),
      F = Symbol.for("react.profiler"),
      X = Symbol.for("react.provider"),
      V = Symbol.for("react.context"),
      C = Symbol.for("react.forward_ref"),
      K = Symbol.for("react.suspense"),
      E = Symbol.for("react.suspense_list"),
      N = Symbol.for("react.memo"),
      q = Symbol.for("react.lazy");
    Symbol.for("react.scope"), Symbol.for("react.debug_trace_mode");
    var O = Symbol.for("react.offscreen");
    Symbol.for("react.legacy_hidden"), Symbol.for("react.cache"), Symbol.for("react.tracing_marker");
    var R = Symbol.iterator;

    function T(w) {
      if (w === null || typeof w !== "object") return null;
      return w = R && w[R] || w["@@iterator"], typeof w === "function" ? w : null
    }

    function L(w) {
      if (w == null) return null;
      if (typeof w === "function") return w.displayName || w.name || null;
      if (typeof w === "string") return w;
      switch (w) {
        case W:
          return "Fragment";
        case Y:
          return "Portal";
        case F:
          return "Profiler";
        case J:
          return "StrictMode";
        case K:
          return "Suspense";
        case E:
          return "SuspenseList"
      }
      if (typeof w === "object") switch (w.$$typeof) {
        case V:
          return (w.displayName || "Context") + ".Consumer";
        case X:
          return (w._context.displayName || "Context") + ".Provider";
        case C:
          var U = w.render;
          return w = w.displayName, w || (w = U.displayName || U.name || "", w = w !== "" ? "ForwardRef(" + w + ")" : "ForwardRef"), w;
        case N:
          return U = w.displayName || null, U !== null ? U : L(w.type) || "Memo";
        case q:
          U = w._payload, w = w._init;
          try {
            return L(w(U))
          } catch (S) {}
      }
      return null
    }

    function _(w) {
      var U = w.type;
      switch (w.tag) {
        case 24:
          return "Cache";
        case 9:
          return (U.displayName || "Context") + ".Consumer";
        case 10:
          return (U._context.displayName || "Context") + ".Provider";
        case 18:
          return "DehydratedFragment";
        case 11:
          return w = U.render, w = w.displayName || w.name || "", U.displayName || (w !== "" ? "ForwardRef(" + w + ")" : "ForwardRef");
        case 7:
          return "Fragment";
        case 5:
          return U;
        case 4:
          return "Portal";
        case 3:
          return "Root";
        case 6:
          return "Text";
        case 16:
          return L(U);
        case 8:
          return U === J ? "StrictMode" : "Mode";
        case 22:
          return "Offscreen";
        case 12:
          return "Profiler";
        case 21:
          return "Scope";
        case 13:
          return "Suspense";
        case 19:
          return "SuspenseList";
        case 25:
          return "TracingMarker";
        case 1:
        case 0:
        case 17:
        case 2:
        case 14:
        case 15:
          if (typeof U === "function") return U.displayName || U.name || null;
          if (typeof U === "string") return U
      }
      return null
    }

    function k(w) {
      var U = w,
        S = w;
      if (w.alternate)
        for (; U.return;) U = U.return;
      else {
        w = U;
        do U = w, (U.flags & 4098) !== 0 && (S = U.return), w = U.return; while (w)
      }
      return U.tag === 3 ? S : null
    }

    function i(w) {
      if (k(w) !== w) throw Error(G(188))
    }

    function x(w) {
      var U = w.alternate;
      if (!U) {
        if (U = k(w), U === null) throw Error(G(188));
        return U !== w ? null : w
      }
      for (var S = w, g = U;;) {
        var m = S.return;
        if (m === null) break;
        var r = m.alternate;
        if (r === null) {
          if (g = m.return, g !== null) {
            S = g;
            continue
          }
          break
        }
        if (m.child === r.child) {
          for (r = m.child; r;) {
            if (r === S) return i(m), w;
            if (r === g) return i(m), U;
            r = r.sibling
          }
          throw Error(G(188))
        }
        if (S.return !== g.return) S = m, g = r;
        else {
          for (var j1 = !1, CA = m.child; CA;) {
            if (CA === S) {
              j1 = !0, S = m, g = r;
              break
            }
            if (CA === g) {
              j1 = !0, g = m, S = r;
              break
            }
            CA = CA.sibling
          }
          if (!j1) {
            for (CA = r.child; CA;) {
              if (CA === S) {
                j1 = !0, S = r, g = m;
                break
              }
              if (CA === g) {
                j1 = !0, g = r, S = m;
                break
              }
              CA = CA.sibling
            }
            if (!j1) throw Error(G(189))
          }
        }
        if (S.alternate !== g) throw Error(G(190))
      }
      if (S.tag !== 3) throw Error(G(188));
      return S.stateNode.current === S ? w : U
    }

    function s(w) {
      return w = x(w), w !== null ? d(w) : null
    }

    function d(w) {
      if (w.tag === 5 || w.tag === 6) return w;
      for (w = w.child; w !== null;) {
        var U = d(w);
        if (U !== null) return U;
        w = w.sibling
      }
      return null
    }

    function F1(w) {
      if (w.tag === 5 || w.tag === 6) return w;
      for (w = w.child; w !== null;) {
        if (w.tag !== 4) {
          var U = F1(w);
          if (U !== null) return U
        }
        w = w.sibling
      }
      return null
    }
    var X1 = Array.isArray,
      v = B.getPublicInstance,
      D1 = B.getRootHostContext,
      N1 = B.getChildHostContext,
      u1 = B.prepareForCommit,
      d1 = B.resetAfterCommit,
      YA = B.createInstance,
      bA = B.appendInitialChild,
      e1 = B.finalizeInitialChildren,
      k1 = B.prepareUpdate,
      Q1 = B.shouldSetTextContent,
      v1 = B.createTextInstance,
      L1 = B.scheduleTimeout,
      BA = B.cancelTimeout,
      HA = B.noTimeout,
      MA = B.isPrimaryRenderer,
      t = B.supportsMutation,
      B1 = B.supportsPersistence,
      W1 = B.supportsHydration,
      w1 = B.getInstanceFromNode,
      P1 = B.preparePortalMount,
      e = B.getCurrentEventPriority,
      y1 = B.detachDeletedInstance,
      O1 = B.supportsMicrotasks,
      h1 = B.scheduleMicrotask,
      o1 = B.supportsTestSelectors,
      QA = B.findFiberRoot,
      zA = B.getBoundingRect,
      Y0 = B.getTextContent,
      fA = B.isHiddenSubtree,
      H0 = B.matchAccessibilityRole,
      k2 = B.setFocusIfFocusable,
      s0 = B.setupIntersectionObserver,
      q2 = B.appendChild,
      h2 = B.appendChildToContainer,
      j9 = B.commitTextUpdate,
      w6 = B.commitMount,
      E0 = B.commitUpdate,
      g0 = B.insertBefore,
      y0 = B.insertInContainerBefore,
      T0 = B.removeChild,
      V0 = B.removeChildFromContainer,
      N2 = B.resetTextContent,
      h9 = B.hideInstance,
      z5 = B.hideTextInstance,
      W3 = B.unhideInstance,
      Z6 = B.unhideTextInstance,
      r2 = B.clearContainer,
      v6 = B.cloneInstance,
      J3 = B.createContainerChildSet,
      uQ = B.appendChildToContainerChildSet,
      x0 = B.finalizeContainerChildren,
      d0 = B.replaceContainerChildren,
      L9 = B.cloneHiddenInstance,
      w5 = B.cloneHiddenTextInstance,
      _B = B.canHydrateInstance,
      D6 = B.canHydrateTextInstance,
      F3 = B.canHydrateSuspenseInstance,
      X3 = B.isSuspenseInstancePending,
      q7 = B.isSuspenseInstanceFallback,
      V3 = B.getSuspenseInstanceFallbackErrorDetails,
      H2 = B.registerSuspenseInstanceRetry,
      w9 = B.getNextHydratableSibling,
      j5 = B.getFirstHydratableChild,
      j8 = B.getFirstHydratableChildWithinContainer,
      y3 = B.getFirstHydratableChildWithinSuspenseInstance,
      WQ = B.hydrateInstance,
      nI = B.hydrateTextInstance,
      AD = B.hydrateSuspenseInstance,
      aI = B.getNextHydratableInstanceAfterSuspenseInstance,
      pQ = B.commitHydratedContainer,
      BD = B.commitHydratedSuspenseInstance,
      cQ = B.clearSuspenseBoundary,
      rG = B.clearSuspenseBoundaryFromContainer,
      zB = B.shouldDeleteUnhydratedTailInstances,
      e7 = B.didNotMatchHydratedContainerTextInstance,
      S1 = B.didNotMatchHydratedTextInstance,
      T1;

    function VA(w) {
      if (T1 === void 0) try {
        throw Error()
      } catch (S) {
        var U = S.stack.trim().match(/\n( *(at )?)/);
        T1 = U && U[1] || ""
      }
      return `
` + T1 + w
    }
    var OA = !1;

    function KA(w, U) {
      if (!w || OA) return "";
      OA = !0;
      var S = Error.prepareStackTrace;
      Error.prepareStackTrace = void 0;
      try {
        if (U)
          if (U = function() {
              throw Error()
            }, Object.defineProperty(U.prototype, "props", {
              set: function() {
                throw Error()
              }
            }), typeof Reflect === "object" && Reflect.construct) {
            try {
              Reflect.construct(U, [])
            } catch (F0) {
              var g = F0
            }
            Reflect.construct(w, [], U)
          } else {
            try {
              U.call()
            } catch (F0) {
              g = F0
            }
            w.call(U.prototype)
          }
        else {
          try {
            throw Error()
          } catch (F0) {
            g = F0
          }
          w()
        }
      } catch (F0) {
        if (F0 && g && typeof F0.stack === "string") {
          for (var m = F0.stack.split(`
`), r = g.stack.split(`
`), j1 = m.length - 1, CA = r.length - 1; 1 <= j1 && 0 <= CA && m[j1] !== r[CA];) CA--;
          for (; 1 <= j1 && 0 <= CA; j1--, CA--)
            if (m[j1] !== r[CA]) {
              if (j1 !== 1 || CA !== 1)
                do
                  if (j1--, CA--, 0 > CA || m[j1] !== r[CA]) {
                    var kA = `
` + m[j1].replace(" at new ", " at ");
                    return w.displayName && kA.includes("<anonymous>") && (kA = kA.replace("<anonymous>", w.displayName)), kA
                  } while (1 <= j1 && 0 <= CA);
              break
            }
        }
      } finally {
        OA = !1, Error.prepareStackTrace = S
      }
      return (w = w ? w.displayName || w.name : "") ? VA(w) : ""
    }
    var PA = Object.prototype.hasOwnProperty,
      D0 = [],
      lA = -1;

    function NA(w) {
      return {
        current: w
      }
    }

    function SA(w) {
      0 > lA || (w.current = D0[lA], D0[lA] = null, lA--)
    }

    function uA(w, U) {
      lA++, D0[lA] = w.current, w.current = U
    }
    var W2 = {},
      c0 = NA(W2),
      z2 = NA(!1),
      V1 = W2;

    function c1(w, U) {
      var S = w.type.contextTypes;
      if (!S) return W2;
      var g = w.stateNode;
      if (g && g.__reactInternalMemoizedUnmaskedChildContext === U) return g.__reactInternalMemoizedMaskedChildContext;
      var m = {},
        r;
      for (r in S) m[r] = U[r];
      return g && (w = w.stateNode, w.__reactInternalMemoizedUnmaskedChildContext = U, w.__reactInternalMemoizedMaskedChildContext = m), m
    }

    function _1(w) {
      return w = w.childContextTypes, w !== null && w !== void 0
    }

    function t1() {
      SA(z2), SA(c0)
    }

    function DA(w, U, S) {
      if (c0.current !== W2) throw Error(G(168));
      uA(c0, U), uA(z2, S)
    }

    function IA(w, U, S) {
      var g = w.stateNode;
      if (U = U.childContextTypes, typeof g.getChildContext !== "function") return S;
      g = g.getChildContext();
      for (var m in g)
        if (!(m in U)) throw Error(G(108, _(w) || "Unknown", m));
      return I({}, S, g)
    }

    function xA(w) {
      return w = (w = w.stateNode) && w.__reactInternalMemoizedMergedChildContext || W2, V1 = c0.current, uA(c0, w), uA(z2, z2.current), !0
    }

    function oA(w, U, S) {
      var g = w.stateNode;
      if (!g) throw Error(G(169));
      S ? (w = IA(w, U, V1), g.__reactInternalMemoizedMergedChildContext = w, SA(z2), SA(c0), uA(c0, w)) : SA(z2), uA(z2, S)
    }
    var sA = Math.clz32 ? Math.clz32 : i0,
      C0 = Math.log,
      U0 = Math.LN2;

    function i0(w) {
      return w >>>= 0, w === 0 ? 32 : 31 - (C0(w) / U0 | 0) | 0
    }
    var R9 = 64,
      Z4 = 4194304;

    function x4(w) {
      switch (w & -w) {
        case 1:
          return 1;
        case 2:
          return 2;
        case 4:
          return 4;
        case 8:
          return 8;
        case 16:
          return 16;
        case 32:
          return 32;
        case 64:
        case 128:
        case 256:
        case 512:
        case 1024:
        case 2048:
        case 4096:
        case 8192:
        case 16384:
        case 32768:
        case 65536:
        case 131072:
        case 262144:
        case 524288:
        case 1048576:
        case 2097152:
          return w & 4194240;
        case 4194304:
        case 8388608:
        case 16777216:
        case 33554432:
        case 67108864:
          return w & 130023424;
        case 134217728:
          return 134217728;
        case 268435456:
          return 268435456;
        case 536870912:
          return 536870912;
        case 1073741824:
          return 1073741824;
        default:
          return w
      }
    }

    function W5(w, U) {
      var S = w.pendingLanes;
      if (S === 0) return 0;
      var g = 0,
        m = w.suspendedLanes,
        r = w.pingedLanes,
        j1 = S & 268435455;
      if (j1 !== 0) {
        var CA = j1 & ~m;
        CA !== 0 ? g = x4(CA) : (r &= j1, r !== 0 && (g = x4(r)))
      } else j1 = S & ~m, j1 !== 0 ? g = x4(j1) : r !== 0 && (g = x4(r));
      if (g === 0) return 0;
      if (U !== 0 && U !== g && (U & m) === 0 && (m = g & -g, r = U & -U, m >= r || m === 16 && (r & 4194240) !== 0)) return U;
      if ((g & 4) !== 0 && (g |= S & 16), U = w.entangledLanes, U !== 0)
        for (w = w.entanglements, U &= g; 0 < U;) S = 31 - sA(U), m = 1 << S, g |= w[S], U &= ~m;
      return g
    }

    function b6(w, U) {
      switch (w) {
        case 1:
        case 2:
        case 4:
          return U + 250;
        case 8:
        case 16:
        case 32:
        case 64:
        case 128:
        case 256:
        case 512:
        case 1024:
        case 2048:
        case 4096:
        case 8192:
        case 16384:
        case 32768:
        case 65536:
        case 131072:
        case 262144:
        case 524288:
        case 1048576:
        case 2097152:
          return U + 5000;
        case 4194304:
        case 8388608:
        case 16777216:
        case 33554432:
        case 67108864:
          return -1;
        case 134217728:
        case 268435456:
        case 536870912:
        case 1073741824:
          return -1;
        default:
          return -1
      }
    }

    function C3(w, U) {
      for (var {
          suspendedLanes: S,
          pingedLanes: g,
          expirationTimes: m,
          pendingLanes: r
        } = w; 0 < r;) {
        var j1 = 31 - sA(r),
          CA = 1 << j1,
          kA = m[j1];
        if (kA === -1) {
          if ((CA & S) === 0 || (CA & g) !== 0) m[j1] = b6(CA, U)
        } else kA <= U && (w.expiredLanes |= CA);
        r &= ~CA
      }
    }

    function AI(w) {
      return w = w.pendingLanes & -1073741825, w !== 0 ? w : w & 1073741824 ? 1073741824 : 0
    }

    function QD() {
      var w = R9;
      return R9 <<= 1, (R9 & 4194240) === 0 && (R9 = 64), w
    }

    function jW(w) {
      for (var U = [], S = 0; 31 > S; S++) U.push(w);
      return U
    }

    function BI(w, U, S) {
      w.pendingLanes |= U, U !== 536870912 && (w.suspendedLanes = 0, w.pingedLanes = 0), w = w.eventTimes, U = 31 - sA(U), w[U] = S
    }

    function yW(w, U) {
      var S = w.pendingLanes & ~U;
      w.pendingLanes = U, w.suspendedLanes = 0, w.pingedLanes = 0, w.expiredLanes &= U, w.mutableReadLanes &= U, w.entangledLanes &= U, U = w.entanglements;
      var g = w.eventTimes;
      for (w = w.expirationTimes; 0 < S;) {
        var m = 31 - sA(S),
          r = 1 << m;
        U[m] = 0, g[m] = -1, w[m] = -1, S &= ~r
      }
    }

    function ID(w, U) {
      var S = w.entangledLanes |= U;
      for (w = w.entanglements; S;) {
        var g = 31 - sA(S),
          m = 1 << g;
        m & U | w[g] & U && (w[g] |= U), S &= ~m
      }
    }
    var L4 = 0;

    function QI(w) {
      return w &= -w, 1 < w ? 4 < w ? (w & 268435455) !== 0 ? 16 : 536870912 : 4 : 1
    }
    var GD = b7.unstable_scheduleCallback,
      qV = b7.unstable_cancelCallback,
      e$ = b7.unstable_shouldYield,
      eK = b7.unstable_requestPaint,
      wB = b7.unstable_now,
      AH = b7.unstable_ImmediatePriority,
      Aq = b7.unstable_UserBlockingPriority,
      jE = b7.unstable_NormalPriority,
      MT = b7.unstable_IdlePriority,
      i6 = null,
      R4 = null;

    function MV(w) {
      if (R4 && typeof R4.onCommitFiberRoot === "function") try {
        R4.onCommitFiberRoot(i6, w, void 0, (w.current.flags & 128) === 128)
      } catch (U) {}
    }

    function Bq(w, U) {
      return w === U && (w !== 0 || 1 / w === 1 / U) || w !== w && U !== U
    }
    var jB = typeof Object.is === "function" ? Object.is : Bq,
      oG = null,
      yE = !1,
      Qq = !1;

    function XF(w) {
      oG === null ? oG = [w] : oG.push(w)
    }

    function Iq(w) {
      yE = !0, XF(w)
    }

    function E5() {
      if (!Qq && oG !== null) {
        Qq = !0;
        var w = 0,
          U = L4;
        try {
          var S = oG;
          for (L4 = 1; w < S.length; w++) {
            var g = S[w];
            do g = g(!0); while (g !== null)
          }
          oG = null, yE = !1
        } catch (m) {
          throw oG !== null && (oG = oG.slice(w + 1)), GD(AH, E5), m
        } finally {
          L4 = U, Qq = !1
        }
      }
      return null
    }
    var kW = [],
      M7 = 0,
      LV = null,
      RV = 0,
      y5 = [],
      n6 = 0,
      tG = null,
      EB = 1,
      yB = "";

    function t4(w, U) {
      kW[M7++] = RV, kW[M7++] = LV, LV = w, RV = U
    }

    function ZD(w, U, S) {
      y5[n6++] = EB, y5[n6++] = yB, y5[n6++] = tG, tG = w;
      var g = EB;
      w = yB;
      var m = 32 - sA(g) - 1;
      g &= ~(1 << m), S += 1;
      var r = 32 - sA(U) + m;
      if (30 < r) {
        var j1 = m - m % 5;
        r = (g & (1 << j1) - 1).toString(32), g >>= j1, m -= j1, EB = 1 << 32 - sA(U) + m | S << m | g, yB = r + w
      } else EB = 1 << r | S << m | g, yB = w
    }

    function J5(w) {
      w.return !== null && (t4(w, 1), ZD(w, 1, 0))
    }

    function Z9(w) {
      for (; w === LV;) LV = kW[--M7], kW[M7] = null, RV = kW[--M7], kW[M7] = null;
      for (; w === tG;) tG = y5[--n6], y5[n6] = null, yB = y5[--n6], y5[n6] = null, EB = y5[--n6], y5[n6] = null
    }
    var P6 = null,
      Q8 = null,
      k5 = !1,
      lQ = !1,
      kB = null;

    function eG(w, U) {
      var S = c2(5, null, null, 0);
      S.elementType = "DELETED", S.stateNode = U, S.return = w, U = w.deletions, U === null ? (w.deletions = [S], w.flags |= 16) : U.push(S)
    }

    function S6(w, U) {
      switch (w.tag) {
        case 5:
          return U = _B(U, w.type, w.pendingProps), U !== null ? (w.stateNode = U, P6 = w, Q8 = j5(U), !0) : !1;
        case 6:
          return U = D6(U, w.pendingProps), U !== null ? (w.stateNode = U, P6 = w, Q8 = null, !0) : !1;
        case 13:
          if (U = F3(U), U !== null) {
            var S = tG !== null ? {
              id: EB,
              overflow: yB
            } : null;
            return w.memoizedState = {
              dehydrated: U,
              treeContext: S,
              retryLane: 1073741824
            }, S = c2(18, null, null, 0), S.stateNode = U, S.return = w, w.child = S, P6 = w, Q8 = null, !0
          }
          return !1;
        default:
          return !1
      }
    }

    function JQ(w) {
      return (w.mode & 1) !== 0 && (w.flags & 128) === 0
    }

    function L7(w) {
      if (k5) {
        var U = Q8;
        if (U) {
          var S = U;
          if (!S6(w, U)) {
            if (JQ(w)) throw Error(G(418));
            U = w9(S);
            var g = P6;
            U && S6(w, U) ? eG(g, S) : (w.flags = w.flags & -4097 | 2, k5 = !1, P6 = w)
          }
        } else {
          if (JQ(w)) throw Error(G(418));
          w.flags = w.flags & -4097 | 2, k5 = !1, P6 = w
        }
      }
    }

    function OV(w) {
      for (w = w.return; w !== null && w.tag !== 5 && w.tag !== 3 && w.tag !== 13;) w = w.return;
      P6 = w
    }

    function K3(w) {
      if (!W1 || w !== P6) return !1;
      if (!k5) return OV(w), k5 = !0, !1;
      if (w.tag !== 3 && (w.tag !== 5 || zB(w.type) && !Q1(w.type, w.memoizedProps))) {
        var U = Q8;
        if (U) {
          if (JQ(w)) throw BH(), Error(G(418));
          for (; U;) eG(w, U), U = w9(U)
        }
      }
      if (OV(w), w.tag === 13) {
        if (!W1) throw Error(G(316));
        if (w = w.memoizedState, w = w !== null ? w.dehydrated : null, !w) throw Error(G(317));
        Q8 = aI(w)
      } else Q8 = P6 ? w9(w.stateNode) : null;
      return !0
    }

    function BH() {
      for (var w = Q8; w;) w = w9(w)
    }

    function DD() {
      W1 && (Q8 = P6 = null, lQ = k5 = !1)
    }

    function QH(w) {
      kB === null ? kB = [w] : kB.push(w)
    }
    var Gq = Z.ReactCurrentBatchConfig;

    function sI(w, U) {
      if (jB(w, U)) return !0;
      if (typeof w !== "object" || w === null || typeof U !== "object" || U === null) return !1;
      var S = Object.keys(w),
        g = Object.keys(U);
      if (S.length !== g.length) return !1;
      for (g = 0; g < S.length; g++) {
        var m = S[g];
        if (!PA.call(U, m) || !jB(w[m], U[m])) return !1
      }
      return !0
    }

    function BY(w) {
      switch (w.tag) {
        case 5:
          return VA(w.type);
        case 16:
          return VA("Lazy");
        case 13:
          return VA("Suspense");
        case 19:
          return VA("SuspenseList");
        case 0:
        case 2:
        case 15:
          return w = KA(w.type, !1), w;
        case 11:
          return w = KA(w.type.render, !1), w;
        case 1:
          return w = KA(w.type, !0), w;
        default:
          return ""
      }
    }

    function o(w, U, S) {
      if (w = S.ref, w !== null && typeof w !== "function" && typeof w !== "object") {
        if (S._owner) {
          if (S = S._owner, S) {
            if (S.tag !== 1) throw Error(G(309));
            var g = S.stateNode
          }
          if (!g) throw Error(G(147, w));
          var m = g,
            r = "" + w;
          if (U !== null && U.ref !== null && typeof U.ref === "function" && U.ref._stringRef === r) return U.ref;
          return U = function(j1) {
            var CA = m.refs;
            j1 === null ? delete CA[r] : CA[r] = j1
          }, U._stringRef = r, U
        }
        if (typeof w !== "string") throw Error(G(284));
        if (!S._owner) throw Error(G(290, w))
      }
      return w
    }

    function A1(w, U) {
      throw w = Object.prototype.toString.call(U), Error(G(31, w === "[object Object]" ? "object with keys {" + Object.keys(U).join(", ") + "}" : w))
    }

    function p1(w) {
      var U = w._init;
      return U(w._payload)
    }

    function TA(w) {
      function U(yA, EA) {
        if (w) {
          var hA = yA.deletions;
          hA === null ? (yA.deletions = [EA], yA.flags |= 16) : hA.push(EA)
        }
      }

      function S(yA, EA) {
        if (!w) return null;
        for (; EA !== null;) U(yA, EA), EA = EA.sibling;
        return null
      }

      function g(yA, EA) {
        for (yA = new Map; EA !== null;) EA.key !== null ? yA.set(EA.key, EA) : yA.set(EA.index, EA), EA = EA.sibling;
        return yA
      }

      function m(yA, EA) {
        return yA = CD(yA, EA), yA.index = 0, yA.sibling = null, yA
      }

      function r(yA, EA, hA) {
        if (yA.index = hA, !w) return yA.flags |= 1048576, EA;
        if (hA = yA.alternate, hA !== null) return hA = hA.index, hA < EA ? (yA.flags |= 2, EA) : hA;
        return yA.flags |= 2, EA
      }

      function j1(yA) {
        return w && yA.alternate === null && (yA.flags |= 2), yA
      }

      function CA(yA, EA, hA, l0) {
        if (EA === null || EA.tag !== 6) return EA = nT(hA, yA.mode, l0), EA.return = yA, EA;
        return EA = m(EA, hA), EA.return = yA, EA
      }

      function kA(yA, EA, hA, l0) {
        var t2 = hA.type;
        if (t2 === W) return h0(yA, EA, hA.props.children, l0, hA.key);
        if (EA !== null && (EA.elementType === t2 || typeof t2 === "object" && t2 !== null && t2.$$typeof === q && p1(t2) === EA.type)) return l0 = m(EA, hA.props), l0.ref = o(yA, EA, hA), l0.return = yA, l0;
        return l0 = LF(hA.type, hA.key, hA.props, null, yA.mode, l0), l0.ref = o(yA, EA, hA), l0.return = yA, l0
      }

      function F0(yA, EA, hA, l0) {
        if (EA === null || EA.tag !== 4 || EA.stateNode.containerInfo !== hA.containerInfo || EA.stateNode.implementation !== hA.implementation) return EA = GU(hA, yA.mode, l0), EA.return = yA, EA;
        return EA = m(EA, hA.children || []), EA.return = yA, EA
      }

      function h0(yA, EA, hA, l0, t2) {
        if (EA === null || EA.tag !== 7) return EA = RF(hA, yA.mode, l0, t2), EA.return = yA, EA;
        return EA = m(EA, hA), EA.return = yA, EA
      }

      function i2(yA, EA, hA) {
        if (typeof EA === "string" && EA !== "" || typeof EA === "number") return EA = nT("" + EA, yA.mode, hA), EA.return = yA, EA;
        if (typeof EA === "object" && EA !== null) {
          switch (EA.$$typeof) {
            case D:
              return hA = LF(EA.type, EA.key, EA.props, null, yA.mode, hA), hA.ref = o(yA, null, EA), hA.return = yA, hA;
            case Y:
              return EA = GU(EA, yA.mode, hA), EA.return = yA, EA;
            case q:
              var l0 = EA._init;
              return i2(yA, l0(EA._payload), hA)
          }
          if (X1(EA) || T(EA)) return EA = RF(EA, yA.mode, hA, null), EA.return = yA, EA;
          A1(yA, EA)
        }
        return null
      }

      function n0(yA, EA, hA, l0) {
        var t2 = EA !== null ? EA.key : null;
        if (typeof hA === "string" && hA !== "" || typeof hA === "number") return t2 !== null ? null : CA(yA, EA, "" + hA, l0);
        if (typeof hA === "object" && hA !== null) {
          switch (hA.$$typeof) {
            case D:
              return hA.key === t2 ? kA(yA, EA, hA, l0) : null;
            case Y:
              return hA.key === t2 ? F0(yA, EA, hA, l0) : null;
            case q:
              return t2 = hA._init, n0(yA, EA, t2(hA._payload), l0)
          }
          if (X1(hA) || T(hA)) return t2 !== null ? null : h0(yA, EA, hA, l0, null);
          A1(yA, hA)
        }
        return null
      }

      function l5(yA, EA, hA, l0, t2) {
        if (typeof l0 === "string" && l0 !== "" || typeof l0 === "number") return yA = yA.get(hA) || null, CA(EA, yA, "" + l0, t2);
        if (typeof l0 === "object" && l0 !== null) {
          switch (l0.$$typeof) {
            case D:
              return yA = yA.get(l0.key === null ? hA : l0.key) || null, kA(EA, yA, l0, t2);
            case Y:
              return yA = yA.get(l0.key === null ? hA : l0.key) || null, F0(EA, yA, l0, t2);
            case q:
              var M0 = l0._init;
              return l5(yA, EA, hA, M0(l0._payload), t2)
          }
          if (X1(l0) || T(l0)) return yA = yA.get(hA) || null, h0(EA, yA, l0, t2, null);
          A1(EA, l0)
        }
        return null
      }

      function x5(yA, EA, hA, l0) {
        for (var t2 = null, M0 = null, l9 = EA, W6 = EA = 0, f8 = null; l9 !== null && W6 < hA.length; W6++) {
          l9.index > W6 ? (f8 = l9, l9 = null) : f8 = l9.sibling;
          var J6 = n0(yA, l9, hA[W6], l0);
          if (J6 === null) {
            l9 === null && (l9 = f8);
            break
          }
          w && l9 && J6.alternate === null && U(yA, l9), EA = r(J6, EA, W6), M0 === null ? t2 = J6 : M0.sibling = J6, M0 = J6, l9 = f8
        }
        if (W6 === hA.length) return S(yA, l9), k5 && t4(yA, W6), t2;
        if (l9 === null) {
          for (; W6 < hA.length; W6++) l9 = i2(yA, hA[W6], l0), l9 !== null && (EA = r(l9, EA, W6), M0 === null ? t2 = l9 : M0.sibling = l9, M0 = l9);
          return k5 && t4(yA, W6), t2
        }
        for (l9 = g(yA, l9); W6 < hA.length; W6++) f8 = l5(l9, yA, W6, hA[W6], l0), f8 !== null && (w && f8.alternate !== null && l9.delete(f8.key === null ? W6 : f8.key), EA = r(f8, EA, W6), M0 === null ? t2 = f8 : M0.sibling = f8, M0 = f8);
        return w && l9.forEach(function(KD) {
          return U(yA, KD)
        }), k5 && t4(yA, W6), t2
      }

      function YI(yA, EA, hA, l0) {
        var t2 = T(hA);
        if (typeof t2 !== "function") throw Error(G(150));
        if (hA = t2.call(hA), hA == null) throw Error(G(151));
        for (var M0 = t2 = null, l9 = EA, W6 = EA = 0, f8 = null, J6 = hA.next(); l9 !== null && !J6.done; W6++, J6 = hA.next()) {
          l9.index > W6 ? (f8 = l9, l9 = null) : f8 = l9.sibling;
          var KD = n0(yA, l9, J6.value, l0);
          if (KD === null) {
            l9 === null && (l9 = f8);
            break
          }
          w && l9 && KD.alternate === null && U(yA, l9), EA = r(KD, EA, W6), M0 === null ? t2 = KD : M0.sibling = KD, M0 = KD, l9 = f8
        }
        if (J6.done) return S(yA, l9), k5 && t4(yA, W6), t2;
        if (l9 === null) {
          for (; !J6.done; W6++, J6 = hA.next()) J6 = i2(yA, J6.value, l0), J6 !== null && (EA = r(J6, EA, W6), M0 === null ? t2 = J6 : M0.sibling = J6, M0 = J6);
          return k5 && t4(yA, W6), t2
        }
        for (l9 = g(yA, l9); !J6.done; W6++, J6 = hA.next()) J6 = l5(l9, yA, W6, J6.value, l0), J6 !== null && (w && J6.alternate !== null && l9.delete(J6.key === null ? W6 : J6.key), EA = r(J6, EA, W6), M0 === null ? t2 = J6 : M0.sibling = J6, M0 = J6);
        return w && l9.forEach(function(Xk) {
          return U(yA, Xk)
        }), k5 && t4(yA, W6), t2
      }

      function wQ(yA, EA, hA, l0) {
        if (typeof hA === "object" && hA !== null && hA.type === W && hA.key === null && (hA = hA.props.children), typeof hA === "object" && hA !== null) {
          switch (hA.$$typeof) {
            case D:
              A: {
                for (var t2 = hA.key, M0 = EA; M0 !== null;) {
                  if (M0.key === t2) {
                    if (t2 = hA.type, t2 === W) {
                      if (M0.tag === 7) {
                        S(yA, M0.sibling), EA = m(M0, hA.props.children), EA.return = yA, yA = EA;
                        break A
                      }
                    } else if (M0.elementType === t2 || typeof t2 === "object" && t2 !== null && t2.$$typeof === q && p1(t2) === M0.type) {
                      S(yA, M0.sibling), EA = m(M0, hA.props), EA.ref = o(yA, M0, hA), EA.return = yA, yA = EA;
                      break A
                    }
                    S(yA, M0);
                    break
                  } else U(yA, M0);
                  M0 = M0.sibling
                }
                hA.type === W ? (EA = RF(hA.props.children, yA.mode, l0, hA.key), EA.return = yA, yA = EA) : (l0 = LF(hA.type, hA.key, hA.props, null, yA.mode, l0), l0.ref = o(yA, EA, hA), l0.return = yA, yA = l0)
              }
              return j1(yA);
            case Y:
              A: {
                for (M0 = hA.key; EA !== null;) {
                  if (EA.key === M0)
                    if (EA.tag === 4 && EA.stateNode.containerInfo === hA.containerInfo && EA.stateNode.implementation === hA.implementation) {
                      S(yA, EA.sibling), EA = m(EA, hA.children || []), EA.return = yA, yA = EA;
                      break A
                    } else {
                      S(yA, EA);
                      break
                    }
                  else U(yA, EA);
                  EA = EA.sibling
                }
                EA = GU(hA, yA.mode, l0),
                EA.return = yA,
                yA = EA
              }
              return j1(yA);
            case q:
              return M0 = hA._init, wQ(yA, EA, M0(hA._payload), l0)
          }
          if (X1(hA)) return x5(yA, EA, hA, l0);
          if (T(hA)) return YI(yA, EA, hA, l0);
          A1(yA, hA)
        }
        return typeof hA === "string" && hA !== "" || typeof hA === "number" ? (hA = "" + hA, EA !== null && EA.tag === 6 ? (S(yA, EA.sibling), EA = m(EA, hA), EA.return = yA, yA = EA) : (S(yA, EA), EA = nT(hA, yA.mode, l0), EA.return = yA, yA = EA), j1(yA)) : S(yA, EA)
      }
      return wQ
    }
    var vA = TA(!0),
      v0 = TA(!1),
      o2 = NA(null),
      t9 = null,
      _6 = null,
      y8 = null;

    function k3() {
      y8 = _6 = t9 = null
    }

    function F5(w, U, S) {
      MA ? (uA(o2, U._currentValue), U._currentValue = S) : (uA(o2, U._currentValue2), U._currentValue2 = S)
    }

    function rI(w) {
      var U = o2.current;
      SA(o2), MA ? w._currentValue = U : w._currentValue2 = U
    }

    function FQ(w, U, S) {
      for (; w !== null;) {
        var g = w.alternate;
        if ((w.childLanes & U) !== U ? (w.childLanes |= U, g !== null && (g.childLanes |= U)) : g !== null && (g.childLanes & U) !== U && (g.childLanes |= U), w === S) break;
        w = w.return
      }
    }

    function oI(w, U) {
      t9 = w, y8 = _6 = null, w = w.dependencies, w !== null && w.firstContext !== null && ((w.lanes & U) !== 0 && (U9 = !0), w.firstContext = null)
    }

    function R7(w) {
      var U = MA ? w._currentValue : w._currentValue2;
      if (y8 !== w)
        if (w = {
            context: w,
            memoizedValue: U,
            next: null
          }, _6 === null) {
          if (t9 === null) throw Error(G(308));
          _6 = w, t9.dependencies = {
            lanes: 0,
            firstContext: w
          }
        } else _6 = _6.next = w;
      return U
    }
    var VF = null;

    function LT(w) {
      VF === null ? VF = [w] : VF.push(w)
    }

    function Zq(w, U, S, g) {
      var m = U.interleaved;
      return m === null ? (S.next = S, LT(U)) : (S.next = m.next, m.next = S), U.interleaved = S, xW(w, g)
    }

    function xW(w, U) {
      w.lanes |= U;
      var S = w.alternate;
      S !== null && (S.lanes |= U), S = w;
      for (w = w.return; w !== null;) w.childLanes |= U, S = w.alternate, S !== null && (S.childLanes |= U), S = w, w = w.return;
      return S.tag === 3 ? S.stateNode : null
    }
    var TV = !1;

    function QY(w) {
      w.updateQueue = {
        baseState: w.memoizedState,
        firstBaseUpdate: null,
        lastBaseUpdate: null,
        shared: {
          pending: null,
          interleaved: null,
          lanes: 0
        },
        effects: null
      }
    }

    function kE(w, U) {
      w = w.updateQueue, U.updateQueue === w && (U.updateQueue = {
        baseState: w.baseState,
        firstBaseUpdate: w.firstBaseUpdate,
        lastBaseUpdate: w.lastBaseUpdate,
        shared: w.shared,
        effects: w.effects
      })
    }

    function iQ(w, U) {
      return {
        eventTime: w,
        lane: U,
        tag: 0,
        payload: null,
        callback: null,
        next: null
      }
    }

    function YD(w, U, S) {
      var g = w.updateQueue;
      if (g === null) return null;
      if (g = g.shared, (h4 & 2) !== 0) {
        var m = g.pending;
        return m === null ? U.next = U : (U.next = m.next, m.next = U), g.pending = U, xW(w, S)
      }
      return m = g.interleaved, m === null ? (U.next = U, LT(g)) : (U.next = m.next, m.next = U), g.interleaved = U, xW(w, S)
    }

    function Dq(w, U, S) {
      if (U = U.updateQueue, U !== null && (U = U.shared, (S & 4194240) !== 0)) {
        var g = U.lanes;
        g &= w.pendingLanes, S |= g, U.lanes = S, ID(w, S)
      }
    }

    function CF(w, U) {
      var {
        updateQueue: S,
        alternate: g
      } = w;
      if (g !== null && (g = g.updateQueue, S === g)) {
        var m = null,
          r = null;
        if (S = S.firstBaseUpdate, S !== null) {
          do {
            var j1 = {
              eventTime: S.eventTime,
              lane: S.lane,
              tag: S.tag,
              payload: S.payload,
              callback: S.callback,
              next: null
            };
            r === null ? m = r = j1 : r = r.next = j1, S = S.next
          } while (S !== null);
          r === null ? m = r = U : r = r.next = U
        } else m = r = U;
        S = {
          baseState: g.baseState,
          firstBaseUpdate: m,
          lastBaseUpdate: r,
          shared: g.shared,
          effects: g.effects
        }, w.updateQueue = S;
        return
      }
      w = S.lastBaseUpdate, w === null ? S.firstBaseUpdate = U : w.next = U, S.lastBaseUpdate = U
    }

    function IH(w, U, S, g) {
      var m = w.updateQueue;
      TV = !1;
      var {
        firstBaseUpdate: r,
        lastBaseUpdate: j1
      } = m, CA = m.shared.pending;
      if (CA !== null) {
        m.shared.pending = null;
        var kA = CA,
          F0 = kA.next;
        kA.next = null, j1 === null ? r = F0 : j1.next = F0, j1 = kA;
        var h0 = w.alternate;
        h0 !== null && (h0 = h0.updateQueue, CA = h0.lastBaseUpdate, CA !== j1 && (CA === null ? h0.firstBaseUpdate = F0 : CA.next = F0, h0.lastBaseUpdate = kA))
      }
      if (r !== null) {
        var i2 = m.baseState;
        j1 = 0, h0 = F0 = kA = null, CA = r;
        do {
          var {
            lane: n0,
            eventTime: l5
          } = CA;
          if ((g & n0) === n0) {
            h0 !== null && (h0 = h0.next = {
              eventTime: l5,
              lane: 0,
              tag: CA.tag,
              payload: CA.payload,
              callback: CA.callback,
              next: null
            });
            A: {
              var x5 = w,
                YI = CA;
              switch (n0 = U, l5 = S, YI.tag) {
                case 1:
                  if (x5 = YI.payload, typeof x5 === "function") {
                    i2 = x5.call(l5, i2, n0);
                    break A
                  }
                  i2 = x5;
                  break A;
                case 3:
                  x5.flags = x5.flags & -65537 | 128;
                case 0:
                  if (x5 = YI.payload, n0 = typeof x5 === "function" ? x5.call(l5, i2, n0) : x5, n0 === null || n0 === void 0) break A;
                  i2 = I({}, i2, n0);
                  break A;
                case 2:
                  TV = !0
              }
            }
            CA.callback !== null && CA.lane !== 0 && (w.flags |= 64, n0 = m.effects, n0 === null ? m.effects = [CA] : n0.push(CA))
          } else l5 = {
            eventTime: l5,
            lane: n0,
            tag: CA.tag,
            payload: CA.payload,
            callback: CA.callback,
            next: null
          }, h0 === null ? (F0 = h0 = l5, kA = i2) : h0 = h0.next = l5, j1 |= n0;
          if (CA = CA.next, CA === null)
            if (CA = m.shared.pending, CA === null) break;
            else n0 = CA, CA = n0.next, n0.next = null, m.lastBaseUpdate = n0, m.shared.pending = null
        } while (1);
        if (h0 === null && (kA = i2), m.baseState = kA, m.firstBaseUpdate = F0, m.lastBaseUpdate = h0, U = m.shared.interleaved, U !== null) {
          m = U;
          do j1 |= m.lane, m = m.next; while (m !== U)
        } else r === null && (m.shared.lanes = 0);
        vV |= j1, w.lanes = j1, w.memoizedState = i2
      }
    }

    function jp(w, U, S) {
      if (w = U.effects, U.effects = null, w !== null)
        for (U = 0; U < w.length; U++) {
          var g = w[U],
            m = g.callback;
          if (m !== null) {
            if (g.callback = null, g = S, typeof m !== "function") throw Error(G(191, m));
            m.call(g)
          }
        }
    }
    var xE = {},
      WD = NA(xE),
      JD = NA(xE),
      O7 = NA(xE);

    function xB(w) {
      if (w === xE) throw Error(G(174));
      return w
    }

    function GH(w, U) {
      uA(O7, U), uA(JD, w), uA(WD, xE), w = D1(U), SA(WD), uA(WD, w)
    }

    function fW() {
      SA(WD), SA(JD), SA(O7)
    }

    function fE(w) {
      var U = xB(O7.current),
        S = xB(WD.current);
      U = N1(S, w.type, U), S !== U && (uA(JD, w), uA(WD, U))
    }

    function Yq(w) {
      JD.current === w && (SA(WD), SA(JD))
    }
    var k8 = NA(0);

    function AZ(w) {
      for (var U = w; U !== null;) {
        if (U.tag === 13) {
          var S = U.memoizedState;
          if (S !== null && (S = S.dehydrated, S === null || X3(S) || q7(S))) return U
        } else if (U.tag === 19 && U.memoizedProps.revealOrder !== void 0) {
          if ((U.flags & 128) !== 0) return U
        } else if (U.child !== null) {
          U.child.return = U, U = U.child;
          continue
        }
        if (U === w) break;
        for (; U.sibling === null;) {
          if (U.return === null || U.return === w) return null;
          U = U.return
        }
        U.sibling.return = U.return, U = U.sibling
      }
      return null
    }
    var JA = [];

    function gA() {
      for (var w = 0; w < JA.length; w++) {
        var U = JA[w];
        MA ? U._workInProgressVersionPrimary = null : U._workInProgressVersionSecondary = null
      }
      JA.length = 0
    }
    var {
      ReactCurrentDispatcher: $A,
      ReactCurrentBatchConfig: w2
    } = Z, f9 = 0, E9 = null, b4 = null, D4 = null, II = !1, Y6 = !1, H3 = 0, PV = 0;

    function fB() {
      throw Error(G(321))
    }

    function SV(w, U) {
      if (U === null) return !1;
      for (var S = 0; S < U.length && S < w.length; S++)
        if (!jB(w[S], U[S])) return !1;
      return !0
    }

    function vE(w, U, S, g, m, r) {
      if (f9 = r, E9 = U, U.memoizedState = null, U.updateQueue = null, U.lanes = 0, $A.current = w === null || w.memoizedState === null ? TT : uE, w = S(g, m), Y6) {
        r = 0;
        do {
          if (Y6 = !1, H3 = 0, 25 <= r) throw Error(G(301));
          r += 1, D4 = b4 = null, U.updateQueue = null, $A.current = PT, w = S(g, m)
        } while (Y6)
      }
      if ($A.current = Xq, U = b4 !== null && b4.next !== null, f9 = 0, D4 = b4 = E9 = null, II = !1, U) throw Error(G(300));
      return w
    }

    function _V() {
      var w = H3 !== 0;
      return H3 = 0, w
    }

    function g4() {
      var w = {
        memoizedState: null,
        baseState: null,
        baseQueue: null,
        queue: null,
        next: null
      };
      return D4 === null ? E9.memoizedState = D4 = w : D4 = D4.next = w, D4
    }

    function BZ() {
      if (b4 === null) {
        var w = E9.alternate;
        w = w !== null ? w.memoizedState : null
      } else w = b4.next;
      var U = D4 === null ? E9.memoizedState : D4.next;
      if (U !== null) D4 = U, b4 = w;
      else {
        if (w === null) throw Error(G(310));
        b4 = w, w = {
          memoizedState: b4.memoizedState,
          baseState: b4.baseState,
          baseQueue: b4.baseQueue,
          queue: b4.queue,
          next: null
        }, D4 === null ? E9.memoizedState = D4 = w : D4 = D4.next = w
      }
      return D4
    }

    function tI(w, U) {
      return typeof U === "function" ? U(w) : U
    }

    function jV(w) {
      var U = BZ(),
        S = U.queue;
      if (S === null) throw Error(G(311));
      S.lastRenderedReducer = w;
      var g = b4,
        m = g.baseQueue,
        r = S.pending;
      if (r !== null) {
        if (m !== null) {
          var j1 = m.next;
          m.next = r.next, r.next = j1
        }
        g.baseQueue = m = r, S.pending = null
      }
      if (m !== null) {
        r = m.next, g = g.baseState;
        var CA = j1 = null,
          kA = null,
          F0 = r;
        do {
          var h0 = F0.lane;
          if ((f9 & h0) === h0) kA !== null && (kA = kA.next = {
            lane: 0,
            action: F0.action,
            hasEagerState: F0.hasEagerState,
            eagerState: F0.eagerState,
            next: null
          }), g = F0.hasEagerState ? F0.eagerState : w(g, F0.action);
          else {
            var i2 = {
              lane: h0,
              action: F0.action,
              hasEagerState: F0.hasEagerState,
              eagerState: F0.eagerState,
              next: null
            };
            kA === null ? (CA = kA = i2, j1 = g) : kA = kA.next = i2, E9.lanes |= h0, vV |= h0
          }
          F0 = F0.next
        } while (F0 !== null && F0 !== r);
        kA === null ? j1 = g : kA.next = CA, jB(g, U.memoizedState) || (U9 = !0), U.memoizedState = g, U.baseState = j1, U.baseQueue = kA, S.lastRenderedState = g
      }
      if (w = S.interleaved, w !== null) {
        m = w;
        do r = m.lane, E9.lanes |= r, vV |= r, m = m.next; while (m !== w)
      } else m === null && (S.lanes = 0);
      return [U.memoizedState, S.dispatch]
    }

    function ZH(w) {
      var U = BZ(),
        S = U.queue;
      if (S === null) throw Error(G(311));
      S.lastRenderedReducer = w;
      var {
        dispatch: g,
        pending: m
      } = S, r = U.memoizedState;
      if (m !== null) {
        S.pending = null;
        var j1 = m = m.next;
        do r = w(r, j1.action), j1 = j1.next; while (j1 !== m);
        jB(r, U.memoizedState) || (U9 = !0), U.memoizedState = r, U.baseQueue === null && (U.baseState = r), S.lastRenderedState = r
      }
      return [r, g]
    }

    function dy() {}

    function uy(w, U) {
      var S = E9,
        g = BZ(),
        m = U(),
        r = !jB(g.memoizedState, m);
      if (r && (g.memoizedState = m, U9 = !0), g = g.queue, YH(gE.bind(null, S, g, w), [w]), g.getSnapshot !== U || r || D4 !== null && D4.memoizedState.tag & 1) {
        if (S.flags |= 2048, KF(9, FD.bind(null, S, g, m, U), void 0, null), b3 === null) throw Error(G(349));
        (f9 & 30) !== 0 || bE(S, U, m)
      }
      return m
    }

    function bE(w, U, S) {
      w.flags |= 16384, w = {
        getSnapshot: U,
        value: S
      }, U = E9.updateQueue, U === null ? (U = {
        lastEffect: null,
        stores: null
      }, E9.updateQueue = U, U.stores = [w]) : (S = U.stores, S === null ? U.stores = [w] : S.push(w))
    }

    function FD(w, U, S, g) {
      U.value = S, U.getSnapshot = g, hE(U) && mE(w)
    }

    function gE(w, U, S) {
      return S(function() {
        hE(U) && mE(w)
      })
    }

    function hE(w) {
      var U = w.getSnapshot;
      w = w.value;
      try {
        var S = U();
        return !jB(w, S)
      } catch (g) {
        return !0
      }
    }

    function mE(w) {
      var U = xW(w, 1);
      U !== null && x8(U, w, 1, -1)
    }

    function RT(w) {
      var U = g4();
      return typeof w === "function" && (w = w()), U.memoizedState = U.baseState = w, w = {
        pending: null,
        interleaved: null,
        lanes: 0,
        dispatch: null,
        lastRenderedReducer: tI,
        lastRenderedState: w
      }, U.queue = w, w = w.dispatch = XQ.bind(null, E9, w), [U.memoizedState, w]
    }

    function KF(w, U, S, g) {
      return w = {
        tag: w,
        create: U,
        destroy: S,
        deps: g,
        next: null
      }, U = E9.updateQueue, U === null ? (U = {
        lastEffect: null,
        stores: null
      }, E9.updateQueue = U, U.lastEffect = w.next = w) : (S = U.lastEffect, S === null ? U.lastEffect = w.next = w : (g = S.next, S.next = w, w.next = g, U.lastEffect = w)), w
    }

    function vW() {
      return BZ().memoizedState
    }

    function DH(w, U, S, g) {
      var m = g4();
      E9.flags |= w, m.memoizedState = KF(1 | U, S, void 0, g === void 0 ? null : g)
    }

    function IY(w, U, S, g) {
      var m = BZ();
      g = g === void 0 ? null : g;
      var r = void 0;
      if (b4 !== null) {
        var j1 = b4.memoizedState;
        if (r = j1.destroy, g !== null && SV(g, j1.deps)) {
          m.memoizedState = KF(U, S, r, g);
          return
        }
      }
      E9.flags |= w, m.memoizedState = KF(1 | U, S, r, g)
    }

    function HF(w, U) {
      return DH(8390656, 8, w, U)
    }

    function YH(w, U) {
      return IY(2048, 8, w, U)
    }

    function py(w, U) {
      return IY(4, 2, w, U)
    }

    function bW(w, U) {
      return IY(4, 4, w, U)
    }

    function Wq(w, U) {
      if (typeof U === "function") return w = w(), U(w),
        function() {
          U(null)
        };
      if (U !== null && U !== void 0) return w = w(), U.current = w,
        function() {
          U.current = null
        }
    }

    function yV(w, U, S) {
      return S = S !== null && S !== void 0 ? S.concat([w]) : null, IY(4, 4, Wq.bind(null, U, w), S)
    }

    function zF() {}

    function Jq(w, U) {
      var S = BZ();
      U = U === void 0 ? null : U;
      var g = S.memoizedState;
      if (g !== null && U !== null && SV(U, g[1])) return g[0];
      return S.memoizedState = [w, U], w
    }

    function OT(w, U) {
      var S = BZ();
      U = U === void 0 ? null : U;
      var g = S.memoizedState;
      if (g !== null && U !== null && SV(U, g[1])) return g[0];
      return w = w(), S.memoizedState = [w, U], w
    }

    function cy(w, U, S) {
      if ((f9 & 21) === 0) return w.baseState && (w.baseState = !1, U9 = !0), w.memoizedState = S;
      return jB(S, U) || (S = QD(), E9.lanes |= S, vV |= S, w.baseState = !0), U
    }

    function yp(w, U) {
      var S = L4;
      L4 = S !== 0 && 4 > S ? S : 4, w(!0);
      var g = w2.transition;
      w2.transition = {};
      try {
        w(!1), U()
      } finally {
        L4 = S, w2.transition = g
      }
    }

    function ly() {
      return BZ().memoizedState
    }

    function z3(w, U, S) {
      var g = cW(w);
      if (S = {
          lane: g,
          action: S,
          hasEagerState: !1,
          eagerState: null,
          next: null
        }, wF(w)) dE(U, S);
      else if (S = Zq(w, U, S, g), S !== null) {
        var m = zQ();
        x8(S, w, g, m), Fq(S, U, g)
      }
    }

    function XQ(w, U, S) {
      var g = cW(w),
        m = {
          lane: g,
          action: S,
          hasEagerState: !1,
          eagerState: null,
          next: null
        };
      if (wF(w)) dE(U, m);
      else {
        var r = w.alternate;
        if (w.lanes === 0 && (r === null || r.lanes === 0) && (r = U.lastRenderedReducer, r !== null)) try {
          var j1 = U.lastRenderedState,
            CA = r(j1, S);
          if (m.hasEagerState = !0, m.eagerState = CA, jB(CA, j1)) {
            var kA = U.interleaved;
            kA === null ? (m.next = m, LT(U)) : (m.next = kA.next, kA.next = m), U.interleaved = m;
            return
          }
        } catch (F0) {} finally {}
        S = Zq(w, U, m, g), S !== null && (m = zQ(), x8(S, w, g, m), Fq(S, U, g))
      }
    }

    function wF(w) {
      var U = w.alternate;
      return w === E9 || U !== null && U === E9
    }

    function dE(w, U) {
      Y6 = II = !0;
      var S = w.pending;
      S === null ? U.next = U : (U.next = S.next, S.next = U), w.pending = U
    }

    function Fq(w, U, S) {
      if ((S & 4194240) !== 0) {
        var g = U.lanes;
        g &= w.pendingLanes, S |= g, U.lanes = S, ID(w, S)
      }
    }
    var Xq = {
        readContext: R7,
        useCallback: fB,
        useContext: fB,
        useEffect: fB,
        useImperativeHandle: fB,
        useInsertionEffect: fB,
        useLayoutEffect: fB,
        useMemo: fB,
        useReducer: fB,
        useRef: fB,
        useState: fB,
        useDebugValue: fB,
        useDeferredValue: fB,
        useTransition: fB,
        useMutableSource: fB,
        useSyncExternalStore: fB,
        useId: fB,
        unstable_isNewReconciler: !1
      },
      TT = {
        readContext: R7,
        useCallback: function(w, U) {
          return g4().memoizedState = [w, U === void 0 ? null : U], w
        },
        useContext: R7,
        useEffect: HF,
        useImperativeHandle: function(w, U, S) {
          return S = S !== null && S !== void 0 ? S.concat([w]) : null, DH(4194308, 4, Wq.bind(null, U, w), S)
        },
        useLayoutEffect: function(w, U) {
          return DH(4194308, 4, w, U)
        },
        useInsertionEffect: function(w, U) {
          return DH(4, 2, w, U)
        },
        useMemo: function(w, U) {
          var S = g4();
          return U = U === void 0 ? null : U, w = w(), S.memoizedState = [w, U], w
        },
        useReducer: function(w, U, S) {
          var g = g4();
          return U = S !== void 0 ? S(U) : U, g.memoizedState = g.baseState = U, w = {
            pending: null,
            interleaved: null,
            lanes: 0,
            dispatch: null,
            lastRenderedReducer: w,
            lastRenderedState: U
          }, g.queue = w, w = w.dispatch = z3.bind(null, E9, w), [g.memoizedState, w]
        },
        useRef: function(w) {
          var U = g4();
          return w = {
            current: w
          }, U.memoizedState = w
        },
        useState: RT,
        useDebugValue: zF,
        useDeferredValue: function(w) {
          return g4().memoizedState = w
        },
        useTransition: function() {
          var w = RT(!1),
            U = w[0];
          return w = yp.bind(null, w[1]), g4().memoizedState = w, [U, w]
        },
        useMutableSource: function() {},
        useSyncExternalStore: function(w, U, S) {
          var g = E9,
            m = g4();
          if (k5) {
            if (S === void 0) throw Error(G(407));
            S = S()
          } else {
            if (S = U(), b3 === null) throw Error(G(349));
            (f9 & 30) !== 0 || bE(g, U, S)
          }
          m.memoizedState = S;
          var r = {
            value: S,
            getSnapshot: U
          };
          return m.queue = r, HF(gE.bind(null, g, r, w), [w]), g.flags |= 2048, KF(9, FD.bind(null, g, r, S, U), void 0, null), S
        },
        useId: function() {
          var w = g4(),
            U = b3.identifierPrefix;
          if (k5) {
            var S = yB,
              g = EB;
            S = (g & ~(1 << 32 - sA(g) - 1)).toString(32) + S, U = ":" + U + "R" + S, S = H3++, 0 < S && (U += "H" + S.toString(32)), U += ":"
          } else S = PV++, U = ":" + U + "r" + S.toString(32) + ":";
          return w.memoizedState = U
        },
        unstable_isNewReconciler: !1
      },
      uE = {
        readContext: R7,
        useCallback: Jq,
        useContext: R7,
        useEffect: YH,
        useImperativeHandle: yV,
        useInsertionEffect: py,
        useLayoutEffect: bW,
        useMemo: OT,
        useReducer: jV,
        useRef: vW,
        useState: function() {
          return jV(tI)
        },
        useDebugValue: zF,
        useDeferredValue: function(w) {
          var U = BZ();
          return cy(U, b4.memoizedState, w)
        },
        useTransition: function() {
          var w = jV(tI)[0],
            U = BZ().memoizedState;
          return [w, U]
        },
        useMutableSource: dy,
        useSyncExternalStore: uy,
        useId: ly,
        unstable_isNewReconciler: !1
      },
      PT = {
        readContext: R7,
        useCallback: Jq,
        useContext: R7,
        useEffect: YH,
        useImperativeHandle: yV,
        useInsertionEffect: py,
        useLayoutEffect: bW,
        useMemo: OT,
        useReducer: ZH,
        useRef: vW,
        useState: function() {
          return ZH(tI)
        },
        useDebugValue: zF,
        useDeferredValue: function(w) {
          var U = BZ();
          return b4 === null ? U.memoizedState = w : cy(U, b4.memoizedState, w)
        },
        useTransition: function() {
          var w = ZH(tI)[0],
            U = BZ().memoizedState;
          return [w, U]
        },
        useMutableSource: dy,
        useSyncExternalStore: uy,
        useId: ly,
        unstable_isNewReconciler: !1
      };

    function VQ(w, U) {
      if (w && w.defaultProps) {
        U = I({}, U), w = w.defaultProps;
        for (var S in w) U[S] === void 0 && (U[S] = w[S]);
        return U
      }
      return U
    }

    function EF(w, U, S, g) {
      U = w.memoizedState, S = S(g, U), S = S === null || S === void 0 ? U : I({}, U, S), w.memoizedState = S, w.lanes === 0 && (w.updateQueue.baseState = S)
    }
    var UF = {
      isMounted: function(w) {
        return (w = w._reactInternals) ? k(w) === w : !1
      },
      enqueueSetState: function(w, U, S) {
        w = w._reactInternals;
        var g = zQ(),
          m = cW(w),
          r = iQ(g, m);
        r.payload = U, S !== void 0 && S !== null && (r.callback = S), U = YD(w, r, m), U !== null && (x8(U, w, m, g), Dq(U, w, m))
      },
      enqueueReplaceState: function(w, U, S) {
        w = w._reactInternals;
        var g = zQ(),
          m = cW(w),
          r = iQ(g, m);
        r.tag = 1, r.payload = U, S !== void 0 && S !== null && (r.callback = S), U = YD(w, r, m), U !== null && (x8(U, w, m, g), Dq(U, w, m))
      },
      enqueueForceUpdate: function(w, U) {
        w = w._reactInternals;
        var S = zQ(),
          g = cW(w),
          m = iQ(S, g);
        m.tag = 2, U !== void 0 && U !== null && (m.callback = U), U = YD(w, m, g), U !== null && (x8(U, w, g, S), Dq(U, w, g))
      }
    };

    function WH(w, U, S, g, m, r, j1) {
      return w = w.stateNode, typeof w.shouldComponentUpdate === "function" ? w.shouldComponentUpdate(g, r, j1) : U.prototype && U.prototype.isPureReactComponent ? !sI(S, g) || !sI(m, r) : !0
    }

    function gW(w, U, S) {
      var g = !1,
        m = W2,
        r = U.contextType;
      return typeof r === "object" && r !== null ? r = R7(r) : (m = _1(U) ? V1 : c0.current, g = U.contextTypes, r = (g = g !== null && g !== void 0) ? c1(w, m) : W2), U = new U(S, r), w.memoizedState = U.state !== null && U.state !== void 0 ? U.state : null, U.updater = UF, w.stateNode = U, U._reactInternals = w, g && (w = w.stateNode, w.__reactInternalMemoizedUnmaskedChildContext = m, w.__reactInternalMemoizedMaskedChildContext = r), U
    }

    function ST(w, U, S, g) {
      w = U.state, typeof U.componentWillReceiveProps === "function" && U.componentWillReceiveProps(S, g), typeof U.UNSAFE_componentWillReceiveProps === "function" && U.UNSAFE_componentWillReceiveProps(S, g), U.state !== w && UF.enqueueReplaceState(U, U.state, null)
    }

    function pE(w, U, S, g) {
      var m = w.stateNode;
      m.props = S, m.state = w.memoizedState, m.refs = {}, QY(w);
      var r = U.contextType;
      typeof r === "object" && r !== null ? m.context = R7(r) : (r = _1(U) ? V1 : c0.current, m.context = c1(w, r)), m.state = w.memoizedState, r = U.getDerivedStateFromProps, typeof r === "function" && (EF(w, U, r, S), m.state = w.memoizedState), typeof U.getDerivedStateFromProps === "function" || typeof m.getSnapshotBeforeUpdate === "function" || typeof m.UNSAFE_componentWillMount !== "function" && typeof m.componentWillMount !== "function" || (U = m.state, typeof m.componentWillMount === "function" && m.componentWillMount(), typeof m.UNSAFE_componentWillMount === "function" && m.UNSAFE_componentWillMount(), U !== m.state && UF.enqueueReplaceState(m, m.state, null), IH(w, S, m, g), m.state = w.memoizedState), typeof m.componentDidMount === "function" && (w.flags |= 4194308)
    }

    function kV(w, U) {
      try {
        var S = "",
          g = U;
        do S += BY(g), g = g.return; while (g);
        var m = S
      } catch (r) {
        m = `
Error generating stack: ` + r.message + `
` + r.stack
      }
      return {
        value: w,
        source: U,
        stack: m,
        digest: null
      }
    }

    function cE(w, U, S) {
      return {
        value: w,
        source: null,
        stack: S != null ? S : null,
        digest: U != null ? U : null
      }
    }

    function GY(w, U) {
      try {
        console.error(U.value)
      } catch (S) {
        setTimeout(function() {
          throw S
        })
      }
    }
    var Vq = typeof WeakMap === "function" ? WeakMap : Map;

    function JH(w, U, S) {
      S = iQ(-1, S), S.tag = 3, S.payload = {
        element: null
      };
      var g = U.value;
      return S.callback = function() {
        bV || (bV = !0, HQ = g), GY(w, U)
      }, S
    }

    function _T(w, U, S) {
      S = iQ(-1, S), S.tag = 3;
      var g = w.type.getDerivedStateFromError;
      if (typeof g === "function") {
        var m = U.value;
        S.payload = function() {
          return g(m)
        }, S.callback = function() {
          GY(w, U)
        }
      }
      var r = w.stateNode;
      return r !== null && typeof r.componentDidCatch === "function" && (S.callback = function() {
        GY(w, U), typeof g !== "function" && (FY === null ? FY = new Set([this]) : FY.add(this));
        var j1 = U.stack;
        this.componentDidCatch(U.value, {
          componentStack: j1 !== null ? j1 : ""
        })
      }), S
    }

    function z1(w, U, S) {
      var g = w.pingCache;
      if (g === null) {
        g = w.pingCache = new Vq;
        var m = new Set;
        g.set(U, m)
      } else m = g.get(U), m === void 0 && (m = new Set, g.set(U, m));
      m.has(S) || (m.add(S), w = Wk.bind(null, w, U, S), U.then(w, w))
    }

    function hW(w) {
      do {
        var U;
        if (U = w.tag === 13) U = w.memoizedState, U = U !== null ? U.dehydrated !== null ? !0 : !1 : !0;
        if (U) return w;
        w = w.return
      } while (w !== null);
      return null
    }

    function NF(w, U, S, g, m) {
      if ((w.mode & 1) === 0) return w === U ? w.flags |= 65536 : (w.flags |= 128, S.flags |= 131072, S.flags &= -52805, S.tag === 1 && (S.alternate === null ? S.tag = 17 : (U = iQ(-1, 1), U.tag = 2, YD(S, U, 1))), S.lanes |= 1), w;
      return w.flags |= 65536, w.lanes = m, w
    }
    var QZ = Z.ReactCurrentOwner,
      U9 = !1;

    function vB(w, U, S, g) {
      U.child = w === null ? v0(U, null, S, g) : vA(U, w.child, S, g)
    }

    function iy(w, U, S, g, m) {
      S = S.render;
      var r = U.ref;
      if (oI(U, m), g = vE(w, U, S, g, r, m), S = _V(), w !== null && !U9) return U.updateQueue = w.updateQueue, U.flags &= -2053, w.lanes &= ~m, x3(w, U, m);
      return k5 && S && J5(U), U.flags |= 1, vB(w, U, g, m), U.child
    }

    function ny(w, U, S, g, m) {
      if (w === null) {
        var r = S.type;
        if (typeof r === "function" && !Oq(r) && r.defaultProps === void 0 && S.compare === null && S.defaultProps === void 0) return U.tag = 15, U.type = r, eI(w, U, r, g, m);
        return w = LF(S.type, null, g, U, U.mode, m), w.ref = U.ref, w.return = U, U.child = w
      }
      if (r = w.child, (w.lanes & m) === 0) {
        var j1 = r.memoizedProps;
        if (S = S.compare, S = S !== null ? S : sI, S(j1, g) && w.ref === U.ref) return x3(w, U, m)
      }
      return U.flags |= 1, w = CD(r, g), w.ref = U.ref, w.return = U, U.child = w
    }

    function eI(w, U, S, g, m) {
      if (w !== null) {
        var r = w.memoizedProps;
        if (sI(r, g) && w.ref === U.ref)
          if (U9 = !1, U.pendingProps = g = r, (w.lanes & m) !== 0)(w.flags & 131072) !== 0 && (U9 = !0);
          else return U.lanes = w.lanes, x3(w, U, m)
      }
      return Cq(w, U, S, g, m)
    }

    function ay(w, U, S) {
      var g = U.pendingProps,
        m = g.children,
        r = w !== null ? w.memoizedState : null;
      if (g.mode === "hidden")
        if ((U.mode & 1) === 0) U.memoizedState = {
          baseLanes: 0,
          cachePool: null,
          transitions: null
        }, uA($F, T7), T7 |= S;
        else {
          if ((S & 1073741824) === 0) return w = r !== null ? r.baseLanes | S : S, U.lanes = U.childLanes = 1073741824, U.memoizedState = {
            baseLanes: w,
            cachePool: null,
            transitions: null
          }, U.updateQueue = null, uA($F, T7), T7 |= w, null;
          U.memoizedState = {
            baseLanes: 0,
            cachePool: null,
            transitions: null
          }, g = r !== null ? r.baseLanes : S, uA($F, T7), T7 |= g
        }
      else r !== null ? (g = r.baseLanes | S, U.memoizedState = null) : g = S, uA($F, T7), T7 |= g;
      return vB(w, U, m, S), U.child
    }

    function sy(w, U) {
      var S = U.ref;
      if (w === null && S !== null || w !== null && w.ref !== S) U.flags |= 512, U.flags |= 2097152
    }

    function Cq(w, U, S, g, m) {
      var r = _1(S) ? V1 : c0.current;
      if (r = c1(U, r), oI(U, m), S = vE(w, U, S, g, r, m), g = _V(), w !== null && !U9) return U.updateQueue = w.updateQueue, U.flags &= -2053, w.lanes &= ~m, x3(w, U, m);
      return k5 && g && J5(U), U.flags |= 1, vB(w, U, S, m), U.child
    }

    function lE(w, U, S, g, m) {
      if (_1(S)) {
        var r = !0;
        xA(U)
      } else r = !1;
      if (oI(U, m), U.stateNode === null) Kq(w, U), gW(U, S, g), pE(U, S, g, m), g = !0;
      else if (w === null) {
        var {
          stateNode: j1,
          memoizedProps: CA
        } = U;
        j1.props = CA;
        var kA = j1.context,
          F0 = S.contextType;
        typeof F0 === "object" && F0 !== null ? F0 = R7(F0) : (F0 = _1(S) ? V1 : c0.current, F0 = c1(U, F0));
        var h0 = S.getDerivedStateFromProps,
          i2 = typeof h0 === "function" || typeof j1.getSnapshotBeforeUpdate === "function";
        i2 || typeof j1.UNSAFE_componentWillReceiveProps !== "function" && typeof j1.componentWillReceiveProps !== "function" || (CA !== g || kA !== F0) && ST(U, j1, g, F0), TV = !1;
        var n0 = U.memoizedState;
        j1.state = n0, IH(U, g, j1, m), kA = U.memoizedState, CA !== g || n0 !== kA || z2.current || TV ? (typeof h0 === "function" && (EF(U, S, h0, g), kA = U.memoizedState), (CA = TV || WH(U, S, CA, g, n0, kA, F0)) ? (i2 || typeof j1.UNSAFE_componentWillMount !== "function" && typeof j1.componentWillMount !== "function" || (typeof j1.componentWillMount === "function" && j1.componentWillMount(), typeof j1.UNSAFE_componentWillMount === "function" && j1.UNSAFE_componentWillMount()), typeof j1.componentDidMount === "function" && (U.flags |= 4194308)) : (typeof j1.componentDidMount === "function" && (U.flags |= 4194308), U.memoizedProps = g, U.memoizedState = kA), j1.props = g, j1.state = kA, j1.context = F0, g = CA) : (typeof j1.componentDidMount === "function" && (U.flags |= 4194308), g = !1)
      } else {
        j1 = U.stateNode, kE(w, U), CA = U.memoizedProps, F0 = U.type === U.elementType ? CA : VQ(U.type, CA), j1.props = F0, i2 = U.pendingProps, n0 = j1.context, kA = S.contextType, typeof kA === "object" && kA !== null ? kA = R7(kA) : (kA = _1(S) ? V1 : c0.current, kA = c1(U, kA));
        var l5 = S.getDerivedStateFromProps;
        (h0 = typeof l5 === "function" || typeof j1.getSnapshotBeforeUpdate === "function") || typeof j1.UNSAFE_componentWillReceiveProps !== "function" && typeof j1.componentWillReceiveProps !== "function" || (CA !== i2 || n0 !== kA) && ST(U, j1, g, kA), TV = !1, n0 = U.memoizedState, j1.state = n0, IH(U, g, j1, m);
        var x5 = U.memoizedState;
        CA !== i2 || n0 !== x5 || z2.current || TV ? (typeof l5 === "function" && (EF(U, S, l5, g), x5 = U.memoizedState), (F0 = TV || WH(U, S, F0, g, n0, x5, kA) || !1) ? (h0 || typeof j1.UNSAFE_componentWillUpdate !== "function" && typeof j1.componentWillUpdate !== "function" || (typeof j1.componentWillUpdate === "function" && j1.componentWillUpdate(g, x5, kA), typeof j1.UNSAFE_componentWillUpdate === "function" && j1.UNSAFE_componentWillUpdate(g, x5, kA)), typeof j1.componentDidUpdate === "function" && (U.flags |= 4), typeof j1.getSnapshotBeforeUpdate === "function" && (U.flags |= 1024)) : (typeof j1.componentDidUpdate !== "function" || CA === w.memoizedProps && n0 === w.memoizedState || (U.flags |= 4), typeof j1.getSnapshotBeforeUpdate !== "function" || CA === w.memoizedProps && n0 === w.memoizedState || (U.flags |= 1024), U.memoizedProps = g, U.memoizedState = x5), j1.props = g, j1.state = x5, j1.context = kA, g = F0) : (typeof j1.componentDidUpdate !== "function" || CA === w.memoizedProps && n0 === w.memoizedState || (U.flags |= 4), typeof j1.getSnapshotBeforeUpdate !== "function" || CA === w.memoizedProps && n0 === w.memoizedState || (U.flags |= 1024), g = !1)
      }
      return jT(w, U, S, g, r, m)
    }

    function jT(w, U, S, g, m, r) {
      sy(w, U);
      var j1 = (U.flags & 128) !== 0;
      if (!g && !j1) return m && oA(U, S, !1), x3(w, U, r);
      g = U.stateNode, QZ.current = U;
      var CA = j1 && typeof S.getDerivedStateFromError !== "function" ? null : g.render();
      return U.flags |= 1, w !== null && j1 ? (U.child = vA(U, w.child, null, r), U.child = vA(U, null, CA, r)) : vB(w, U, CA, r), U.memoizedState = g.state, m && oA(U, S, !0), U.child
    }

    function XD(w) {
      var U = w.stateNode;
      U.pendingContext ? DA(w, U.pendingContext, U.pendingContext !== U.context) : U.context && DA(w, U.context, !1), GH(w, U.containerInfo)
    }

    function yT(w, U, S, g, m) {
      return DD(), QH(m), U.flags |= 256, vB(w, U, S, g), U.child
    }
    var IZ = {
      dehydrated: null,
      treeContext: null,
      retryLane: 0
    };

    function kT(w) {
      return {
        baseLanes: w,
        cachePool: null,
        transitions: null
      }
    }

    function ry(w, U, S) {
      var g = U.pendingProps,
        m = k8.current,
        r = !1,
        j1 = (U.flags & 128) !== 0,
        CA;
      if ((CA = j1) || (CA = w !== null && w.memoizedState === null ? !1 : (m & 2) !== 0), CA) r = !0, U.flags &= -129;
      else if (w === null || w.memoizedState !== null) m |= 1;
      if (uA(k8, m & 1), w === null) {
        if (L7(U), w = U.memoizedState, w !== null && (w = w.dehydrated, w !== null)) return (U.mode & 1) === 0 ? U.lanes = 1 : q7(w) ? U.lanes = 8 : U.lanes = 1073741824, null;
        return j1 = g.children, w = g.fallback, r ? (g = U.mode, r = U.child, j1 = {
          mode: "hidden",
          children: j1
        }, (g & 1) === 0 && r !== null ? (r.childLanes = 0, r.pendingProps = j1) : r = IU(j1, g, 0, null), w = RF(w, g, S, null), r.return = U, w.return = U, r.sibling = w, U.child = r, U.child.memoizedState = kT(S), U.memoizedState = IZ, w) : xT(U, j1)
      }
      if (m = w.memoizedState, m !== null && (CA = m.dehydrated, CA !== null)) return kp(w, U, j1, g, CA, m, S);
      if (r) {
        r = g.fallback, j1 = U.mode, m = w.child, CA = m.sibling;
        var kA = {
          mode: "hidden",
          children: g.children
        };
        return (j1 & 1) === 0 && U.child !== m ? (g = U.child, g.childLanes = 0, g.pendingProps = kA, U.deletions = null) : (g = CD(m, kA), g.subtreeFlags = m.subtreeFlags & 14680064), CA !== null ? r = CD(CA, r) : (r = RF(r, j1, S, null), r.flags |= 2), r.return = U, g.return = U, g.sibling = r, U.child = g, g = r, r = U.child, j1 = w.child.memoizedState, j1 = j1 === null ? kT(S) : {
          baseLanes: j1.baseLanes | S,
          cachePool: null,
          transitions: j1.transitions
        }, r.memoizedState = j1, r.childLanes = w.childLanes & ~S, U.memoizedState = IZ, g
      }
      return r = w.child, w = r.sibling, g = CD(r, {
        mode: "visible",
        children: g.children
      }), (U.mode & 1) === 0 && (g.lanes = S), g.return = U, g.sibling = null, w !== null && (S = U.deletions, S === null ? (U.deletions = [w], U.flags |= 16) : S.push(w)), U.child = g, U.memoizedState = null, g
    }

    function xT(w, U) {
      return U = IU({
        mode: "visible",
        children: U
      }, w.mode, 0, null), U.return = w, w.child = U
    }

    function AG(w, U, S, g) {
      return g !== null && QH(g), vA(U, w.child, null, S), w = xT(U, U.pendingProps.children), w.flags |= 2, U.memoizedState = null, w
    }

    function kp(w, U, S, g, m, r, j1) {
      if (S) {
        if (U.flags & 256) return U.flags &= -257, g = cE(Error(G(422))), AG(w, U, j1, g);
        if (U.memoizedState !== null) return U.child = w.child, U.flags |= 128, null;
        return r = g.fallback, m = U.mode, g = IU({
          mode: "visible",
          children: g.children
        }, m, 0, null), r = RF(r, m, j1, null), r.flags |= 2, g.return = U, r.return = U, g.sibling = r, U.child = g, (U.mode & 1) !== 0 && vA(U, w.child, null, j1), U.child.memoizedState = kT(j1), U.memoizedState = IZ, r
      }
      if ((U.mode & 1) === 0) return AG(w, U, j1, null);
      if (q7(m)) return g = V3(m).digest, r = Error(G(419)), g = cE(r, g, void 0), AG(w, U, j1, g);
      if (S = (j1 & w.childLanes) !== 0, U9 || S) {
        if (g = b3, g !== null) {
          switch (j1 & -j1) {
            case 4:
              m = 2;
              break;
            case 16:
              m = 8;
              break;
            case 64:
            case 128:
            case 256:
            case 512:
            case 1024:
            case 2048:
            case 4096:
            case 8192:
            case 16384:
            case 32768:
            case 65536:
            case 131072:
            case 262144:
            case 524288:
            case 1048576:
            case 2097152:
            case 4194304:
            case 8388608:
            case 16777216:
            case 33554432:
            case 67108864:
              m = 32;
              break;
            case 536870912:
              m = 268435456;
              break;
            default:
              m = 0
          }
          m = (m & (g.suspendedLanes | j1)) !== 0 ? 0 : m, m !== 0 && m !== r.retryLane && (r.retryLane = m, xW(w, m), x8(g, w, m, -1))
        }
        return pT(), g = cE(Error(G(421))), AG(w, U, j1, g)
      }
      if (X3(m)) return U.flags |= 128, U.child = w.child, U = Jk.bind(null, w), H2(m, U), null;
      return w = r.treeContext, W1 && (Q8 = y3(m), P6 = U, k5 = !0, kB = null, lQ = !1, w !== null && (y5[n6++] = EB, y5[n6++] = yB, y5[n6++] = tG, EB = w.id, yB = w.overflow, tG = U)), U = xT(U, g.children), U.flags |= 4096, U
    }

    function oy(w, U, S) {
      w.lanes |= U;
      var g = w.alternate;
      g !== null && (g.lanes |= U), FQ(w.return, U, S)
    }

    function fT(w, U, S, g, m) {
      var r = w.memoizedState;
      r === null ? w.memoizedState = {
        isBackwards: U,
        rendering: null,
        renderingStartTime: 0,
        last: g,
        tail: S,
        tailMode: m
      } : (r.isBackwards = U, r.rendering = null, r.renderingStartTime = 0, r.last = g, r.tail = S, r.tailMode = m)
    }

    function ty(w, U, S) {
      var g = U.pendingProps,
        m = g.revealOrder,
        r = g.tail;
      if (vB(w, U, g.children, S), g = k8.current, (g & 2) !== 0) g = g & 1 | 2, U.flags |= 128;
      else {
        if (w !== null && (w.flags & 128) !== 0) A: for (w = U.child; w !== null;) {
          if (w.tag === 13) w.memoizedState !== null && oy(w, S, U);
          else if (w.tag === 19) oy(w, S, U);
          else if (w.child !== null) {
            w.child.return = w, w = w.child;
            continue
          }
          if (w === U) break A;
          for (; w.sibling === null;) {
            if (w.return === null || w.return === U) break A;
            w = w.return
          }
          w.sibling.return = w.return, w = w.sibling
        }
        g &= 1
      }
      if (uA(k8, g), (U.mode & 1) === 0) U.memoizedState = null;
      else switch (m) {
        case "forwards":
          S = U.child;
          for (m = null; S !== null;) w = S.alternate, w !== null && AZ(w) === null && (m = S), S = S.sibling;
          S = m, S === null ? (m = U.child, U.child = null) : (m = S.sibling, S.sibling = null), fT(U, !1, m, S, r);
          break;
        case "backwards":
          S = null, m = U.child;
          for (U.child = null; m !== null;) {
            if (w = m.alternate, w !== null && AZ(w) === null) {
              U.child = m;
              break
            }
            w = m.sibling, m.sibling = S, S = m, m = w
          }
          fT(U, !0, S, null, r);
          break;
        case "together":
          fT(U, !1, null, null, void 0);
          break;
        default:
          U.memoizedState = null
      }
      return U.child
    }

    function Kq(w, U) {
      (U.mode & 1) === 0 && w !== null && (w.alternate = null, U.alternate = null, U.flags |= 2)
    }

    function x3(w, U, S) {
      if (w !== null && (U.dependencies = w.dependencies), vV |= U.lanes, (S & U.childLanes) === 0) return null;
      if (w !== null && U.child !== w.child) throw Error(G(153));
      if (U.child !== null) {
        w = U.child, S = CD(w, w.pendingProps), U.child = S;
        for (S.return = U; w.sibling !== null;) w = w.sibling, S = S.sibling = CD(w, w.pendingProps), S.return = U;
        S.sibling = null
      }
      return U.child
    }

    function ey(w, U, S) {
      switch (U.tag) {
        case 3:
          XD(U), DD();
          break;
        case 5:
          fE(U);
          break;
        case 1:
          _1(U.type) && xA(U);
          break;
        case 4:
          GH(U, U.stateNode.containerInfo);
          break;
        case 10:
          F5(U, U.type._context, U.memoizedProps.value);
          break;
        case 13:
          var g = U.memoizedState;
          if (g !== null) {
            if (g.dehydrated !== null) return uA(k8, k8.current & 1), U.flags |= 128, null;
            if ((S & U.child.childLanes) !== 0) return ry(w, U, S);
            return uA(k8, k8.current & 1), w = x3(w, U, S), w !== null ? w.sibling : null
          }
          uA(k8, k8.current & 1);
          break;
        case 19:
          if (g = (S & U.childLanes) !== 0, (w.flags & 128) !== 0) {
            if (g) return ty(w, U, S);
            U.flags |= 128
          }
          var m = U.memoizedState;
          if (m !== null && (m.rendering = null, m.tail = null, m.lastEffect = null), uA(k8, k8.current), g) break;
          else return null;
        case 22:
        case 23:
          return U.lanes = 0, ay(w, U, S)
      }
      return x3(w, U, S)
    }

    function ZY(w) {
      w.flags |= 4
    }

    function GZ(w, U) {
      if (w !== null && w.child === U.child) return !0;
      if ((U.flags & 16) !== 0) return !1;
      for (w = U.child; w !== null;) {
        if ((w.flags & 12854) !== 0 || (w.subtreeFlags & 12854) !== 0) return !1;
        w = w.sibling
      }
      return !0
    }
    var FH, DY, xV, mW;
    if (t) FH = function(w, U) {
      for (var S = U.child; S !== null;) {
        if (S.tag === 5 || S.tag === 6) bA(w, S.stateNode);
        else if (S.tag !== 4 && S.child !== null) {
          S.child.return = S, S = S.child;
          continue
        }
        if (S === U) break;
        for (; S.sibling === null;) {
          if (S.return === null || S.return === U) return;
          S = S.return
        }
        S.sibling.return = S.return, S = S.sibling
      }
    }, DY = function() {}, xV = function(w, U, S, g, m) {
      if (w = w.memoizedProps, w !== g) {
        var r = U.stateNode,
          j1 = xB(WD.current);
        S = k1(r, S, w, g, m, j1), (U.updateQueue = S) && ZY(U)
      }
    }, mW = function(w, U, S, g) {
      S !== g && ZY(U)
    };
    else if (B1) {
      FH = function(w, U, S, g) {
        for (var m = U.child; m !== null;) {
          if (m.tag === 5) {
            var r = m.stateNode;
            S && g && (r = L9(r, m.type, m.memoizedProps, m)), bA(w, r)
          } else if (m.tag === 6) r = m.stateNode, S && g && (r = w5(r, m.memoizedProps, m)), bA(w, r);
          else if (m.tag !== 4) {
            if (m.tag === 22 && m.memoizedState !== null) r = m.child, r !== null && (r.return = m), FH(w, m, !0, !0);
            else if (m.child !== null) {
              m.child.return = m, m = m.child;
              continue
            }
          }
          if (m === U) break;
          for (; m.sibling === null;) {
            if (m.return === null || m.return === U) return;
            m = m.return
          }
          m.sibling.return = m.return, m = m.sibling
        }
      };
      var Hq = function(w, U, S, g) {
        for (var m = U.child; m !== null;) {
          if (m.tag === 5) {
            var r = m.stateNode;
            S && g && (r = L9(r, m.type, m.memoizedProps, m)), uQ(w, r)
          } else if (m.tag === 6) r = m.stateNode, S && g && (r = w5(r, m.memoizedProps, m)), uQ(w, r);
          else if (m.tag !== 4) {
            if (m.tag === 22 && m.memoizedState !== null) r = m.child, r !== null && (r.return = m), Hq(w, m, !0, !0);
            else if (m.child !== null) {
              m.child.return = m, m = m.child;
              continue
            }
          }
          if (m === U) break;
          for (; m.sibling === null;) {
            if (m.return === null || m.return === U) return;
            m = m.return
          }
          m.sibling.return = m.return, m = m.sibling
        }
      };
      DY = function(w, U) {
        var S = U.stateNode;
        if (!GZ(w, U)) {
          w = S.containerInfo;
          var g = J3(w);
          Hq(g, U, !1, !1), S.pendingChildren = g, ZY(U), x0(w, g)
        }
      }, xV = function(w, U, S, g, m) {
        var {
          stateNode: r,
          memoizedProps: j1
        } = w;
        if ((w = GZ(w, U)) && j1 === g) U.stateNode = r;
        else {
          var CA = U.stateNode,
            kA = xB(WD.current),
            F0 = null;
          j1 !== g && (F0 = k1(CA, S, j1, g, m, kA)), w && F0 === null ? U.stateNode = r : (r = v6(r, F0, S, j1, g, U, w, CA), e1(r, S, g, m, kA) && ZY(U), U.stateNode = r, w ? ZY(U) : FH(r, U, !1, !1))
        }
      }, mW = function(w, U, S, g) {
        S !== g ? (w = xB(O7.current), S = xB(WD.current), U.stateNode = v1(g, w, S, U), ZY(U)) : U.stateNode = w.stateNode
      }
    } else DY = function() {}, xV = function() {}, mW = function() {};

    function BG(w, U) {
      if (!k5) switch (w.tailMode) {
        case "hidden":
          U = w.tail;
          for (var S = null; U !== null;) U.alternate !== null && (S = U), U = U.sibling;
          S === null ? w.tail = null : S.sibling = null;
          break;
        case "collapsed":
          S = w.tail;
          for (var g = null; S !== null;) S.alternate !== null && (g = S), S = S.sibling;
          g === null ? U || w.tail === null ? w.tail = null : w.tail.sibling = null : g.sibling = null
      }
    }

    function CQ(w) {
      var U = w.alternate !== null && w.alternate.child === w.child,
        S = 0,
        g = 0;
      if (U)
        for (var m = w.child; m !== null;) S |= m.lanes | m.childLanes, g |= m.subtreeFlags & 14680064, g |= m.flags & 14680064, m.return = w, m = m.sibling;
      else
        for (m = w.child; m !== null;) S |= m.lanes | m.childLanes, g |= m.subtreeFlags, g |= m.flags, m.return = w, m = m.sibling;
      return w.subtreeFlags |= g, w.childLanes = S, U
    }

    function xp(w, U, S) {
      var g = U.pendingProps;
      switch (Z9(U), U.tag) {
        case 2:
        case 16:
        case 15:
        case 0:
        case 11:
        case 7:
        case 8:
        case 12:
        case 9:
        case 14:
          return CQ(U), null;
        case 1:
          return _1(U.type) && t1(), CQ(U), null;
        case 3:
          if (S = U.stateNode, fW(), SA(z2), SA(c0), gA(), S.pendingContext && (S.context = S.pendingContext, S.pendingContext = null), w === null || w.child === null) K3(U) ? ZY(U) : w === null || w.memoizedState.isDehydrated && (U.flags & 256) === 0 || (U.flags |= 1024, kB !== null && (Lq(kB), kB = null));
          return DY(w, U), CQ(U), null;
        case 5:
          Yq(U), S = xB(O7.current);
          var m = U.type;
          if (w !== null && U.stateNode != null) xV(w, U, m, g, S), w.ref !== U.ref && (U.flags |= 512, U.flags |= 2097152);
          else {
            if (!g) {
              if (U.stateNode === null) throw Error(G(166));
              return CQ(U), null
            }
            if (w = xB(WD.current), K3(U)) {
              if (!W1) throw Error(G(175));
              w = WQ(U.stateNode, U.type, U.memoizedProps, S, w, U, !lQ), U.updateQueue = w, w !== null && ZY(U)
            } else {
              var r = YA(m, g, S, w, U);
              FH(r, U, !1, !1), U.stateNode = r, e1(r, m, g, S, w) && ZY(U)
            }
            U.ref !== null && (U.flags |= 512, U.flags |= 2097152)
          }
          return CQ(U), null;
        case 6:
          if (w && U.stateNode != null) mW(w, U, w.memoizedProps, g);
          else {
            if (typeof g !== "string" && U.stateNode === null) throw Error(G(166));
            if (w = xB(O7.current), S = xB(WD.current), K3(U)) {
              if (!W1) throw Error(G(176));
              if (w = U.stateNode, S = U.memoizedProps, g = nI(w, S, U, !lQ)) {
                if (m = P6, m !== null) switch (m.tag) {
                  case 3:
                    e7(m.stateNode.containerInfo, w, S, (m.mode & 1) !== 0);
                    break;
                  case 5:
                    S1(m.type, m.memoizedProps, m.stateNode, w, S, (m.mode & 1) !== 0)
                }
              }
              g && ZY(U)
            } else U.stateNode = v1(g, w, S, U)
          }
          return CQ(U), null;
        case 13:
          if (SA(k8), g = U.memoizedState, w === null || w.memoizedState !== null && w.memoizedState.dehydrated !== null) {
            if (k5 && Q8 !== null && (U.mode & 1) !== 0 && (U.flags & 128) === 0) BH(), DD(), U.flags |= 98560, m = !1;
            else if (m = K3(U), g !== null && g.dehydrated !== null) {
              if (w === null) {
                if (!m) throw Error(G(318));
                if (!W1) throw Error(G(344));
                if (m = U.memoizedState, m = m !== null ? m.dehydrated : null, !m) throw Error(G(317));
                AD(m, U)
              } else DD(), (U.flags & 128) === 0 && (U.memoizedState = null), U.flags |= 4;
              CQ(U), m = !1
            } else kB !== null && (Lq(kB), kB = null), m = !0;
            if (!m) return U.flags & 65536 ? U : null
          }
          if ((U.flags & 128) !== 0) return U.lanes = S, U;
          return S = g !== null, S !== (w !== null && w.memoizedState !== null) && S && (U.child.flags |= 8192, (U.mode & 1) !== 0 && (w === null || (k8.current & 1) !== 0 ? r8 === 0 && (r8 = 3) : pT())), U.updateQueue !== null && (U.flags |= 4), CQ(U), null;
        case 4:
          return fW(), DY(w, U), w === null && P1(U.stateNode.containerInfo), CQ(U), null;
        case 10:
          return rI(U.type._context), CQ(U), null;
        case 17:
          return _1(U.type) && t1(), CQ(U), null;
        case 19:
          if (SA(k8), m = U.memoizedState, m === null) return CQ(U), null;
          if (g = (U.flags & 128) !== 0, r = m.rendering, r === null)
            if (g) BG(m, !1);
            else {
              if (r8 !== 0 || w !== null && (w.flags & 128) !== 0)
                for (w = U.child; w !== null;) {
                  if (r = AZ(w), r !== null) {
                    U.flags |= 128, BG(m, !1), w = r.updateQueue, w !== null && (U.updateQueue = w, U.flags |= 4), U.subtreeFlags = 0, w = S;
                    for (S = U.child; S !== null;) g = S, m = w, g.flags &= 14680066, r = g.alternate, r === null ? (g.childLanes = 0, g.lanes = m, g.child = null, g.subtreeFlags = 0, g.memoizedProps = null, g.memoizedState = null, g.updateQueue = null, g.dependencies = null, g.stateNode = null) : (g.childLanes = r.childLanes, g.lanes = r.lanes, g.child = r.child, g.subtreeFlags = 0, g.deletions = null, g.memoizedProps = r.memoizedProps, g.memoizedState = r.memoizedState, g.updateQueue = r.updateQueue, g.type = r.type, m = r.dependencies, g.dependencies = m === null ? null : {
                      lanes: m.lanes,
                      firstContext: m.firstContext
                    }), S = S.sibling;
                    return uA(k8, k8.current & 1 | 2), U.child
                  }
                  w = w.sibling
                }
              m.tail !== null && wB() > qq && (U.flags |= 128, g = !0, BG(m, !1), U.lanes = 4194304)
            }
          else {
            if (!g)
              if (w = AZ(r), w !== null) {
                if (U.flags |= 128, g = !0, w = w.updateQueue, w !== null && (U.updateQueue = w, U.flags |= 4), BG(m, !0), m.tail === null && m.tailMode === "hidden" && !r.alternate && !k5) return CQ(U), null
              } else 2 * wB() - m.renderingStartTime > qq && S !== 1073741824 && (U.flags |= 128, g = !0, BG(m, !1), U.lanes = 4194304);
            m.isBackwards ? (r.sibling = U.child, U.child = r) : (w = m.last, w !== null ? w.sibling = r : U.child = r, m.last = r)
          }
          if (m.tail !== null) return U = m.tail, m.rendering = U, m.tail = U.sibling, m.renderingStartTime = wB(), U.sibling = null, w = k8.current, uA(k8, g ? w & 1 | 2 : w & 1), U;
          return CQ(U), null;
        case 22:
        case 23:
          return $H(), S = U.memoizedState !== null, w !== null && w.memoizedState !== null !== S && (U.flags |= 8192), S && (U.mode & 1) !== 0 ? (T7 & 1073741824) !== 0 && (CQ(U), t && U.subtreeFlags & 6 && (U.flags |= 8192)) : CQ(U), null;
        case 24:
          return null;
        case 25:
          return null
      }
      throw Error(G(156, U.tag))
    }

    function fp(w, U) {
      switch (Z9(U), U.tag) {
        case 1:
          return _1(U.type) && t1(), w = U.flags, w & 65536 ? (U.flags = w & -65537 | 128, U) : null;
        case 3:
          return fW(), SA(z2), SA(c0), gA(), w = U.flags, (w & 65536) !== 0 && (w & 128) === 0 ? (U.flags = w & -65537 | 128, U) : null;
        case 5:
          return Yq(U), null;
        case 13:
          if (SA(k8), w = U.memoizedState, w !== null && w.dehydrated !== null) {
            if (U.alternate === null) throw Error(G(340));
            DD()
          }
          return w = U.flags, w & 65536 ? (U.flags = w & -65537 | 128, U) : null;
        case 19:
          return SA(k8), null;
        case 4:
          return fW(), null;
        case 10:
          return rI(U.type._context), null;
        case 22:
        case 23:
          return $H(), null;
        case 24:
          return null;
        default:
          return null
      }
    }
    var fV = !1,
      bB = !1,
      zq = typeof WeakSet === "function" ? WeakSet : Set,
      $2 = null;

    function dW(w, U) {
      var S = w.ref;
      if (S !== null)
        if (typeof S === "function") try {
          S(null)
        } catch (g) {
          w8(w, U, g)
        } else S.current = null
    }

    function iE(w, U, S) {
      try {
        S()
      } catch (g) {
        w8(w, U, g)
      }
    }
    var QG = !1;

    function vT(w, U) {
      u1(w.containerInfo);
      for ($2 = U; $2 !== null;)
        if (w = $2, U = w.child, (w.subtreeFlags & 1028) !== 0 && U !== null) U.return = w, $2 = U;
        else
          for (; $2 !== null;) {
            w = $2;
            try {
              var S = w.alternate;
              if ((w.flags & 1024) !== 0) switch (w.tag) {
                case 0:
                case 11:
                case 15:
                  break;
                case 1:
                  if (S !== null) {
                    var {
                      memoizedProps: g,
                      memoizedState: m
                    } = S, r = w.stateNode, j1 = r.getSnapshotBeforeUpdate(w.elementType === w.type ? g : VQ(w.type, g), m);
                    r.__reactInternalSnapshotBeforeUpdate = j1
                  }
                  break;
                case 3:
                  t && r2(w.stateNode.containerInfo);
                  break;
                case 5:
                case 6:
                case 4:
                case 17:
                  break;
                default:
                  throw Error(G(163))
              }
            } catch (CA) {
              w8(w, w.return, CA)
            }
            if (U = w.sibling, U !== null) {
              U.return = w.return, $2 = U;
              break
            }
            $2 = w.return
          }
      return S = QG, QG = !1, S
    }

    function IG(w, U, S) {
      var g = U.updateQueue;
      if (g = g !== null ? g.lastEffect : null, g !== null) {
        var m = g = g.next;
        do {
          if ((m.tag & w) === w) {
            var r = m.destroy;
            m.destroy = void 0, r !== void 0 && iE(U, S, r)
          }
          m = m.next
        } while (m !== g)
      }
    }

    function GI(w, U) {
      if (U = U.updateQueue, U = U !== null ? U.lastEffect : null, U !== null) {
        var S = U = U.next;
        do {
          if ((S.tag & w) === w) {
            var g = S.create;
            S.destroy = g()
          }
          S = S.next
        } while (S !== U)
      }
    }

    function Ak(w) {
      var U = w.ref;
      if (U !== null) {
        var S = w.stateNode;
        switch (w.tag) {
          case 5:
            w = v(S);
            break;
          default:
            w = S
        }
        typeof U === "function" ? U(w) : U.current = w
      }
    }

    function Bk(w) {
      var U = w.alternate;
      U !== null && (w.alternate = null, Bk(U)), w.child = null, w.deletions = null, w.sibling = null, w.tag === 5 && (U = w.stateNode, U !== null && y1(U)), w.stateNode = null, w.return = null, w.dependencies = null, w.memoizedProps = null, w.memoizedState = null, w.pendingProps = null, w.stateNode = null, w.updateQueue = null
    }

    function Qk(w) {
      return w.tag === 5 || w.tag === 3 || w.tag === 4
    }

    function nE(w) {
      A: for (;;) {
        for (; w.sibling === null;) {
          if (w.return === null || Qk(w.return)) return null;
          w = w.return
        }
        w.sibling.return = w.return;
        for (w = w.sibling; w.tag !== 5 && w.tag !== 6 && w.tag !== 18;) {
          if (w.flags & 2) continue A;
          if (w.child === null || w.tag === 4) continue A;
          else w.child.return = w, w = w.child
        }
        if (!(w.flags & 2)) return w.stateNode
      }
    }

    function YY(w, U, S) {
      var g = w.tag;
      if (g === 5 || g === 6) w = w.stateNode, U ? y0(S, w, U) : h2(S, w);
      else if (g !== 4 && (w = w.child, w !== null))
        for (YY(w, U, S), w = w.sibling; w !== null;) YY(w, U, S), w = w.sibling
    }

    function wq(w, U, S) {
      var g = w.tag;
      if (g === 5 || g === 6) w = w.stateNode, U ? g0(S, w, U) : q2(S, w);
      else if (g !== 4 && (w = w.child, w !== null))
        for (wq(w, U, S), w = w.sibling; w !== null;) wq(w, U, S), w = w.sibling
    }
    var nQ = null,
      GG = !1;

    function uW(w, U, S) {
      for (S = S.child; S !== null;) bT(w, U, S), S = S.sibling
    }

    function bT(w, U, S) {
      if (R4 && typeof R4.onCommitFiberUnmount === "function") try {
        R4.onCommitFiberUnmount(i6, S)
      } catch (CA) {}
      switch (S.tag) {
        case 5:
          bB || dW(S, U);
        case 6:
          if (t) {
            var g = nQ,
              m = GG;
            nQ = null, uW(w, U, S), nQ = g, GG = m, nQ !== null && (GG ? V0(nQ, S.stateNode) : T0(nQ, S.stateNode))
          } else uW(w, U, S);
          break;
        case 18:
          t && nQ !== null && (GG ? rG(nQ, S.stateNode) : cQ(nQ, S.stateNode));
          break;
        case 4:
          t ? (g = nQ, m = GG, nQ = S.stateNode.containerInfo, GG = !0, uW(w, U, S), nQ = g, GG = m) : (B1 && (g = S.stateNode.containerInfo, m = J3(g), d0(g, m)), uW(w, U, S));
          break;
        case 0:
        case 11:
        case 14:
        case 15:
          if (!bB && (g = S.updateQueue, g !== null && (g = g.lastEffect, g !== null))) {
            m = g = g.next;
            do {
              var r = m,
                j1 = r.destroy;
              r = r.tag, j1 !== void 0 && ((r & 2) !== 0 ? iE(S, U, j1) : (r & 4) !== 0 && iE(S, U, j1)), m = m.next
            } while (m !== g)
          }
          uW(w, U, S);
          break;
        case 1:
          if (!bB && (dW(S, U), g = S.stateNode, typeof g.componentWillUnmount === "function")) try {
            g.props = S.memoizedProps, g.state = S.memoizedState, g.componentWillUnmount()
          } catch (CA) {
            w8(S, U, CA)
          }
          uW(w, U, S);
          break;
        case 21:
          uW(w, U, S);
          break;
        case 22:
          S.mode & 1 ? (bB = (g = bB) || S.memoizedState !== null, uW(w, U, S), bB = g) : uW(w, U, S);
          break;
        default:
          uW(w, U, S)
      }
    }

    function f3(w) {
      var U = w.updateQueue;
      if (U !== null) {
        w.updateQueue = null;
        var S = w.stateNode;
        S === null && (S = w.stateNode = new zq), U.forEach(function(g) {
          var m = QU.bind(null, w, g);
          S.has(g) || (S.add(g), g.then(m, m))
        })
      }
    }

    function ZG(w, U) {
      var S = U.deletions;
      if (S !== null)
        for (var g = 0; g < S.length; g++) {
          var m = S[g];
          try {
            var r = w,
              j1 = U;
            if (t) {
              var CA = j1;
              A: for (; CA !== null;) {
                switch (CA.tag) {
                  case 5:
                    nQ = CA.stateNode, GG = !1;
                    break A;
                  case 3:
                    nQ = CA.stateNode.containerInfo, GG = !0;
                    break A;
                  case 4:
                    nQ = CA.stateNode.containerInfo, GG = !0;
                    break A
                }
                CA = CA.return
              }
              if (nQ === null) throw Error(G(160));
              bT(r, j1, m), nQ = null, GG = !1
            } else bT(r, j1, m);
            var kA = m.alternate;
            kA !== null && (kA.return = null), m.return = null
          } catch (F0) {
            w8(m, U, F0)
          }
        }
      if (U.subtreeFlags & 12854)
        for (U = U.child; U !== null;) Ik(U, w), U = U.sibling
    }

    function Ik(w, U) {
      var {
        alternate: S,
        flags: g
      } = w;
      switch (w.tag) {
        case 0:
        case 11:
        case 14:
        case 15:
          if (ZG(U, w), v3(w), g & 4) {
            try {
              IG(3, w, w.return), GI(3, w)
            } catch (n0) {
              w8(w, w.return, n0)
            }
            try {
              IG(5, w, w.return)
            } catch (n0) {
              w8(w, w.return, n0)
            }
          }
          break;
        case 1:
          ZG(U, w), v3(w), g & 512 && S !== null && dW(S, S.return);
          break;
        case 5:
          if (ZG(U, w), v3(w), g & 512 && S !== null && dW(S, S.return), t) {
            if (w.flags & 32) {
              var m = w.stateNode;
              try {
                N2(m)
              } catch (n0) {
                w8(w, w.return, n0)
              }
            }
            if (g & 4 && (m = w.stateNode, m != null)) {
              var r = w.memoizedProps;
              if (S = S !== null ? S.memoizedProps : r, g = w.type, U = w.updateQueue, w.updateQueue = null, U !== null) try {
                E0(m, U, g, S, r, w)
              } catch (n0) {
                w8(w, w.return, n0)
              }
            }
          }
          break;
        case 6:
          if (ZG(U, w), v3(w), g & 4 && t) {
            if (w.stateNode === null) throw Error(G(162));
            m = w.stateNode, r = w.memoizedProps, S = S !== null ? S.memoizedProps : r;
            try {
              j9(m, S, r)
            } catch (n0) {
              w8(w, w.return, n0)
            }
          }
          break;
        case 3:
          if (ZG(U, w), v3(w), g & 4) {
            if (t && W1 && S !== null && S.memoizedState.isDehydrated) try {
              pQ(U.containerInfo)
            } catch (n0) {
              w8(w, w.return, n0)
            }
            if (B1) {
              m = U.containerInfo, r = U.pendingChildren;
              try {
                d0(m, r)
              } catch (n0) {
                w8(w, w.return, n0)
              }
            }
          }
          break;
        case 4:
          if (ZG(U, w), v3(w), g & 4 && B1) {
            r = w.stateNode, m = r.containerInfo, r = r.pendingChildren;
            try {
              d0(m, r)
            } catch (n0) {
              w8(w, w.return, n0)
            }
          }
          break;
        case 13:
          ZG(U, w), v3(w), m = w.child, m.flags & 8192 && (r = m.memoizedState !== null, m.stateNode.isHidden = r, !r || m.alternate !== null && m.alternate.memoizedState !== null || (mT = wB())), g & 4 && f3(w);
          break;
        case 22:
          var j1 = S !== null && S.memoizedState !== null;
          if (w.mode & 1 ? (bB = (S = bB) || j1, ZG(U, w), bB = S) : ZG(U, w), v3(w), g & 8192) {
            if (S = w.memoizedState !== null, (w.stateNode.isHidden = S) && !j1 && (w.mode & 1) !== 0)
              for ($2 = w, g = w.child; g !== null;) {
                for (U = $2 = g; $2 !== null;) {
                  j1 = $2;
                  var CA = j1.child;
                  switch (j1.tag) {
                    case 0:
                    case 11:
                    case 14:
                    case 15:
                      IG(4, j1, j1.return);
                      break;
                    case 1:
                      dW(j1, j1.return);
                      var kA = j1.stateNode;
                      if (typeof kA.componentWillUnmount === "function") {
                        var F0 = j1,
                          h0 = j1.return;
                        try {
                          var i2 = F0;
                          kA.props = i2.memoizedProps, kA.state = i2.memoizedState, kA.componentWillUnmount()
                        } catch (n0) {
                          w8(F0, h0, n0)
                        }
                      }
                      break;
                    case 5:
                      dW(j1, j1.return);
                      break;
                    case 22:
                      if (j1.memoizedState !== null) {
                        aE(U);
                        continue
                      }
                  }
                  CA !== null ? (CA.return = j1, $2 = CA) : aE(U)
                }
                g = g.sibling
              }
            if (t) A: if (g = null, t)
              for (U = w;;) {
                if (U.tag === 5) {
                  if (g === null) {
                    g = U;
                    try {
                      m = U.stateNode, S ? h9(m) : W3(U.stateNode, U.memoizedProps)
                    } catch (n0) {
                      w8(w, w.return, n0)
                    }
                  }
                } else if (U.tag === 6) {
                  if (g === null) try {
                    r = U.stateNode, S ? z5(r) : Z6(r, U.memoizedProps)
                  } catch (n0) {
                    w8(w, w.return, n0)
                  }
                } else if ((U.tag !== 22 && U.tag !== 23 || U.memoizedState === null || U === w) && U.child !== null) {
                  U.child.return = U, U = U.child;
                  continue
                }
                if (U === w) break A;
                for (; U.sibling === null;) {
                  if (U.return === null || U.return === w) break A;
                  g === U && (g = null), U = U.return
                }
                g === U && (g = null), U.sibling.return = U.return, U = U.sibling
              }
          }
          break;
        case 19:
          ZG(U, w), v3(w), g & 4 && f3(w);
          break;
        case 21:
          break;
        default:
          ZG(U, w), v3(w)
      }
    }

    function v3(w) {
      var U = w.flags;
      if (U & 2) {
        try {
          if (t) {
            A: {
              for (var S = w.return; S !== null;) {
                if (Qk(S)) {
                  var g = S;
                  break A
                }
                S = S.return
              }
              throw Error(G(160))
            }
            switch (g.tag) {
              case 5:
                var m = g.stateNode;
                g.flags & 32 && (N2(m), g.flags &= -33);
                var r = nE(w);
                wq(w, r, m);
                break;
              case 3:
              case 4:
                var j1 = g.stateNode.containerInfo,
                  CA = nE(w);
                YY(w, CA, j1);
                break;
              default:
                throw Error(G(161))
            }
          }
        } catch (kA) {
          w8(w, w.return, kA)
        }
        w.flags &= -3
      }
      U & 4096 && (w.flags &= -4097)
    }

    function Eq(w, U, S) {
      $2 = w, XH(w, U, S)
    }

    function XH(w, U, S) {
      for (var g = (w.mode & 1) !== 0; $2 !== null;) {
        var m = $2,
          r = m.child;
        if (m.tag === 22 && g) {
          var j1 = m.memoizedState !== null || fV;
          if (!j1) {
            var CA = m.alternate,
              kA = CA !== null && CA.memoizedState !== null || bB;
            CA = fV;
            var F0 = bB;
            if (fV = j1, (bB = kA) && !F0)
              for ($2 = m; $2 !== null;) j1 = $2, kA = j1.child, j1.tag === 22 && j1.memoizedState !== null ? KQ(m) : kA !== null ? (kA.return = j1, $2 = kA) : KQ(m);
            for (; r !== null;) $2 = r, XH(r, U, S), r = r.sibling;
            $2 = m, fV = CA, bB = F0
          }
          WY(w, U, S)
        } else(m.subtreeFlags & 8772) !== 0 && r !== null ? (r.return = m, $2 = r) : WY(w, U, S)
      }
    }

    function WY(w) {
      for (; $2 !== null;) {
        var U = $2;
        if ((U.flags & 8772) !== 0) {
          var S = U.alternate;
          try {
            if ((U.flags & 8772) !== 0) switch (U.tag) {
              case 0:
              case 11:
              case 15:
                bB || GI(5, U);
                break;
              case 1:
                var g = U.stateNode;
                if (U.flags & 4 && !bB)
                  if (S === null) g.componentDidMount();
                  else {
                    var m = U.elementType === U.type ? S.memoizedProps : VQ(U.type, S.memoizedProps);
                    g.componentDidUpdate(m, S.memoizedState, g.__reactInternalSnapshotBeforeUpdate)
                  } var r = U.updateQueue;
                r !== null && jp(U, r, g);
                break;
              case 3:
                var j1 = U.updateQueue;
                if (j1 !== null) {
                  if (S = null, U.child !== null) switch (U.child.tag) {
                    case 5:
                      S = v(U.child.stateNode);
                      break;
                    case 1:
                      S = U.child.stateNode
                  }
                  jp(U, j1, S)
                }
                break;
              case 5:
                var CA = U.stateNode;
                S === null && U.flags & 4 && w6(CA, U.type, U.memoizedProps, U);
                break;
              case 6:
                break;
              case 4:
                break;
              case 12:
                break;
              case 13:
                if (W1 && U.memoizedState === null) {
                  var kA = U.alternate;
                  if (kA !== null) {
                    var F0 = kA.memoizedState;
                    if (F0 !== null) {
                      var h0 = F0.dehydrated;
                      h0 !== null && BD(h0)
                    }
                  }
                }
                break;
              case 19:
              case 17:
              case 21:
              case 22:
              case 23:
              case 25:
                break;
              default:
                throw Error(G(163))
            }
            bB || U.flags & 512 && Ak(U)
          } catch (i2) {
            w8(U, U.return, i2)
          }
        }
        if (U === w) {
          $2 = null;
          break
        }
        if (S = U.sibling, S !== null) {
          S.return = U.return, $2 = S;
          break
        }
        $2 = U.return
      }
    }

    function aE(w) {
      for (; $2 !== null;) {
        var U = $2;
        if (U === w) {
          $2 = null;
          break
        }
        var S = U.sibling;
        if (S !== null) {
          S.return = U.return, $2 = S;
          break
        }
        $2 = U.return
      }
    }

    function KQ(w) {
      for (; $2 !== null;) {
        var U = $2;
        try {
          switch (U.tag) {
            case 0:
            case 11:
            case 15:
              var S = U.return;
              try {
                GI(4, U)
              } catch (kA) {
                w8(U, S, kA)
              }
              break;
            case 1:
              var g = U.stateNode;
              if (typeof g.componentDidMount === "function") {
                var m = U.return;
                try {
                  g.componentDidMount()
                } catch (kA) {
                  w8(U, m, kA)
                }
              }
              var r = U.return;
              try {
                Ak(U)
              } catch (kA) {
                w8(U, r, kA)
              }
              break;
            case 5:
              var j1 = U.return;
              try {
                Ak(U)
              } catch (kA) {
                w8(U, j1, kA)
              }
          }
        } catch (kA) {
          w8(U, U.return, kA)
        }
        if (U === w) {
          $2 = null;
          break
        }
        var CA = U.sibling;
        if (CA !== null) {
          CA.return = U.return, $2 = CA;
          break
        }
        $2 = U.return
      }
    }
    var VH = 0,
      Uq = 1,
      CH = 2,
      KH = 3,
      sE = 4;
    if (typeof Symbol === "function" && Symbol.for) {
      var Nq = Symbol.for;
      VH = Nq("selector.component"), Uq = Nq("selector.has_pseudo_class"), CH = Nq("selector.role"), KH = Nq("selector.test_id"), sE = Nq("selector.text")
    }

    function HH(w) {
      var U = w1(w);
      if (U != null) {
        if (typeof U.memoizedProps["data-testname"] !== "string") throw Error(G(364));
        return U
      }
      if (w = QA(w), w === null) throw Error(G(362));
      return w.stateNode.current
    }

    function gT(w, U) {
      switch (U.$$typeof) {
        case VH:
          if (w.type === U.value) return !0;
          break;
        case Uq:
          A: {
            U = U.value,
            w = [w, 0];
            for (var S = 0; S < w.length;) {
              var g = w[S++],
                m = w[S++],
                r = U[m];
              if (g.tag !== 5 || !fA(g)) {
                for (; r != null && gT(g, r);) m++, r = U[m];
                if (m === U.length) {
                  U = !0;
                  break A
                } else
                  for (g = g.child; g !== null;) w.push(g, m), g = g.sibling
              }
            }
            U = !1
          }
          return U;
        case CH:
          if (w.tag === 5 && H0(w.stateNode, U.value)) return !0;
          break;
        case sE:
          if (w.tag === 5 || w.tag === 6) {
            if (w = Y0(w), w !== null && 0 <= w.indexOf(U.value)) return !0
          }
          break;
        case KH:
          if (w.tag === 5 && (w = w.memoizedProps["data-testname"], typeof w === "string" && w.toLowerCase() === U.value.toLowerCase())) return !0;
          break;
        default:
          throw Error(G(365))
      }
      return !1
    }

    function Gk(w) {
      switch (w.$$typeof) {
        case VH:
          return "<" + (L(w.value) || "Unknown") + ">";
        case Uq:
          return ":has(" + (Gk(w) || "") + ")";
        case CH:
          return '[role="' + w.value + '"]';
        case sE:
          return '"' + w.value + '"';
        case KH:
          return '[data-testname="' + w.value + '"]';
        default:
          throw Error(G(365))
      }
    }

    function Zk(w, U) {
      var S = [];
      w = [w, 0];
      for (var g = 0; g < w.length;) {
        var m = w[g++],
          r = w[g++],
          j1 = U[r];
        if (m.tag !== 5 || !fA(m)) {
          for (; j1 != null && gT(m, j1);) r++, j1 = U[r];
          if (r === U.length) S.push(m);
          else
            for (m = m.child; m !== null;) w.push(m, r), m = m.sibling
        }
      }
      return S
    }

    function zH(w, U) {
      if (!o1) throw Error(G(363));
      w = HH(w), w = Zk(w, U), U = [], w = Array.from(w);
      for (var S = 0; S < w.length;) {
        var g = w[S++];
        if (g.tag === 5) fA(g) || U.push(g.stateNode);
        else
          for (g = g.child; g !== null;) w.push(g), g = g.sibling
      }
      return U
    }
    var vp = Math.ceil,
      hT = Z.ReactCurrentDispatcher,
      rE = Z.ReactCurrentOwner,
      s8 = Z.ReactCurrentBatchConfig,
      h4 = 0,
      b3 = null,
      gB = null,
      hB = 0,
      T7 = 0,
      $F = NA(0),
      r8 = 0,
      wH = null,
      vV = 0,
      $q = 0,
      oE = 0,
      EH = null,
      ZI = null,
      mT = 0,
      qq = 1 / 0,
      JY = null;

    function tE() {
      qq = wB() + 500
    }
    var bV = !1,
      HQ = null,
      FY = null,
      qF = !1,
      VD = null,
      V4 = 0,
      UH = 0,
      Mq = null,
      pW = -1,
      NH = 0;

    function zQ() {
      return (h4 & 6) !== 0 ? wB() : pW !== -1 ? pW : pW = wB()
    }

    function cW(w) {
      if ((w.mode & 1) === 0) return 1;
      if ((h4 & 2) !== 0 && hB !== 0) return hB & -hB;
      if (Gq.transition !== null) return NH === 0 && (NH = QD()), NH;
      return w = L4, w !== 0 ? w : e()
    }

    function x8(w, U, S, g) {
      if (50 < UH) throw UH = 0, Mq = null, Error(G(185));
      if (BI(w, S, g), (h4 & 2) === 0 || w !== b3) w === b3 && ((h4 & 2) === 0 && ($q |= S), r8 === 4 && mB(w, hB)), DI(w, g), S === 1 && h4 === 0 && (U.mode & 1) === 0 && (tE(), yE && E5())
    }

    function DI(w, U) {
      var S = w.callbackNode;
      C3(w, U);
      var g = W5(w, w === b3 ? hB : 0);
      if (g === 0) S !== null && qV(S), w.callbackNode = null, w.callbackPriority = 0;
      else if (U = g & -g, w.callbackPriority !== U) {
        if (S != null && qV(S), U === 1) w.tag === 0 ? Iq(lW.bind(null, w)) : XF(lW.bind(null, w)), O1 ? h1(function() {
          (h4 & 6) === 0 && E5()
        }) : GD(AH, E5), S = null;
        else {
          switch (QI(g)) {
            case 1:
              S = AH;
              break;
            case 4:
              S = Aq;
              break;
            case 16:
              S = jE;
              break;
            case 536870912:
              S = MT;
              break;
            default:
              S = jE
          }
          S = MH(S, eE.bind(null, w))
        }
        w.callbackPriority = U, w.callbackNode = S
      }
    }

    function eE(w, U) {
      if (pW = -1, NH = 0, (h4 & 6) !== 0) throw Error(G(327));
      var S = w.callbackNode;
      if (VY() && w.callbackNode !== S) return null;
      var g = W5(w, w === b3 ? hB : 0);
      if (g === 0) return null;
      if ((g & 30) !== 0 || (g & w.expiredLanes) !== 0 || U) U = BU(w, g);
      else {
        U = g;
        var m = h4;
        h4 |= 2;
        var r = qH();
        if (b3 !== w || hB !== U) JY = null, tE(), P7(w, U);
        do try {
          MF();
          break
        } catch (CA) {
          uT(w, CA)
        }
        while (1);
        k3(), hT.current = r, h4 = m, gB !== null ? U = 0 : (b3 = null, hB = 0, U = r8)
      }
      if (U !== 0) {
        if (U === 2 && (m = AI(w), m !== 0 && (g = m, U = AU(w, m))), U === 1) throw S = wH, P7(w, 0), mB(w, g), DI(w, wB()), S;
        if (U === 6) mB(w, g);
        else {
          if (m = w.current.alternate, (g & 30) === 0 && !dT(m) && (U = BU(w, g), U === 2 && (r = AI(w), r !== 0 && (g = r, U = AU(w, r))), U === 1)) throw S = wH, P7(w, 0), mB(w, g), DI(w, wB()), S;
          switch (w.finishedWork = m, w.finishedLanes = g, U) {
            case 0:
            case 1:
              throw Error(G(345));
            case 2:
              iW(w, ZI, JY);
              break;
            case 3:
              if (mB(w, g), (g & 130023424) === g && (U = mT + 500 - wB(), 10 < U)) {
                if (W5(w, 0) !== 0) break;
                if (m = w.suspendedLanes, (m & g) !== g) {
                  zQ(), w.pingedLanes |= w.suspendedLanes & m;
                  break
                }
                w.timeoutHandle = L1(iW.bind(null, w, ZI, JY), U);
                break
              }
              iW(w, ZI, JY);
              break;
            case 4:
              if (mB(w, g), (g & 4194240) === g) break;
              U = w.eventTimes;
              for (m = -1; 0 < g;) {
                var j1 = 31 - sA(g);
                r = 1 << j1, j1 = U[j1], j1 > m && (m = j1), g &= ~r
              }
              if (g = m, g = wB() - g, g = (120 > g ? 120 : 480 > g ? 480 : 1080 > g ? 1080 : 1920 > g ? 1920 : 3000 > g ? 3000 : 4320 > g ? 4320 : 1960 * vp(g / 1960)) - g, 10 < g) {
                w.timeoutHandle = L1(iW.bind(null, w, ZI, JY), g);
                break
              }
              iW(w, ZI, JY);
              break;
            case 5:
              iW(w, ZI, JY);
              break;
            default:
              throw Error(G(329))
          }
        }
      }
      return DI(w, wB()), w.callbackNode === S ? eE.bind(null, w) : null
    }

    function AU(w, U) {
      var S = EH;
      return w.current.memoizedState.isDehydrated && (P7(w, U).flags |= 256), w = BU(w, U), w !== 2 && (U = ZI, ZI = S, U !== null && Lq(U)), w
    }

    function Lq(w) {
      ZI === null ? ZI = w : ZI.push.apply(ZI, w)
    }

    function dT(w) {
      for (var U = w;;) {
        if (U.flags & 16384) {
          var S = U.updateQueue;
          if (S !== null && (S = S.stores, S !== null))
            for (var g = 0; g < S.length; g++) {
              var m = S[g],
                r = m.getSnapshot;
              m = m.value;
              try {
                if (!jB(r(), m)) return !1
              } catch (j1) {
                return !1
              }
            }
        }
        if (S = U.child, U.subtreeFlags & 16384 && S !== null) S.return = U, U = S;
        else {
          if (U === w) break;
          for (; U.sibling === null;) {
            if (U.return === null || U.return === w) return !0;
            U = U.return
          }
          U.sibling.return = U.return, U = U.sibling
        }
      }
      return !0
    }

    function mB(w, U) {
      U &= ~oE, U &= ~$q, w.suspendedLanes |= U, w.pingedLanes &= ~U;
      for (w = w.expirationTimes; 0 < U;) {
        var S = 31 - sA(U),
          g = 1 << S;
        w[S] = -1, U &= ~g
      }
    }

    function lW(w) {
      if ((h4 & 6) !== 0) throw Error(G(327));
      VY();
      var U = W5(w, 0);
      if ((U & 1) === 0) return DI(w, wB()), null;
      var S = BU(w, U);
      if (w.tag !== 0 && S === 2) {
        var g = AI(w);
        g !== 0 && (U = g, S = AU(w, g))
      }
      if (S === 1) throw S = wH, P7(w, 0), mB(w, U), DI(w, wB()), S;
      if (S === 6) throw Error(G(345));
      return w.finishedWork = w.current.alternate, w.finishedLanes = U, iW(w, ZI, JY), DI(w, wB()), null
    }

    function gV(w) {
      VD !== null && VD.tag === 0 && (h4 & 6) === 0 && VY();
      var U = h4;
      h4 |= 1;
      var S = s8.transition,
        g = L4;
      try {
        if (s8.transition = null, L4 = 1, w) return w()
      } finally {
        L4 = g, s8.transition = S, h4 = U, (h4 & 6) === 0 && E5()
      }
    }

    function $H() {
      T7 = $F.current, SA($F)
    }

    function P7(w, U) {
      w.finishedWork = null, w.finishedLanes = 0;
      var S = w.timeoutHandle;
      if (S !== HA && (w.timeoutHandle = HA, BA(S)), gB !== null)
        for (S = gB.return; S !== null;) {
          var g = S;
          switch (Z9(g), g.tag) {
            case 1:
              g = g.type.childContextTypes, g !== null && g !== void 0 && t1();
              break;
            case 3:
              fW(), SA(z2), SA(c0), gA();
              break;
            case 5:
              Yq(g);
              break;
            case 4:
              fW();
              break;
            case 13:
              SA(k8);
              break;
            case 19:
              SA(k8);
              break;
            case 10:
              rI(g.type._context);
              break;
            case 22:
            case 23:
              $H()
          }
          S = S.return
        }
      if (b3 = w, gB = w = CD(w.current, null), hB = T7 = U, r8 = 0, wH = null, oE = $q = vV = 0, ZI = EH = null, VF !== null) {
        for (U = 0; U < VF.length; U++)
          if (S = VF[U], g = S.interleaved, g !== null) {
            S.interleaved = null;
            var m = g.next,
              r = S.pending;
            if (r !== null) {
              var j1 = r.next;
              r.next = m, g.next = j1
            }
            S.pending = g
          } VF = null
      }
      return w
    }

    function uT(w, U) {
      do {
        var S = gB;
        try {
          if (k3(), $A.current = Xq, II) {
            for (var g = E9.memoizedState; g !== null;) {
              var m = g.queue;
              m !== null && (m.pending = null), g = g.next
            }
            II = !1
          }
          if (f9 = 0, D4 = b4 = E9 = null, Y6 = !1, H3 = 0, rE.current = null, S === null || S.return === null) {
            r8 = 1, wH = U, gB = null;
            break
          }
          A: {
            var r = w,
              j1 = S.return,
              CA = S,
              kA = U;
            if (U = hB, CA.flags |= 32768, kA !== null && typeof kA === "object" && typeof kA.then === "function") {
              var F0 = kA,
                h0 = CA,
                i2 = h0.tag;
              if ((h0.mode & 1) === 0 && (i2 === 0 || i2 === 11 || i2 === 15)) {
                var n0 = h0.alternate;
                n0 ? (h0.updateQueue = n0.updateQueue, h0.memoizedState = n0.memoizedState, h0.lanes = n0.lanes) : (h0.updateQueue = null, h0.memoizedState = null)
              }
              var l5 = hW(j1);
              if (l5 !== null) {
                l5.flags &= -257, NF(l5, j1, CA, r, U), l5.mode & 1 && z1(r, F0, U), U = l5, kA = F0;
                var x5 = U.updateQueue;
                if (x5 === null) {
                  var YI = new Set;
                  YI.add(kA), U.updateQueue = YI
                } else x5.add(kA);
                break A
              } else {
                if ((U & 1) === 0) {
                  z1(r, F0, U), pT();
                  break A
                }
                kA = Error(G(426))
              }
            } else if (k5 && CA.mode & 1) {
              var wQ = hW(j1);
              if (wQ !== null) {
                (wQ.flags & 65536) === 0 && (wQ.flags |= 256), NF(wQ, j1, CA, r, U), QH(kV(kA, CA));
                break A
              }
            }
            r = kA = kV(kA, CA),
            r8 !== 4 && (r8 = 2),
            EH === null ? EH = [r] : EH.push(r),
            r = j1;do {
              switch (r.tag) {
                case 3:
                  r.flags |= 65536, U &= -U, r.lanes |= U;
                  var yA = JH(r, kA, U);
                  CF(r, yA);
                  break A;
                case 1:
                  CA = kA;
                  var {
                    type: EA, stateNode: hA
                  } = r;
                  if ((r.flags & 128) === 0 && (typeof EA.getDerivedStateFromError === "function" || hA !== null && typeof hA.componentDidCatch === "function" && (FY === null || !FY.has(hA)))) {
                    r.flags |= 65536, U &= -U, r.lanes |= U;
                    var l0 = _T(r, CA, U);
                    CF(r, l0);
                    break A
                  }
              }
              r = r.return
            } while (r !== null)
          }
          XY(S)
        } catch (t2) {
          U = t2, gB === S && S !== null && (gB = S = S.return);
          continue
        }
        break
      } while (1)
    }

    function qH() {
      var w = hT.current;
      return hT.current = Xq, w === null ? Xq : w
    }

    function pT() {
      if (r8 === 0 || r8 === 3 || r8 === 2) r8 = 4;
      b3 === null || (vV & 268435455) === 0 && ($q & 268435455) === 0 || mB(b3, hB)
    }

    function BU(w, U) {
      var S = h4;
      h4 |= 2;
      var g = qH();
      if (b3 !== w || hB !== U) JY = null, P7(w, U);
      do try {
        Rq();
        break
      } catch (m) {
        uT(w, m)
      }
      while (1);
      if (k3(), h4 = S, hT.current = g, gB !== null) throw Error(G(261));
      return b3 = null, hB = 0, r8
    }

    function Rq() {
      for (; gB !== null;) cT(gB)
    }

    function MF() {
      for (; gB !== null && !e$();) cT(gB)
    }

    function cT(w) {
      var U = iT(w.alternate, w, T7);
      w.memoizedProps = w.pendingProps, U === null ? XY(w) : gB = U, rE.current = null
    }

    function XY(w) {
      var U = w;
      do {
        var S = U.alternate;
        if (w = U.return, (U.flags & 32768) === 0) {
          if (S = xp(S, U, T7), S !== null) {
            gB = S;
            return
          }
        } else {
          if (S = fp(S, U), S !== null) {
            S.flags &= 32767, gB = S;
            return
          }
          if (w !== null) w.flags |= 32768, w.subtreeFlags = 0, w.deletions = null;
          else {
            r8 = 6, gB = null;
            return
          }
        }
        if (U = U.sibling, U !== null) {
          gB = U;
          return
        }
        gB = U = w
      } while (U !== null);
      r8 === 0 && (r8 = 5)
    }

    function iW(w, U, S) {
      var g = L4,
        m = s8.transition;
      try {
        s8.transition = null, L4 = 1, Dk(w, U, S, g)
      } finally {
        s8.transition = m, L4 = g
      }
      return null
    }

    function Dk(w, U, S, g) {
      do VY(); while (VD !== null);
      if ((h4 & 6) !== 0) throw Error(G(327));
      S = w.finishedWork;
      var m = w.finishedLanes;
      if (S === null) return null;
      if (w.finishedWork = null, w.finishedLanes = 0, S === w.current) throw Error(G(177));
      w.callbackNode = null, w.callbackPriority = 0;
      var r = S.lanes | S.childLanes;
      if (yW(w, r), w === b3 && (gB = b3 = null, hB = 0), (S.subtreeFlags & 2064) === 0 && (S.flags & 2064) === 0 || qF || (qF = !0, MH(jE, function() {
          return VY(), null
        })), r = (S.flags & 15990) !== 0, (S.subtreeFlags & 15990) !== 0 || r) {
        r = s8.transition, s8.transition = null;
        var j1 = L4;
        L4 = 1;
        var CA = h4;
        h4 |= 4, rE.current = null, vT(w, S), Ik(S, w), d1(w.containerInfo), w.current = S, Eq(S, w, m), eK(), h4 = CA, L4 = j1, s8.transition = r
      } else w.current = S;
      if (qF && (qF = !1, VD = w, V4 = m), r = w.pendingLanes, r === 0 && (FY = null), MV(S.stateNode, g), DI(w, wB()), U !== null)
        for (g = w.onRecoverableError, S = 0; S < U.length; S++) m = U[S], g(m.value, {
          componentStack: m.stack,
          digest: m.digest
        });
      if (bV) throw bV = !1, w = HQ, HQ = null, w;
      return (V4 & 1) !== 0 && w.tag !== 0 && VY(), r = w.pendingLanes, (r & 1) !== 0 ? w === Mq ? UH++ : (UH = 0, Mq = w) : UH = 0, E5(), null
    }

    function VY() {
      if (VD !== null) {
        var w = QI(V4),
          U = s8.transition,
          S = L4;
        try {
          if (s8.transition = null, L4 = 16 > w ? 16 : w, VD === null) var g = !1;
          else {
            if (w = VD, VD = null, V4 = 0, (h4 & 6) !== 0) throw Error(G(331));
            var m = h4;
            h4 |= 4;
            for ($2 = w.current; $2 !== null;) {
              var r = $2,
                j1 = r.child;
              if (($2.flags & 16) !== 0) {
                var CA = r.deletions;
                if (CA !== null) {
                  for (var kA = 0; kA < CA.length; kA++) {
                    var F0 = CA[kA];
                    for ($2 = F0; $2 !== null;) {
                      var h0 = $2;
                      switch (h0.tag) {
                        case 0:
                        case 11:
                        case 15:
                          IG(8, h0, r)
                      }
                      var i2 = h0.child;
                      if (i2 !== null) i2.return = h0, $2 = i2;
                      else
                        for (; $2 !== null;) {
                          h0 = $2;
                          var {
                            sibling: n0,
                            return: l5
                          } = h0;
                          if (Bk(h0), h0 === F0) {
                            $2 = null;
                            break
                          }
                          if (n0 !== null) {
                            n0.return = l5, $2 = n0;
                            break
                          }
                          $2 = l5
                        }
                    }
                  }
                  var x5 = r.alternate;
                  if (x5 !== null) {
                    var YI = x5.child;
                    if (YI !== null) {
                      x5.child = null;
                      do {
                        var wQ = YI.sibling;
                        YI.sibling = null, YI = wQ
                      } while (YI !== null)
                    }
                  }
                  $2 = r
                }
              }
              if ((r.subtreeFlags & 2064) !== 0 && j1 !== null) j1.return = r, $2 = j1;
              else A: for (; $2 !== null;) {
                if (r = $2, (r.flags & 2048) !== 0) switch (r.tag) {
                  case 0:
                  case 11:
                  case 15:
                    IG(9, r, r.return)
                }
                var yA = r.sibling;
                if (yA !== null) {
                  yA.return = r.return, $2 = yA;
                  break A
                }
                $2 = r.return
              }
            }
            var EA = w.current;
            for ($2 = EA; $2 !== null;) {
              j1 = $2;
              var hA = j1.child;
              if ((j1.subtreeFlags & 2064) !== 0 && hA !== null) hA.return = j1, $2 = hA;
              else A: for (j1 = EA; $2 !== null;) {
                if (CA = $2, (CA.flags & 2048) !== 0) try {
                  switch (CA.tag) {
                    case 0:
                    case 11:
                    case 15:
                      GI(9, CA)
                  }
                } catch (t2) {
                  w8(CA, CA.return, t2)
                }
                if (CA === j1) {
                  $2 = null;
                  break A
                }
                var l0 = CA.sibling;
                if (l0 !== null) {
                  l0.return = CA.return, $2 = l0;
                  break A
                }
                $2 = CA.return
              }
            }
            if (h4 = m, E5(), R4 && typeof R4.onPostCommitFiberRoot === "function") try {
              R4.onPostCommitFiberRoot(i6, w)
            } catch (t2) {}
            g = !0
          }
          return g
        } finally {
          L4 = S, s8.transition = U
        }
      }
      return !1
    }

    function Yk(w, U, S) {
      U = kV(S, U), U = JH(w, U, 1), w = YD(w, U, 1), U = zQ(), w !== null && (BI(w, 1, U), DI(w, U))
    }

    function w8(w, U, S) {
      if (w.tag === 3) Yk(w, w, S);
      else
        for (; U !== null;) {
          if (U.tag === 3) {
            Yk(U, w, S);
            break
          } else if (U.tag === 1) {
            var g = U.stateNode;
            if (typeof U.type.getDerivedStateFromError === "function" || typeof g.componentDidCatch === "function" && (FY === null || !FY.has(g))) {
              w = kV(S, w), w = _T(U, w, 1), U = YD(U, w, 1), w = zQ(), U !== null && (BI(U, 1, w), DI(U, w));
              break
            }
          }
          U = U.return
        }
    }

    function Wk(w, U, S) {
      var g = w.pingCache;
      g !== null && g.delete(U), U = zQ(), w.pingedLanes |= w.suspendedLanes & S, b3 === w && (hB & S) === S && (r8 === 4 || r8 === 3 && (hB & 130023424) === hB && 500 > wB() - mT ? P7(w, 0) : oE |= S), DI(w, U)
    }

    function lT(w, U) {
      U === 0 && ((w.mode & 1) === 0 ? U = 1 : (U = Z4, Z4 <<= 1, (Z4 & 130023424) === 0 && (Z4 = 4194304)));
      var S = zQ();
      w = xW(w, U), w !== null && (BI(w, U, S), DI(w, S))
    }

    function Jk(w) {
      var U = w.memoizedState,
        S = 0;
      U !== null && (S = U.retryLane), lT(w, S)
    }

    function QU(w, U) {
      var S = 0;
      switch (w.tag) {
        case 13:
          var {
            stateNode: g, memoizedState: m
          } = w;
          m !== null && (S = m.retryLane);
          break;
        case 19:
          g = w.stateNode;
          break;
        default:
          throw Error(G(314))
      }
      g !== null && g.delete(U), lT(w, S)
    }
    var iT = function(w, U, S) {
      if (w !== null)
        if (w.memoizedProps !== U.pendingProps || z2.current) U9 = !0;
        else {
          if ((w.lanes & S) === 0 && (U.flags & 128) === 0) return U9 = !1, ey(w, U, S);
          U9 = (w.flags & 131072) !== 0 ? !0 : !1
        }
      else U9 = !1, k5 && (U.flags & 1048576) !== 0 && ZD(U, RV, U.index);
      switch (U.lanes = 0, U.tag) {
        case 2:
          var g = U.type;
          Kq(w, U), w = U.pendingProps;
          var m = c1(U, c0.current);
          oI(U, S), m = vE(null, U, g, w, m, S);
          var r = _V();
          return U.flags |= 1, typeof m === "object" && m !== null && typeof m.render === "function" && m.$$typeof === void 0 ? (U.tag = 1, U.memoizedState = null, U.updateQueue = null, _1(g) ? (r = !0, xA(U)) : r = !1, U.memoizedState = m.state !== null && m.state !== void 0 ? m.state : null, QY(U), m.updater = UF, U.stateNode = m, m._reactInternals = U, pE(U, g, w, S), U = jT(null, U, g, !0, r, S)) : (U.tag = 0, k5 && r && J5(U), vB(null, U, m, S), U = U.child), U;
        case 16:
          g = U.elementType;
          A: {
            switch (Kq(w, U), w = U.pendingProps, m = g._init, g = m(g._payload), U.type = g, m = U.tag = Fk(g), w = VQ(g, w), m) {
              case 0:
                U = Cq(null, U, g, w, S);
                break A;
              case 1:
                U = lE(null, U, g, w, S);
                break A;
              case 11:
                U = iy(null, U, g, w, S);
                break A;
              case 14:
                U = ny(null, U, g, VQ(g.type, w), S);
                break A
            }
            throw Error(G(306, g, ""))
          }
          return U;
        case 0:
          return g = U.type, m = U.pendingProps, m = U.elementType === g ? m : VQ(g, m), Cq(w, U, g, m, S);
        case 1:
          return g = U.type, m = U.pendingProps, m = U.elementType === g ? m : VQ(g, m), lE(w, U, g, m, S);
        case 3:
          A: {
            if (XD(U), w === null) throw Error(G(387));g = U.pendingProps,
            r = U.memoizedState,
            m = r.element,
            kE(w, U),
            IH(U, g, null, S);
            var j1 = U.memoizedState;
            if (g = j1.element, W1 && r.isDehydrated)
              if (r = {
                  element: g,
                  isDehydrated: !1,
                  cache: j1.cache,
                  pendingSuspenseBoundaries: j1.pendingSuspenseBoundaries,
                  transitions: j1.transitions
                }, U.updateQueue.baseState = r, U.memoizedState = r, U.flags & 256) {
                m = kV(Error(G(423)), U), U = yT(w, U, g, S, m);
                break A
              } else if (g !== m) {
              m = kV(Error(G(424)), U), U = yT(w, U, g, S, m);
              break A
            } else
              for (W1 && (Q8 = j8(U.stateNode.containerInfo), P6 = U, k5 = !0, kB = null, lQ = !1), S = v0(U, null, g, S), U.child = S; S;) S.flags = S.flags & -3 | 4096, S = S.sibling;
            else {
              if (DD(), g === m) {
                U = x3(w, U, S);
                break A
              }
              vB(w, U, g, S)
            }
            U = U.child
          }
          return U;
        case 5:
          return fE(U), w === null && L7(U), g = U.type, m = U.pendingProps, r = w !== null ? w.memoizedProps : null, j1 = m.children, Q1(g, m) ? j1 = null : r !== null && Q1(g, r) && (U.flags |= 32), sy(w, U), vB(w, U, j1, S), U.child;
        case 6:
          return w === null && L7(U), null;
        case 13:
          return ry(w, U, S);
        case 4:
          return GH(U, U.stateNode.containerInfo), g = U.pendingProps, w === null ? U.child = vA(U, null, g, S) : vB(w, U, g, S), U.child;
        case 11:
          return g = U.type, m = U.pendingProps, m = U.elementType === g ? m : VQ(g, m), iy(w, U, g, m, S);
        case 7:
          return vB(w, U, U.pendingProps, S), U.child;
        case 8:
          return vB(w, U, U.pendingProps.children, S), U.child;
        case 12:
          return vB(w, U, U.pendingProps.children, S), U.child;
        case 10:
          A: {
            if (g = U.type._context, m = U.pendingProps, r = U.memoizedProps, j1 = m.value, F5(U, g, j1), r !== null)
              if (jB(r.value, j1)) {
                if (r.children === m.children && !z2.current) {
                  U = x3(w, U, S);
                  break A
                }
              } else
                for (r = U.child, r !== null && (r.return = U); r !== null;) {
                  var CA = r.dependencies;
                  if (CA !== null) {
                    j1 = r.child;
                    for (var kA = CA.firstContext; kA !== null;) {
                      if (kA.context === g) {
                        if (r.tag === 1) {
                          kA = iQ(-1, S & -S), kA.tag = 2;
                          var F0 = r.updateQueue;
                          if (F0 !== null) {
                            F0 = F0.shared;
                            var h0 = F0.pending;
                            h0 === null ? kA.next = kA : (kA.next = h0.next, h0.next = kA), F0.pending = kA
                          }
                        }
                        r.lanes |= S, kA = r.alternate, kA !== null && (kA.lanes |= S), FQ(r.return, S, U), CA.lanes |= S;
                        break
                      }
                      kA = kA.next
                    }
                  } else if (r.tag === 10) j1 = r.type === U.type ? null : r.child;
                  else if (r.tag === 18) {
                    if (j1 = r.return, j1 === null) throw Error(G(341));
                    j1.lanes |= S, CA = j1.alternate, CA !== null && (CA.lanes |= S), FQ(j1, S, U), j1 = r.sibling
                  } else j1 = r.child;
                  if (j1 !== null) j1.return = r;
                  else
                    for (j1 = r; j1 !== null;) {
                      if (j1 === U) {
                        j1 = null;
                        break
                      }
                      if (r = j1.sibling, r !== null) {
                        r.return = j1.return, j1 = r;
                        break
                      }
                      j1 = j1.return
                    }
                  r = j1
                }
            vB(w, U, m.children, S),
            U = U.child
          }
          return U;
        case 9:
          return m = U.type, g = U.pendingProps.children, oI(U, S), m = R7(m), g = g(m), U.flags |= 1, vB(w, U, g, S), U.child;
        case 14:
          return g = U.type, m = VQ(g, U.pendingProps), m = VQ(g.type, m), ny(w, U, g, m, S);
        case 15:
          return eI(w, U, U.type, U.pendingProps, S);
        case 17:
          return g = U.type, m = U.pendingProps, m = U.elementType === g ? m : VQ(g, m), Kq(w, U), U.tag = 1, _1(g) ? (w = !0, xA(U)) : w = !1, oI(U, S), gW(U, g, m), pE(U, g, m, S), jT(null, U, g, !0, w, S);
        case 19:
          return ty(w, U, S);
        case 22:
          return ay(w, U, S)
      }
      throw Error(G(156, U.tag))
    };

    function MH(w, U) {
      return GD(w, U)
    }

    function S7(w, U, S, g) {
      this.tag = w, this.key = S, this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null, this.index = 0, this.ref = null, this.pendingProps = U, this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null, this.mode = g, this.subtreeFlags = this.flags = 0, this.deletions = null, this.childLanes = this.lanes = 0, this.alternate = null
    }

    function c2(w, U, S, g) {
      return new S7(w, U, S, g)
    }

    function Oq(w) {
      return w = w.prototype, !(!w || !w.isReactComponent)
    }

    function Fk(w) {
      if (typeof w === "function") return Oq(w) ? 1 : 0;
      if (w !== void 0 && w !== null) {
        if (w = w.$$typeof, w === C) return 11;
        if (w === N) return 14
      }
      return 2
    }

    function CD(w, U) {
      var S = w.alternate;
      return S === null ? (S = c2(w.tag, U, w.key, w.mode), S.elementType = w.elementType, S.type = w.type, S.stateNode = w.stateNode, S.alternate = w, w.alternate = S) : (S.pendingProps = U, S.type = w.type, S.flags = 0, S.subtreeFlags = 0, S.deletions = null), S.flags = w.flags & 14680064, S.childLanes = w.childLanes, S.lanes = w.lanes, S.child = w.child, S.memoizedProps = w.memoizedProps, S.memoizedState = w.memoizedState, S.updateQueue = w.updateQueue, U = w.dependencies, S.dependencies = U === null ? null : {
        lanes: U.lanes,
        firstContext: U.firstContext
      }, S.sibling = w.sibling, S.index = w.index, S.ref = w.ref, S
    }

    function LF(w, U, S, g, m, r) {
      var j1 = 2;
      if (g = w, typeof w === "function") Oq(w) && (j1 = 1);
      else if (typeof w === "string") j1 = 5;
      else A: switch (w) {
        case W:
          return RF(S.children, m, r, U);
        case J:
          j1 = 8, m |= 8;
          break;
        case F:
          return w = c2(12, S, U, m | 2), w.elementType = F, w.lanes = r, w;
        case K:
          return w = c2(13, S, U, m), w.elementType = K, w.lanes = r, w;
        case E:
          return w = c2(19, S, U, m), w.elementType = E, w.lanes = r, w;
        case O:
          return IU(S, m, r, U);
        default:
          if (typeof w === "object" && w !== null) switch (w.$$typeof) {
            case X:
              j1 = 10;
              break A;
            case V:
              j1 = 9;
              break A;
            case C:
              j1 = 11;
              break A;
            case N:
              j1 = 14;
              break A;
            case q:
              j1 = 16, g = null;
              break A
          }
          throw Error(G(130, w == null ? w : typeof w, ""))
      }
      return U = c2(j1, S, U, m), U.elementType = w, U.type = g, U.lanes = r, U
    }

    function RF(w, U, S, g) {
      return w = c2(7, w, g, U), w.lanes = S, w
    }

    function IU(w, U, S, g) {
      return w = c2(22, w, g, U), w.elementType = O, w.lanes = S, w.stateNode = {
        isHidden: !1
      }, w
    }

    function nT(w, U, S) {
      return w = c2(6, w, null, U), w.lanes = S, w
    }

    function GU(w, U, S) {
      return U = c2(4, w.children !== null ? w.children : [], w.key, U), U.lanes = S, U.stateNode = {
        containerInfo: w.containerInfo,
        pendingChildren: null,
        implementation: w.implementation
      }, U
    }

    function OF(w, U, S, g, m) {
      this.tag = U, this.containerInfo = w, this.finishedWork = this.pingCache = this.current = this.pendingChildren = null, this.timeoutHandle = HA, this.callbackNode = this.pendingContext = this.context = null, this.callbackPriority = 0, this.eventTimes = jW(0), this.expirationTimes = jW(-1), this.entangledLanes = this.finishedLanes = this.mutableReadLanes = this.expiredLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0, this.entanglements = jW(0), this.identifierPrefix = g, this.onRecoverableError = m, W1 && (this.mutableSourceEagerHydrationData = null)
    }

    function LH(w, U, S, g, m, r, j1, CA, kA) {
      return w = new OF(w, U, S, CA, kA), U === 1 ? (U = 1, r === !0 && (U |= 8)) : U = 0, r = c2(3, null, null, U), w.current = r, r.stateNode = w, r.memoizedState = {
        element: g,
        isDehydrated: S,
        cache: null,
        transitions: null,
        pendingSuspenseBoundaries: null
      }, QY(r), w
    }

    function aT(w) {
      if (!w) return W2;
      w = w._reactInternals;
      A: {
        if (k(w) !== w || w.tag !== 1) throw Error(G(170));
        var U = w;do {
          switch (U.tag) {
            case 3:
              U = U.stateNode.context;
              break A;
            case 1:
              if (_1(U.type)) {
                U = U.stateNode.__reactInternalMemoizedMergedChildContext;
                break A
              }
          }
          U = U.return
        } while (U !== null);
        throw Error(G(171))
      }
      if (w.tag === 1) {
        var S = w.type;
        if (_1(S)) return IA(w, S, U)
      }
      return U
    }

    function sT(w) {
      var U = w._reactInternals;
      if (U === void 0) {
        if (typeof w.render === "function") throw Error(G(188));
        throw w = Object.keys(w).join(","), Error(G(268, w))
      }
      return w = s(U), w === null ? null : w.stateNode
    }

    function rT(w, U) {
      if (w = w.memoizedState, w !== null && w.dehydrated !== null) {
        var S = w.retryLane;
        w.retryLane = S !== 0 && S < U ? S : U
      }
    }

    function hV(w, U) {
      rT(w, U), (w = w.alternate) && rT(w, U)
    }

    function Tq(w) {
      return w = s(w), w === null ? null : w.stateNode
    }

    function Pq() {
      return null
    }
    return Q.attemptContinuousHydration = function(w) {
      if (w.tag === 13) {
        var U = xW(w, 134217728);
        if (U !== null) {
          var S = zQ();
          x8(U, w, 134217728, S)
        }
        hV(w, 134217728)
      }
    }, Q.attemptDiscreteHydration = function(w) {
      if (w.tag === 13) {
        var U = xW(w, 1);
        if (U !== null) {
          var S = zQ();
          x8(U, w, 1, S)
        }
        hV(w, 1)
      }
    }, Q.attemptHydrationAtCurrentPriority = function(w) {
      if (w.tag === 13) {
        var U = cW(w),
          S = xW(w, U);
        if (S !== null) {
          var g = zQ();
          x8(S, w, U, g)
        }
        hV(w, U)
      }
    }, Q.attemptSynchronousHydration = function(w) {
      switch (w.tag) {
        case 3:
          var U = w.stateNode;
          if (U.current.memoizedState.isDehydrated) {
            var S = x4(U.pendingLanes);
            S !== 0 && (ID(U, S | 1), DI(U, wB()), (h4 & 6) === 0 && (tE(), E5()))
          }
          break;
        case 13:
          gV(function() {
            var g = xW(w, 1);
            if (g !== null) {
              var m = zQ();
              x8(g, w, 1, m)
            }
          }), hV(w, 1)
      }
    }, Q.batchedUpdates = function(w, U) {
      var S = h4;
      h4 |= 1;
      try {
        return w(U)
      } finally {
        h4 = S, h4 === 0 && (tE(), yE && E5())
      }
    }, Q.createComponentSelector = function(w) {
      return {
        $$typeof: VH,
        value: w
      }
    }, Q.createContainer = function(w, U, S, g, m, r, j1) {
      return LH(w, U, !1, null, S, g, m, r, j1)
    }, Q.createHasPseudoClassSelector = function(w) {
      return {
        $$typeof: Uq,
        value: w
      }
    }, Q.createHydrationContainer = function(w, U, S, g, m, r, j1, CA, kA) {
      return w = LH(S, g, !0, w, m, r, j1, CA, kA), w.context = aT(null), S = w.current, g = zQ(), m = cW(S), r = iQ(g, m), r.callback = U !== void 0 && U !== null ? U : null, YD(S, r, m), w.current.lanes = m, BI(w, m, g), DI(w, g), w
    }, Q.createPortal = function(w, U, S) {
      var g = 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null;
      return {
        $$typeof: Y,
        key: g == null ? null : "" + g,
        children: w,
        containerInfo: U,
        implementation: S
      }
    }, Q.createRoleSelector = function(w) {
      return {
        $$typeof: CH,
        value: w
      }
    }, Q.createTestNameSelector = function(w) {
      return {
        $$typeof: KH,
        value: w
      }
    }, Q.createTextSelector = function(w) {
      return {
        $$typeof: sE,
        value: w
      }
    }, Q.deferredUpdates = function(w) {
      var U = L4,
        S = s8.transition;
      try {
        return s8.transition = null, L4 = 16, w()
      } finally {
        L4 = U, s8.transition = S
      }
    }, Q.discreteUpdates = function(w, U, S, g, m) {
      var r = L4,
        j1 = s8.transition;
      try {
        return s8.transition = null, L4 = 1, w(U, S, g, m)
      } finally {
        L4 = r, s8.transition = j1, h4 === 0 && tE()
      }
    }, Q.findAllNodes = zH, Q.findBoundingRects = function(w, U) {
      if (!o1) throw Error(G(363));
      U = zH(w, U), w = [];
      for (var S = 0; S < U.length; S++) w.push(zA(U[S]));
      for (U = w.length - 1; 0 < U; U--) {
        S = w[U];
        for (var g = S.x, m = g + S.width, r = S.y, j1 = r + S.height, CA = U - 1; 0 <= CA; CA--)
          if (U !== CA) {
            var kA = w[CA],
              F0 = kA.x,
              h0 = F0 + kA.width,
              i2 = kA.y,
              n0 = i2 + kA.height;
            if (g >= F0 && r >= i2 && m <= h0 && j1 <= n0) {
              w.splice(U, 1);
              break
            } else if (!(g !== F0 || S.width !== kA.width || n0 < r || i2 > j1)) {
              i2 > r && (kA.height += i2 - r, kA.y = r), n0 < j1 && (kA.height = j1 - i2), w.splice(U, 1);
              break
            } else if (!(r !== i2 || S.height !== kA.height || h0 < g || F0 > m)) {
              F0 > g && (kA.width += F0 - g, kA.x = g), h0 < m && (kA.width = m - F0), w.splice(U, 1);
              break
            }
          }
      }
      return w
    }, Q.findHostInstance = sT, Q.findHostInstanceWithNoPortals = function(w) {
      return w = x(w), w = w !== null ? F1(w) : null, w === null ? null : w.stateNode
    }, Q.findHostInstanceWithWarning = function(w) {
      return sT(w)
    }, Q.flushControlled = function(w) {
      var U = h4;
      h4 |= 1;
      var S = s8.transition,
        g = L4;
      try {
        s8.transition = null, L4 = 1, w()
      } finally {
        L4 = g, s8.transition = S, h4 = U, h4 === 0 && (tE(), E5())
      }
    }, Q.flushPassiveEffects = VY, Q.flushSync = gV, Q.focusWithin = function(w, U) {
      if (!o1) throw Error(G(363));
      w = HH(w), U = Zk(w, U), U = Array.from(U);
      for (w = 0; w < U.length;) {
        var S = U[w++];
        if (!fA(S)) {
          if (S.tag === 5 && k2(S.stateNode)) return !0;
          for (S = S.child; S !== null;) U.push(S), S = S.sibling
        }
      }
      return !1
    }, Q.getCurrentUpdatePriority = function() {
      return L4
    }, Q.getFindAllNodesFailureDescription = function(w, U) {
      if (!o1) throw Error(G(363));
      var S = 0,
        g = [];
      w = [HH(w), 0];
      for (var m = 0; m < w.length;) {
        var r = w[m++],
          j1 = w[m++],
          CA = U[j1];
        if (r.tag !== 5 || !fA(r)) {
          if (gT(r, CA) && (g.push(Gk(CA)), j1++, j1 > S && (S = j1)), j1 < U.length)
            for (r = r.child; r !== null;) w.push(r, j1), r = r.sibling
        }
      }
      if (S < U.length) {
        for (w = []; S < U.length; S++) w.push(Gk(U[S]));
        return `findAllNodes was able to match part of the selector:
  ` + (g.join(" > ") + `

No matching component was found for:
  `) + w.join(" > ")
      }
      return null
    }, Q.getPublicRootInstance = function(w) {
      if (w = w.current, !w.child) return null;
      switch (w.child.tag) {
        case 5:
          return v(w.child.stateNode);
        default:
          return w.child.stateNode
      }
    }, Q.injectIntoDevTools = function(w) {
      if (w = {
          bundleType: w.bundleType,
          version: w.version,
          rendererPackageName: w.rendererPackageName,
          rendererConfig: w.rendererConfig,
          overrideHookState: null,
          overrideHookStateDeletePath: null,
          overrideHookStateRenamePath: null,
          overrideProps: null,
          overridePropsDeletePath: null,
          overridePropsRenamePath: null,
          setErrorHandler: null,
          setSuspenseHandler: null,
          scheduleUpdate: null,
          currentDispatcherRef: Z.ReactCurrentDispatcher,
          findHostInstanceByFiber: Tq,
          findFiberByHostInstance: w.findFiberByHostInstance || Pq,
          findHostInstancesForRefresh: null,
          scheduleRefresh: null,
          scheduleRoot: null,
          setRefreshHandler: null,
          getCurrentFiber: null,
          reconcilerVersion: "18.3.1"
        }, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") w = !1;
      else {
        var U = __REACT_DEVTOOLS_GLOBAL_HOOK__;
        if (U.isDisabled || !U.supportsFiber) w = !0;
        else {
          try {
            i6 = U.inject(w), R4 = U
          } catch (S) {}
          w = U.checkDCE ? !0 : !1
        }
      }
      return w
    }, Q.isAlreadyRendering = function() {
      return !1
    }, Q.observeVisibleRects = function(w, U, S, g) {
      if (!o1) throw Error(G(363));
      w = zH(w, U);
      var m = s0(w, S, g).disconnect;
      return {
        disconnect: function() {
          m()
        }
      }
    }, Q.registerMutableSourceForHydration = function(w, U) {
      var S = U._getVersion;
      S = S(U._source), w.mutableSourceEagerHydrationData == null ? w.mutableSourceEagerHydrationData = [U, S] : w.mutableSourceEagerHydrationData.push(U, S)
    }, Q.runWithPriority = function(w, U) {
      var S = L4;
      try {
        return L4 = w, U()
      } finally {
        L4 = S
      }
    }, Q.shouldError = function() {
      return null
    }, Q.shouldSuspend = function() {
      return !1
    }, Q.updateContainer = function(w, U, S, g) {
      var m = U.current,
        r = zQ(),
        j1 = cW(m);
      return S = aT(S), U.context === null ? U.context = S : U.pendingContext = S, U = iQ(r, j1), U.payload = {
        element: w
      }, g = g === void 0 ? null : g, g !== null && (U.callback = g), w = YD(m, U, j1), w !== null && (x8(w, m, j1, r), Dq(w, m, j1)), j1
    }, Q
  }
})
// @from(Start 2474930, End 2487806)
gbA = z((F98, bbA) => {
  bbA.exports = () => {
    return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26D3\uFE0F?(?:\u200D\uD83D\uDCA5)?|\u26F9(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF43\uDF45-\uDF4A\uDF4C-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDF44(?:\u200D\uD83D\uDFEB)?|\uDF4B(?:\u200D\uD83D\uDFE9)?|\uDFC3(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4\uDEB5](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE41\uDE43\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC26(?:\u200D(?:\u2B1B|\uD83D\uDD25))?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?|\uDE42(?:\u200D[\u2194\u2195]\uFE0F?)?|\uDEB6(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE89\uDE8F-\uDEC2\uDEC6\uDECE-\uDEDC\uDEDF-\uDEE9]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDCE(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1|\uDDD1\u200D\uD83E\uDDD2(?:\u200D\uD83E\uDDD2)?|\uDDD2(?:\u200D\uD83E\uDDD2)?))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g
  }
})
// @from(Start 2487812, End 2500688)
ubA = z((E98, dbA) => {
  dbA.exports = () => {
    return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26D3\uFE0F?(?:\u200D\uD83D\uDCA5)?|\u26F9(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF43\uDF45-\uDF4A\uDF4C-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDF44(?:\u200D\uD83D\uDFEB)?|\uDF4B(?:\u200D\uD83D\uDFE9)?|\uDFC3(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4\uDEB5](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE41\uDE43\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC26(?:\u200D(?:\u2B1B|\uD83D\uDD25))?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?|\uDE42(?:\u200D[\u2194\u2195]\uFE0F?)?|\uDEB6(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE89\uDE8F-\uDEC2\uDEC6\uDECE-\uDEDC\uDEDF-\uDEE9]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDCE(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1|\uDDD1\u200D\uD83E\uDDD2(?:\u200D\uD83E\uDDD2)?|\uDDD2(?:\u200D\uD83E\uDDD2)?))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g
  }
})
// @from(Start 2500694, End 2513570)
AgA = z((k98, ebA) => {
  ebA.exports = () => {
    return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26D3\uFE0F?(?:\u200D\uD83D\uDCA5)?|\u26F9(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF43\uDF45-\uDF4A\uDF4C-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDF44(?:\u200D\uD83D\uDFEB)?|\uDF4B(?:\u200D\uD83D\uDFE9)?|\uDFC3(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4\uDEB5](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE41\uDE43\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC26(?:\u200D(?:\u2B1B|\uD83D\uDD25))?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?|\uDE42(?:\u200D[\u2194\u2195]\uFE0F?)?|\uDEB6(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE89\uDE8F-\uDEC2\uDEC6\uDECE-\uDEDC\uDEDF-\uDEE9]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDCE(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1|\uDDD1\u200D\uD83E\uDDD2(?:\u200D\uD83E\uDDD2)?|\uDDD2(?:\u200D\uD83E\uDDD2)?))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g
  }
})
// @from(Start 2513576, End 2514065)
AN = z((s98, WgA) => {
  var DgA = ["nodebuffer", "arraybuffer", "fragments"],
    YgA = typeof Blob !== "undefined";
  if (YgA) DgA.push("blob");
  WgA.exports = {
    BINARY_TYPES: DgA,
    EMPTY_BUFFER: Buffer.alloc(0),
    GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
    hasBlob: YgA,
    kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
    kListener: Symbol("kListener"),
    kStatusCode: Symbol("status-code"),
    kWebSocket: Symbol("websocket"),
    NOOP: () => {}
  }
})
// @from(Start 2514071, End 2515611)
Un = z((r98, hB1) => {
  var {
    EMPTY_BUFFER: Ke9
  } = AN(), AS1 = Buffer[Symbol.species];

  function He9(A, B) {
    if (A.length === 0) return Ke9;
    if (A.length === 1) return A[0];
    let Q = Buffer.allocUnsafe(B),
      I = 0;
    for (let G = 0; G < A.length; G++) {
      let Z = A[G];
      Q.set(Z, I), I += Z.length
    }
    if (I < B) return new AS1(Q.buffer, Q.byteOffset, I);
    return Q
  }

  function JgA(A, B, Q, I, G) {
    for (let Z = 0; Z < G; Z++) Q[I + Z] = A[Z] ^ B[Z & 3]
  }

  function FgA(A, B) {
    for (let Q = 0; Q < A.length; Q++) A[Q] ^= B[Q & 3]
  }

  function ze9(A) {
    if (A.length === A.buffer.byteLength) return A.buffer;
    return A.buffer.slice(A.byteOffset, A.byteOffset + A.length)
  }

  function BS1(A) {
    if (BS1.readOnly = !0, Buffer.isBuffer(A)) return A;
    let B;
    if (A instanceof ArrayBuffer) B = new AS1(A);
    else if (ArrayBuffer.isView(A)) B = new AS1(A.buffer, A.byteOffset, A.byteLength);
    else B = Buffer.from(A), BS1.readOnly = !1;
    return B
  }
  hB1.exports = {
    concat: He9,
    mask: JgA,
    toArrayBuffer: ze9,
    toBuffer: BS1,
    unmask: FgA
  };
  if (!process.env.WS_NO_BUFFER_UTIL) try {
    let A = (() => {
      throw new Error("Cannot require module " + "bufferutil");
    })();
    hB1.exports.mask = function(B, Q, I, G, Z) {
      if (Z < 48) JgA(B, Q, I, G, Z);
      else A.mask(B, Q, I, G, Z)
    }, hB1.exports.unmask = function(B, Q) {
      if (B.length < 32) FgA(B, Q);
      else A.unmask(B, Q)
    }
  } catch (A) {}
})
// @from(Start 2515617, End 2516133)
KgA = z((o98, CgA) => {
  var XgA = Symbol("kDone"),
    QS1 = Symbol("kRun");
  class VgA {
    constructor(A) {
      this[XgA] = () => {
        this.pending--, this[QS1]()
      }, this.concurrency = A || 1 / 0, this.jobs = [], this.pending = 0
    }
    add(A) {
      this.jobs.push(A), this[QS1]()
    } [QS1]() {
      if (this.pending === this.concurrency) return;
      if (this.jobs.length) {
        let A = this.jobs.shift();
        this.pending++, A(this[XgA])
      }
    }
  }
  CgA.exports = VgA
})
// @from(Start 2516139, End 2523528)
qn = z((t98, UgA) => {
  var Nn = Z1("zlib"),
    HgA = Un(),
    we9 = KgA(),
    {
      kStatusCode: zgA
    } = AN(),
    Ee9 = Buffer[Symbol.species],
    Ue9 = Buffer.from([0, 0, 255, 255]),
    uB1 = Symbol("permessage-deflate"),
    BN = Symbol("total-length"),
    $n = Symbol("callback"),
    YL = Symbol("buffers"),
    dB1 = Symbol("error"),
    mB1;
  class wgA {
    constructor(A, B, Q) {
      if (this._maxPayload = Q | 0, this._options = A || {}, this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024, this._isServer = !!B, this._deflate = null, this._inflate = null, this.params = null, !mB1) {
        let I = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10;
        mB1 = new we9(I)
      }
    }
    static get extensionName() {
      return "permessage-deflate"
    }
    offer() {
      let A = {};
      if (this._options.serverNoContextTakeover) A.server_no_context_takeover = !0;
      if (this._options.clientNoContextTakeover) A.client_no_context_takeover = !0;
      if (this._options.serverMaxWindowBits) A.server_max_window_bits = this._options.serverMaxWindowBits;
      if (this._options.clientMaxWindowBits) A.client_max_window_bits = this._options.clientMaxWindowBits;
      else if (this._options.clientMaxWindowBits == null) A.client_max_window_bits = !0;
      return A
    }
    accept(A) {
      return A = this.normalizeParams(A), this.params = this._isServer ? this.acceptAsServer(A) : this.acceptAsClient(A), this.params
    }
    cleanup() {
      if (this._inflate) this._inflate.close(), this._inflate = null;
      if (this._deflate) {
        let A = this._deflate[$n];
        if (this._deflate.close(), this._deflate = null, A) A(new Error("The deflate stream was closed while data was being processed"))
      }
    }
    acceptAsServer(A) {
      let B = this._options,
        Q = A.find((I) => {
          if (B.serverNoContextTakeover === !1 && I.server_no_context_takeover || I.server_max_window_bits && (B.serverMaxWindowBits === !1 || typeof B.serverMaxWindowBits === "number" && B.serverMaxWindowBits > I.server_max_window_bits) || typeof B.clientMaxWindowBits === "number" && !I.client_max_window_bits) return !1;
          return !0
        });
      if (!Q) throw new Error("None of the extension offers can be accepted");
      if (B.serverNoContextTakeover) Q.server_no_context_takeover = !0;
      if (B.clientNoContextTakeover) Q.client_no_context_takeover = !0;
      if (typeof B.serverMaxWindowBits === "number") Q.server_max_window_bits = B.serverMaxWindowBits;
      if (typeof B.clientMaxWindowBits === "number") Q.client_max_window_bits = B.clientMaxWindowBits;
      else if (Q.client_max_window_bits === !0 || B.clientMaxWindowBits === !1) delete Q.client_max_window_bits;
      return Q
    }
    acceptAsClient(A) {
      let B = A[0];
      if (this._options.clientNoContextTakeover === !1 && B.client_no_context_takeover) throw new Error('Unexpected parameter "client_no_context_takeover"');
      if (!B.client_max_window_bits) {
        if (typeof this._options.clientMaxWindowBits === "number") B.client_max_window_bits = this._options.clientMaxWindowBits
      } else if (this._options.clientMaxWindowBits === !1 || typeof this._options.clientMaxWindowBits === "number" && B.client_max_window_bits > this._options.clientMaxWindowBits) throw new Error('Unexpected or invalid parameter "client_max_window_bits"');
      return B
    }
    normalizeParams(A) {
      return A.forEach((B) => {
        Object.keys(B).forEach((Q) => {
          let I = B[Q];
          if (I.length > 1) throw new Error(`Parameter "${Q}" must have only a single value`);
          if (I = I[0], Q === "client_max_window_bits") {
            if (I !== !0) {
              let G = +I;
              if (!Number.isInteger(G) || G < 8 || G > 15) throw new TypeError(`Invalid value for parameter "${Q}": ${I}`);
              I = G
            } else if (!this._isServer) throw new TypeError(`Invalid value for parameter "${Q}": ${I}`)
          } else if (Q === "server_max_window_bits") {
            let G = +I;
            if (!Number.isInteger(G) || G < 8 || G > 15) throw new TypeError(`Invalid value for parameter "${Q}": ${I}`);
            I = G
          } else if (Q === "client_no_context_takeover" || Q === "server_no_context_takeover") {
            if (I !== !0) throw new TypeError(`Invalid value for parameter "${Q}": ${I}`)
          } else throw new Error(`Unknown parameter "${Q}"`);
          B[Q] = I
        })
      }), A
    }
    decompress(A, B, Q) {
      mB1.add((I) => {
        this._decompress(A, B, (G, Z) => {
          I(), Q(G, Z)
        })
      })
    }
    compress(A, B, Q) {
      mB1.add((I) => {
        this._compress(A, B, (G, Z) => {
          I(), Q(G, Z)
        })
      })
    }
    _decompress(A, B, Q) {
      let I = this._isServer ? "client" : "server";
      if (!this._inflate) {
        let G = `${I}_max_window_bits`,
          Z = typeof this.params[G] !== "number" ? Nn.Z_DEFAULT_WINDOWBITS : this.params[G];
        this._inflate = Nn.createInflateRaw({
          ...this._options.zlibInflateOptions,
          windowBits: Z
        }), this._inflate[uB1] = this, this._inflate[BN] = 0, this._inflate[YL] = [], this._inflate.on("error", $e9), this._inflate.on("data", EgA)
      }
      if (this._inflate[$n] = Q, this._inflate.write(A), B) this._inflate.write(Ue9);
      this._inflate.flush(() => {
        let G = this._inflate[dB1];
        if (G) {
          this._inflate.close(), this._inflate = null, Q(G);
          return
        }
        let Z = HgA.concat(this._inflate[YL], this._inflate[BN]);
        if (this._inflate._readableState.endEmitted) this._inflate.close(), this._inflate = null;
        else if (this._inflate[BN] = 0, this._inflate[YL] = [], B && this.params[`${I}_no_context_takeover`]) this._inflate.reset();
        Q(null, Z)
      })
    }
    _compress(A, B, Q) {
      let I = this._isServer ? "server" : "client";
      if (!this._deflate) {
        let G = `${I}_max_window_bits`,
          Z = typeof this.params[G] !== "number" ? Nn.Z_DEFAULT_WINDOWBITS : this.params[G];
        this._deflate = Nn.createDeflateRaw({
          ...this._options.zlibDeflateOptions,
          windowBits: Z
        }), this._deflate[BN] = 0, this._deflate[YL] = [], this._deflate.on("data", Ne9)
      }
      this._deflate[$n] = Q, this._deflate.write(A), this._deflate.flush(Nn.Z_SYNC_FLUSH, () => {
        if (!this._deflate) return;
        let G = HgA.concat(this._deflate[YL], this._deflate[BN]);
        if (B) G = new Ee9(G.buffer, G.byteOffset, G.length - 4);
        if (this._deflate[$n] = null, this._deflate[BN] = 0, this._deflate[YL] = [], B && this.params[`${I}_no_context_takeover`]) this._deflate.reset();
        Q(null, G)
      })
    }
  }
  UgA.exports = wgA;

  function Ne9(A) {
    this[YL].push(A), this[BN] += A.length
  }

  function EgA(A) {
    if (this[BN] += A.length, this[uB1]._maxPayload < 1 || this[BN] <= this[uB1]._maxPayload) {
      this[YL].push(A);
      return
    }
    this[dB1] = new RangeError("Max payload size exceeded"), this[dB1].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH", this[dB1][zgA] = 1009, this.removeListener("data", EgA), this.reset()
  }

  function $e9(A) {
    this[uB1]._inflate = null, A[zgA] = 1007, this[$n](A)
  }
})
// @from(Start 2523534, End 2525642)
lv = z((e98, pB1) => {
  var {
    isUtf8: NgA
  } = Z1("buffer"), {
    hasBlob: qe9
  } = AN(), Me9 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0];

  function Le9(A) {
    return A >= 1000 && A <= 1014 && A !== 1004 && A !== 1005 && A !== 1006 || A >= 3000 && A <= 4999
  }

  function IS1(A) {
    let B = A.length,
      Q = 0;
    while (Q < B)
      if ((A[Q] & 128) === 0) Q++;
      else if ((A[Q] & 224) === 192) {
      if (Q + 1 === B || (A[Q + 1] & 192) !== 128 || (A[Q] & 254) === 192) return !1;
      Q += 2
    } else if ((A[Q] & 240) === 224) {
      if (Q + 2 >= B || (A[Q + 1] & 192) !== 128 || (A[Q + 2] & 192) !== 128 || A[Q] === 224 && (A[Q + 1] & 224) === 128 || A[Q] === 237 && (A[Q + 1] & 224) === 160) return !1;
      Q += 3
    } else if ((A[Q] & 248) === 240) {
      if (Q + 3 >= B || (A[Q + 1] & 192) !== 128 || (A[Q + 2] & 192) !== 128 || (A[Q + 3] & 192) !== 128 || A[Q] === 240 && (A[Q + 1] & 240) === 128 || A[Q] === 244 && A[Q + 1] > 143 || A[Q] > 244) return !1;
      Q += 4
    } else return !1;
    return !0
  }

  function Re9(A) {
    return qe9 && typeof A === "object" && typeof A.arrayBuffer === "function" && typeof A.type === "string" && typeof A.stream === "function" && (A[Symbol.toStringTag] === "Blob" || A[Symbol.toStringTag] === "File")
  }
  pB1.exports = {
    isBlob: Re9,
    isValidStatusCode: Le9,
    isValidUTF8: IS1,
    tokenChars: Me9
  };
  if (NgA) pB1.exports.isValidUTF8 = function(A) {
    return A.length < 24 ? IS1(A) : NgA(A)
  };
  else if (!process.env.WS_NO_UTF_8_VALIDATE) try {
    let A = (() => {
      throw new Error("Cannot require module " + "utf-8-validate");
    })();
    pB1.exports.isValidUTF8 = function(B) {
      return B.length < 32 ? IS1(B) : A(B)
    }
  } catch (A) {}
})
// @from(Start 2525648, End 2536044)
ZS1 = z((A48, RgA) => {
  var {
    Writable: Oe9
  } = Z1("stream"), $gA = qn(), {
    BINARY_TYPES: Te9,
    EMPTY_BUFFER: qgA,
    kStatusCode: Pe9,
    kWebSocket: Se9
  } = AN(), {
    concat: GS1,
    toArrayBuffer: _e9,
    unmask: je9
  } = Un(), {
    isValidStatusCode: ye9,
    isValidUTF8: MgA
  } = lv(), cB1 = Buffer[Symbol.species];
  class LgA extends Oe9 {
    constructor(A = {}) {
      super();
      this._allowSynchronousEvents = A.allowSynchronousEvents !== void 0 ? A.allowSynchronousEvents : !0, this._binaryType = A.binaryType || Te9[0], this._extensions = A.extensions || {}, this._isServer = !!A.isServer, this._maxPayload = A.maxPayload | 0, this._skipUTF8Validation = !!A.skipUTF8Validation, this[Se9] = void 0, this._bufferedBytes = 0, this._buffers = [], this._compressed = !1, this._payloadLength = 0, this._mask = void 0, this._fragmented = 0, this._masked = !1, this._fin = !1, this._opcode = 0, this._totalPayloadLength = 0, this._messageLength = 0, this._fragments = [], this._errored = !1, this._loop = !1, this._state = 0
    }
    _write(A, B, Q) {
      if (this._opcode === 8 && this._state == 0) return Q();
      this._bufferedBytes += A.length, this._buffers.push(A), this.startLoop(Q)
    }
    consume(A) {
      if (this._bufferedBytes -= A, A === this._buffers[0].length) return this._buffers.shift();
      if (A < this._buffers[0].length) {
        let Q = this._buffers[0];
        return this._buffers[0] = new cB1(Q.buffer, Q.byteOffset + A, Q.length - A), new cB1(Q.buffer, Q.byteOffset, A)
      }
      let B = Buffer.allocUnsafe(A);
      do {
        let Q = this._buffers[0],
          I = B.length - A;
        if (A >= Q.length) B.set(this._buffers.shift(), I);
        else B.set(new Uint8Array(Q.buffer, Q.byteOffset, A), I), this._buffers[0] = new cB1(Q.buffer, Q.byteOffset + A, Q.length - A);
        A -= Q.length
      } while (A > 0);
      return B
    }
    startLoop(A) {
      this._loop = !0;
      do switch (this._state) {
        case 0:
          this.getInfo(A);
          break;
        case 1:
          this.getPayloadLength16(A);
          break;
        case 2:
          this.getPayloadLength64(A);
          break;
        case 3:
          this.getMask();
          break;
        case 4:
          this.getData(A);
          break;
        case 5:
        case 6:
          this._loop = !1;
          return
      }
      while (this._loop);
      if (!this._errored) A()
    }
    getInfo(A) {
      if (this._bufferedBytes < 2) {
        this._loop = !1;
        return
      }
      let B = this.consume(2);
      if ((B[0] & 48) !== 0) {
        let I = this.createError(RangeError, "RSV2 and RSV3 must be clear", !0, 1002, "WS_ERR_UNEXPECTED_RSV_2_3");
        A(I);
        return
      }
      let Q = (B[0] & 64) === 64;
      if (Q && !this._extensions[$gA.extensionName]) {
        let I = this.createError(RangeError, "RSV1 must be clear", !0, 1002, "WS_ERR_UNEXPECTED_RSV_1");
        A(I);
        return
      }
      if (this._fin = (B[0] & 128) === 128, this._opcode = B[0] & 15, this._payloadLength = B[1] & 127, this._opcode === 0) {
        if (Q) {
          let I = this.createError(RangeError, "RSV1 must be clear", !0, 1002, "WS_ERR_UNEXPECTED_RSV_1");
          A(I);
          return
        }
        if (!this._fragmented) {
          let I = this.createError(RangeError, "invalid opcode 0", !0, 1002, "WS_ERR_INVALID_OPCODE");
          A(I);
          return
        }
        this._opcode = this._fragmented
      } else if (this._opcode === 1 || this._opcode === 2) {
        if (this._fragmented) {
          let I = this.createError(RangeError, `invalid opcode ${this._opcode}`, !0, 1002, "WS_ERR_INVALID_OPCODE");
          A(I);
          return
        }
        this._compressed = Q
      } else if (this._opcode > 7 && this._opcode < 11) {
        if (!this._fin) {
          let I = this.createError(RangeError, "FIN must be set", !0, 1002, "WS_ERR_EXPECTED_FIN");
          A(I);
          return
        }
        if (Q) {
          let I = this.createError(RangeError, "RSV1 must be clear", !0, 1002, "WS_ERR_UNEXPECTED_RSV_1");
          A(I);
          return
        }
        if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
          let I = this.createError(RangeError, `invalid payload length ${this._payloadLength}`, !0, 1002, "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH");
          A(I);
          return
        }
      } else {
        let I = this.createError(RangeError, `invalid opcode ${this._opcode}`, !0, 1002, "WS_ERR_INVALID_OPCODE");
        A(I);
        return
      }
      if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
      if (this._masked = (B[1] & 128) === 128, this._isServer) {
        if (!this._masked) {
          let I = this.createError(RangeError, "MASK must be set", !0, 1002, "WS_ERR_EXPECTED_MASK");
          A(I);
          return
        }
      } else if (this._masked) {
        let I = this.createError(RangeError, "MASK must be clear", !0, 1002, "WS_ERR_UNEXPECTED_MASK");
        A(I);
        return
      }
      if (this._payloadLength === 126) this._state = 1;
      else if (this._payloadLength === 127) this._state = 2;
      else this.haveLength(A)
    }
    getPayloadLength16(A) {
      if (this._bufferedBytes < 2) {
        this._loop = !1;
        return
      }
      this._payloadLength = this.consume(2).readUInt16BE(0), this.haveLength(A)
    }
    getPayloadLength64(A) {
      if (this._bufferedBytes < 8) {
        this._loop = !1;
        return
      }
      let B = this.consume(8),
        Q = B.readUInt32BE(0);
      if (Q > Math.pow(2, 21) - 1) {
        let I = this.createError(RangeError, "Unsupported WebSocket frame: payload length > 2^53 - 1", !1, 1009, "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH");
        A(I);
        return
      }
      this._payloadLength = Q * Math.pow(2, 32) + B.readUInt32BE(4), this.haveLength(A)
    }
    haveLength(A) {
      if (this._payloadLength && this._opcode < 8) {
        if (this._totalPayloadLength += this._payloadLength, this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
          let B = this.createError(RangeError, "Max payload size exceeded", !1, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH");
          A(B);
          return
        }
      }
      if (this._masked) this._state = 3;
      else this._state = 4
    }
    getMask() {
      if (this._bufferedBytes < 4) {
        this._loop = !1;
        return
      }
      this._mask = this.consume(4), this._state = 4
    }
    getData(A) {
      let B = qgA;
      if (this._payloadLength) {
        if (this._bufferedBytes < this._payloadLength) {
          this._loop = !1;
          return
        }
        if (B = this.consume(this._payloadLength), this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) je9(B, this._mask)
      }
      if (this._opcode > 7) {
        this.controlMessage(B, A);
        return
      }
      if (this._compressed) {
        this._state = 5, this.decompress(B, A);
        return
      }
      if (B.length) this._messageLength = this._totalPayloadLength, this._fragments.push(B);
      this.dataMessage(A)
    }
    decompress(A, B) {
      this._extensions[$gA.extensionName].decompress(A, this._fin, (I, G) => {
        if (I) return B(I);
        if (G.length) {
          if (this._messageLength += G.length, this._messageLength > this._maxPayload && this._maxPayload > 0) {
            let Z = this.createError(RangeError, "Max payload size exceeded", !1, 1009, "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH");
            B(Z);
            return
          }
          this._fragments.push(G)
        }
        if (this.dataMessage(B), this._state === 0) this.startLoop(B)
      })
    }
    dataMessage(A) {
      if (!this._fin) {
        this._state = 0;
        return
      }
      let B = this._messageLength,
        Q = this._fragments;
      if (this._totalPayloadLength = 0, this._messageLength = 0, this._fragmented = 0, this._fragments = [], this._opcode === 2) {
        let I;
        if (this._binaryType === "nodebuffer") I = GS1(Q, B);
        else if (this._binaryType === "arraybuffer") I = _e9(GS1(Q, B));
        else if (this._binaryType === "blob") I = new Blob(Q);
        else I = Q;
        if (this._allowSynchronousEvents) this.emit("message", I, !0), this._state = 0;
        else this._state = 6, setImmediate(() => {
          this.emit("message", I, !0), this._state = 0, this.startLoop(A)
        })
      } else {
        let I = GS1(Q, B);
        if (!this._skipUTF8Validation && !MgA(I)) {
          let G = this.createError(Error, "invalid UTF-8 sequence", !0, 1007, "WS_ERR_INVALID_UTF8");
          A(G);
          return
        }
        if (this._state === 5 || this._allowSynchronousEvents) this.emit("message", I, !1), this._state = 0;
        else this._state = 6, setImmediate(() => {
          this.emit("message", I, !1), this._state = 0, this.startLoop(A)
        })
      }
    }
    controlMessage(A, B) {
      if (this._opcode === 8) {
        if (A.length === 0) this._loop = !1, this.emit("conclude", 1005, qgA), this.end();
        else {
          let Q = A.readUInt16BE(0);
          if (!ye9(Q)) {
            let G = this.createError(RangeError, `invalid status code ${Q}`, !0, 1002, "WS_ERR_INVALID_CLOSE_CODE");
            B(G);
            return
          }
          let I = new cB1(A.buffer, A.byteOffset + 2, A.length - 2);
          if (!this._skipUTF8Validation && !MgA(I)) {
            let G = this.createError(Error, "invalid UTF-8 sequence", !0, 1007, "WS_ERR_INVALID_UTF8");
            B(G);
            return
          }
          this._loop = !1, this.emit("conclude", Q, I), this.end()
        }
        this._state = 0;
        return
      }
      if (this._allowSynchronousEvents) this.emit(this._opcode === 9 ? "ping" : "pong", A), this._state = 0;
      else this._state = 6, setImmediate(() => {
        this.emit(this._opcode === 9 ? "ping" : "pong", A), this._state = 0, this.startLoop(B)
      })
    }
    createError(A, B, Q, I, G) {
      this._loop = !1, this._errored = !0;
      let Z = new A(Q ? `Invalid WebSocket frame: ${B}` : B);
      return Error.captureStackTrace(Z, this.createError), Z.code = G, Z[Pe9] = I, Z
    }
  }
  RgA.exports = LgA
})
// @from(Start 2536050, End 2543512)
YS1 = z((Q48, PgA) => {
  var {
    Duplex: B48
  } = Z1("stream"), {
    randomFillSync: ke9
  } = Z1("crypto"), OgA = qn(), {
    EMPTY_BUFFER: xe9,
    kWebSocket: fe9,
    NOOP: ve9
  } = AN(), {
    isBlob: iv,
    isValidStatusCode: be9
  } = lv(), {
    mask: TgA,
    toBuffer: TS
  } = Un(), QX = Symbol("kByteLength"), ge9 = Buffer.alloc(4), PS, nv = 8192, wC = 0, he9 = 1, me9 = 2;
  class WL {
    constructor(A, B, Q) {
      if (this._extensions = B || {}, Q) this._generateMask = Q, this._maskBuffer = Buffer.alloc(4);
      this._socket = A, this._firstFragment = !0, this._compress = !1, this._bufferedBytes = 0, this._queue = [], this._state = wC, this.onerror = ve9, this[fe9] = void 0
    }
    static frame(A, B) {
      let Q, I = !1,
        G = 2,
        Z = !1;
      if (B.mask) {
        if (Q = B.maskBuffer || ge9, B.generateMask) B.generateMask(Q);
        else {
          if (nv === 8192) {
            if (PS === void 0) PS = Buffer.alloc(8192);
            ke9(PS, 0, 8192), nv = 0
          }
          Q[0] = PS[nv++], Q[1] = PS[nv++], Q[2] = PS[nv++], Q[3] = PS[nv++]
        }
        Z = (Q[0] | Q[1] | Q[2] | Q[3]) === 0, G = 6
      }
      let D;
      if (typeof A === "string")
        if ((!B.mask || Z) && B[QX] !== void 0) D = B[QX];
        else A = Buffer.from(A), D = A.length;
      else D = A.length, I = B.mask && B.readOnly && !Z;
      let Y = D;
      if (D >= 65536) G += 8, Y = 127;
      else if (D > 125) G += 2, Y = 126;
      let W = Buffer.allocUnsafe(I ? D + G : G);
      if (W[0] = B.fin ? B.opcode | 128 : B.opcode, B.rsv1) W[0] |= 64;
      if (W[1] = Y, Y === 126) W.writeUInt16BE(D, 2);
      else if (Y === 127) W[2] = W[3] = 0, W.writeUIntBE(D, 4, 6);
      if (!B.mask) return [W, A];
      if (W[1] |= 128, W[G - 4] = Q[0], W[G - 3] = Q[1], W[G - 2] = Q[2], W[G - 1] = Q[3], Z) return [W, A];
      if (I) return TgA(A, Q, W, G, D), [W];
      return TgA(A, Q, A, 0, D), [W, A]
    }
    close(A, B, Q, I) {
      let G;
      if (A === void 0) G = xe9;
      else if (typeof A !== "number" || !be9(A)) throw new TypeError("First argument must be a valid error code number");
      else if (B === void 0 || !B.length) G = Buffer.allocUnsafe(2), G.writeUInt16BE(A, 0);
      else {
        let D = Buffer.byteLength(B);
        if (D > 123) throw new RangeError("The message must not be greater than 123 bytes");
        if (G = Buffer.allocUnsafe(2 + D), G.writeUInt16BE(A, 0), typeof B === "string") G.write(B, 2);
        else G.set(B, 2)
      }
      let Z = {
        [QX]: G.length,
        fin: !0,
        generateMask: this._generateMask,
        mask: Q,
        maskBuffer: this._maskBuffer,
        opcode: 8,
        readOnly: !1,
        rsv1: !1
      };
      if (this._state !== wC) this.enqueue([this.dispatch, G, !1, Z, I]);
      else this.sendFrame(WL.frame(G, Z), I)
    }
    ping(A, B, Q) {
      let I, G;
      if (typeof A === "string") I = Buffer.byteLength(A), G = !1;
      else if (iv(A)) I = A.size, G = !1;
      else A = TS(A), I = A.length, G = TS.readOnly;
      if (I > 125) throw new RangeError("The data size must not be greater than 125 bytes");
      let Z = {
        [QX]: I,
        fin: !0,
        generateMask: this._generateMask,
        mask: B,
        maskBuffer: this._maskBuffer,
        opcode: 9,
        readOnly: G,
        rsv1: !1
      };
      if (iv(A))
        if (this._state !== wC) this.enqueue([this.getBlobData, A, !1, Z, Q]);
        else this.getBlobData(A, !1, Z, Q);
      else if (this._state !== wC) this.enqueue([this.dispatch, A, !1, Z, Q]);
      else this.sendFrame(WL.frame(A, Z), Q)
    }
    pong(A, B, Q) {
      let I, G;
      if (typeof A === "string") I = Buffer.byteLength(A), G = !1;
      else if (iv(A)) I = A.size, G = !1;
      else A = TS(A), I = A.length, G = TS.readOnly;
      if (I > 125) throw new RangeError("The data size must not be greater than 125 bytes");
      let Z = {
        [QX]: I,
        fin: !0,
        generateMask: this._generateMask,
        mask: B,
        maskBuffer: this._maskBuffer,
        opcode: 10,
        readOnly: G,
        rsv1: !1
      };
      if (iv(A))
        if (this._state !== wC) this.enqueue([this.getBlobData, A, !1, Z, Q]);
        else this.getBlobData(A, !1, Z, Q);
      else if (this._state !== wC) this.enqueue([this.dispatch, A, !1, Z, Q]);
      else this.sendFrame(WL.frame(A, Z), Q)
    }
    send(A, B, Q) {
      let I = this._extensions[OgA.extensionName],
        G = B.binary ? 2 : 1,
        Z = B.compress,
        D, Y;
      if (typeof A === "string") D = Buffer.byteLength(A), Y = !1;
      else if (iv(A)) D = A.size, Y = !1;
      else A = TS(A), D = A.length, Y = TS.readOnly;
      if (this._firstFragment) {
        if (this._firstFragment = !1, Z && I && I.params[I._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) Z = D >= I._threshold;
        this._compress = Z
      } else Z = !1, G = 0;
      if (B.fin) this._firstFragment = !0;
      let W = {
        [QX]: D,
        fin: B.fin,
        generateMask: this._generateMask,
        mask: B.mask,
        maskBuffer: this._maskBuffer,
        opcode: G,
        readOnly: Y,
        rsv1: Z
      };
      if (iv(A))
        if (this._state !== wC) this.enqueue([this.getBlobData, A, this._compress, W, Q]);
        else this.getBlobData(A, this._compress, W, Q);
      else if (this._state !== wC) this.enqueue([this.dispatch, A, this._compress, W, Q]);
      else this.dispatch(A, this._compress, W, Q)
    }
    getBlobData(A, B, Q, I) {
      this._bufferedBytes += Q[QX], this._state = me9, A.arrayBuffer().then((G) => {
        if (this._socket.destroyed) {
          let D = new Error("The socket was closed while the blob was being read");
          process.nextTick(DS1, this, D, I);
          return
        }
        this._bufferedBytes -= Q[QX];
        let Z = TS(G);
        if (!B) this._state = wC, this.sendFrame(WL.frame(Z, Q), I), this.dequeue();
        else this.dispatch(Z, B, Q, I)
      }).catch((G) => {
        process.nextTick(de9, this, G, I)
      })
    }
    dispatch(A, B, Q, I) {
      if (!B) {
        this.sendFrame(WL.frame(A, Q), I);
        return
      }
      let G = this._extensions[OgA.extensionName];
      this._bufferedBytes += Q[QX], this._state = he9, G.compress(A, Q.fin, (Z, D) => {
        if (this._socket.destroyed) {
          let Y = new Error("The socket was closed while data was being compressed");
          DS1(this, Y, I);
          return
        }
        this._bufferedBytes -= Q[QX], this._state = wC, Q.readOnly = !1, this.sendFrame(WL.frame(D, Q), I), this.dequeue()
      })
    }
    dequeue() {
      while (this._state === wC && this._queue.length) {
        let A = this._queue.shift();
        this._bufferedBytes -= A[3][QX], Reflect.apply(A[0], this, A.slice(1))
      }
    }
    enqueue(A) {
      this._bufferedBytes += A[3][QX], this._queue.push(A)
    }
    sendFrame(A, B) {
      if (A.length === 2) this._socket.cork(), this._socket.write(A[0]), this._socket.write(A[1], B), this._socket.uncork();
      else this._socket.write(A[0], B)
    }
  }
  PgA.exports = WL;

  function DS1(A, B, Q) {
    if (typeof Q === "function") Q(B);
    for (let I = 0; I < A._queue.length; I++) {
      let G = A._queue[I],
        Z = G[G.length - 1];
      if (typeof Z === "function") Z(B)
    }
  }

  function de9(A, B, Q) {
    DS1(A, B, Q), A.onerror(B)
  }
})
// @from(Start 2543518, End 2546883)
bgA = z((I48, vgA) => {
  var {
    kForOnEventAttribute: Mn,
    kListener: WS1
  } = AN(), SgA = Symbol("kCode"), _gA = Symbol("kData"), jgA = Symbol("kError"), ygA = Symbol("kMessage"), kgA = Symbol("kReason"), av = Symbol("kTarget"), xgA = Symbol("kType"), fgA = Symbol("kWasClean");
  class JL {
    constructor(A) {
      this[av] = null, this[xgA] = A
    }
    get target() {
      return this[av]
    }
    get type() {
      return this[xgA]
    }
  }
  Object.defineProperty(JL.prototype, "target", {
    enumerable: !0
  });
  Object.defineProperty(JL.prototype, "type", {
    enumerable: !0
  });
  class sv extends JL {
    constructor(A, B = {}) {
      super(A);
      this[SgA] = B.code === void 0 ? 0 : B.code, this[kgA] = B.reason === void 0 ? "" : B.reason, this[fgA] = B.wasClean === void 0 ? !1 : B.wasClean
    }
    get code() {
      return this[SgA]
    }
    get reason() {
      return this[kgA]
    }
    get wasClean() {
      return this[fgA]
    }
  }
  Object.defineProperty(sv.prototype, "code", {
    enumerable: !0
  });
  Object.defineProperty(sv.prototype, "reason", {
    enumerable: !0
  });
  Object.defineProperty(sv.prototype, "wasClean", {
    enumerable: !0
  });
  class Ln extends JL {
    constructor(A, B = {}) {
      super(A);
      this[jgA] = B.error === void 0 ? null : B.error, this[ygA] = B.message === void 0 ? "" : B.message
    }
    get error() {
      return this[jgA]
    }
    get message() {
      return this[ygA]
    }
  }
  Object.defineProperty(Ln.prototype, "error", {
    enumerable: !0
  });
  Object.defineProperty(Ln.prototype, "message", {
    enumerable: !0
  });
  class iB1 extends JL {
    constructor(A, B = {}) {
      super(A);
      this[_gA] = B.data === void 0 ? null : B.data
    }
    get data() {
      return this[_gA]
    }
  }
  Object.defineProperty(iB1.prototype, "data", {
    enumerable: !0
  });
  var ue9 = {
    addEventListener(A, B, Q = {}) {
      for (let G of this.listeners(A))
        if (!Q[Mn] && G[WS1] === B && !G[Mn]) return;
      let I;
      if (A === "message") I = function G(Z, D) {
        let Y = new iB1("message", {
          data: D ? Z : Z.toString()
        });
        Y[av] = this, lB1(B, this, Y)
      };
      else if (A === "close") I = function G(Z, D) {
        let Y = new sv("close", {
          code: Z,
          reason: D.toString(),
          wasClean: this._closeFrameReceived && this._closeFrameSent
        });
        Y[av] = this, lB1(B, this, Y)
      };
      else if (A === "error") I = function G(Z) {
        let D = new Ln("error", {
          error: Z,
          message: Z.message
        });
        D[av] = this, lB1(B, this, D)
      };
      else if (A === "open") I = function G() {
        let Z = new JL("open");
        Z[av] = this, lB1(B, this, Z)
      };
      else return;
      if (I[Mn] = !!Q[Mn], I[WS1] = B, Q.once) this.once(A, I);
      else this.on(A, I)
    },
    removeEventListener(A, B) {
      for (let Q of this.listeners(A))
        if (Q[WS1] === B && !Q[Mn]) {
          this.removeListener(A, Q);
          break
        }
    }
  };
  vgA.exports = {
    CloseEvent: sv,
    ErrorEvent: Ln,
    Event: JL,
    EventTarget: ue9,
    MessageEvent: iB1
  };

  function lB1(A, B, Q) {
    if (typeof A === "object" && A.handleEvent) A.handleEvent.call(A, Q);
    else A.call(B, Q)
  }
})
// @from(Start 2546889, End 2550197)
JS1 = z((G48, ggA) => {
  var {
    tokenChars: Rn
  } = lv();

  function Pz(A, B, Q) {
    if (A[B] === void 0) A[B] = [Q];
    else A[B].push(Q)
  }

  function pe9(A) {
    let B = Object.create(null),
      Q = Object.create(null),
      I = !1,
      G = !1,
      Z = !1,
      D, Y, W = -1,
      J = -1,
      F = -1,
      X = 0;
    for (; X < A.length; X++)
      if (J = A.charCodeAt(X), D === void 0)
        if (F === -1 && Rn[J] === 1) {
          if (W === -1) W = X
        } else if (X !== 0 && (J === 32 || J === 9)) {
      if (F === -1 && W !== -1) F = X
    } else if (J === 59 || J === 44) {
      if (W === -1) throw new SyntaxError(`Unexpected character at index ${X}`);
      if (F === -1) F = X;
      let C = A.slice(W, F);
      if (J === 44) Pz(B, C, Q), Q = Object.create(null);
      else D = C;
      W = F = -1
    } else throw new SyntaxError(`Unexpected character at index ${X}`);
    else if (Y === void 0)
      if (F === -1 && Rn[J] === 1) {
        if (W === -1) W = X
      } else if (J === 32 || J === 9) {
      if (F === -1 && W !== -1) F = X
    } else if (J === 59 || J === 44) {
      if (W === -1) throw new SyntaxError(`Unexpected character at index ${X}`);
      if (F === -1) F = X;
      if (Pz(Q, A.slice(W, F), !0), J === 44) Pz(B, D, Q), Q = Object.create(null), D = void 0;
      W = F = -1
    } else if (J === 61 && W !== -1 && F === -1) Y = A.slice(W, X), W = F = -1;
    else throw new SyntaxError(`Unexpected character at index ${X}`);
    else if (G) {
      if (Rn[J] !== 1) throw new SyntaxError(`Unexpected character at index ${X}`);
      if (W === -1) W = X;
      else if (!I) I = !0;
      G = !1
    } else if (Z)
      if (Rn[J] === 1) {
        if (W === -1) W = X
      } else if (J === 34 && W !== -1) Z = !1, F = X;
    else if (J === 92) G = !0;
    else throw new SyntaxError(`Unexpected character at index ${X}`);
    else if (J === 34 && A.charCodeAt(X - 1) === 61) Z = !0;
    else if (F === -1 && Rn[J] === 1) {
      if (W === -1) W = X
    } else if (W !== -1 && (J === 32 || J === 9)) {
      if (F === -1) F = X
    } else if (J === 59 || J === 44) {
      if (W === -1) throw new SyntaxError(`Unexpected character at index ${X}`);
      if (F === -1) F = X;
      let C = A.slice(W, F);
      if (I) C = C.replace(/\\/g, ""), I = !1;
      if (Pz(Q, Y, C), J === 44) Pz(B, D, Q), Q = Object.create(null), D = void 0;
      Y = void 0, W = F = -1
    } else throw new SyntaxError(`Unexpected character at index ${X}`);
    if (W === -1 || Z || J === 32 || J === 9) throw new SyntaxError("Unexpected end of input");
    if (F === -1) F = X;
    let V = A.slice(W, F);
    if (D === void 0) Pz(B, V, Q);
    else {
      if (Y === void 0) Pz(Q, V, !0);
      else if (I) Pz(Q, Y, V.replace(/\\/g, ""));
      else Pz(Q, Y, V);
      Pz(B, D, Q)
    }
    return B
  }

  function ce9(A) {
    return Object.keys(A).map((B) => {
      let Q = A[B];
      if (!Array.isArray(Q)) Q = [Q];
      return Q.map((I) => {
        return [B].concat(Object.keys(I).map((G) => {
          let Z = I[G];
          if (!Array.isArray(Z)) Z = [Z];
          return Z.map((D) => D === !0 ? G : `${G}=${D}`).join("; ")
        })).join("; ")
      }).join(", ")
    }).join(", ")
  }
  ggA.exports = {
    format: ce9,
    parse: pe9
  }
})
// @from(Start 2550203, End 2568567)
rB1 = z((Y48, rgA) => {
  var le9 = Z1("events"),
    ie9 = Z1("https"),
    ne9 = Z1("http"),
    dgA = Z1("net"),
    ae9 = Z1("tls"),
    {
      randomBytes: se9,
      createHash: re9
    } = Z1("crypto"),
    {
      Duplex: Z48,
      Readable: D48
    } = Z1("stream"),
    {
      URL: FS1
    } = Z1("url"),
    FL = qn(),
    oe9 = ZS1(),
    te9 = YS1(),
    {
      isBlob: ee9
    } = lv(),
    {
      BINARY_TYPES: hgA,
      EMPTY_BUFFER: nB1,
      GUID: A14,
      kForOnEventAttribute: XS1,
      kListener: B14,
      kStatusCode: Q14,
      kWebSocket: EI,
      NOOP: ugA
    } = AN(),
    {
      EventTarget: {
        addEventListener: I14,
        removeEventListener: G14
      }
    } = bgA(),
    {
      format: Z14,
      parse: D14
    } = JS1(),
    {
      toBuffer: Y14
    } = Un(),
    pgA = Symbol("kAborted"),
    VS1 = [8, 13],
    QN = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"],
    W14 = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
  class _4 extends le9 {
    constructor(A, B, Q) {
      super();
      if (this._binaryType = hgA[0], this._closeCode = 1006, this._closeFrameReceived = !1, this._closeFrameSent = !1, this._closeMessage = nB1, this._closeTimer = null, this._errorEmitted = !1, this._extensions = {}, this._paused = !1, this._protocol = "", this._readyState = _4.CONNECTING, this._receiver = null, this._sender = null, this._socket = null, A !== null) {
        if (this._bufferedAmount = 0, this._isServer = !1, this._redirects = 0, B === void 0) B = [];
        else if (!Array.isArray(B))
          if (typeof B === "object" && B !== null) Q = B, B = [];
          else B = [B];
        cgA(this, A, B, Q)
      } else this._autoPong = Q.autoPong, this._isServer = !0
    }
    get binaryType() {
      return this._binaryType
    }
    set binaryType(A) {
      if (!hgA.includes(A)) return;
      if (this._binaryType = A, this._receiver) this._receiver._binaryType = A
    }
    get bufferedAmount() {
      if (!this._socket) return this._bufferedAmount;
      return this._socket._writableState.length + this._sender._bufferedBytes
    }
    get extensions() {
      return Object.keys(this._extensions).join()
    }
    get isPaused() {
      return this._paused
    }
    get onclose() {
      return null
    }
    get onerror() {
      return null
    }
    get onopen() {
      return null
    }
    get onmessage() {
      return null
    }
    get protocol() {
      return this._protocol
    }
    get readyState() {
      return this._readyState
    }
    get url() {
      return this._url
    }
    setSocket(A, B, Q) {
      let I = new oe9({
          allowSynchronousEvents: Q.allowSynchronousEvents,
          binaryType: this.binaryType,
          extensions: this._extensions,
          isServer: this._isServer,
          maxPayload: Q.maxPayload,
          skipUTF8Validation: Q.skipUTF8Validation
        }),
        G = new te9(A, this._extensions, Q.generateMask);
      if (this._receiver = I, this._sender = G, this._socket = A, I[EI] = this, G[EI] = this, A[EI] = this, I.on("conclude", X14), I.on("drain", V14), I.on("error", C14), I.on("message", K14), I.on("ping", H14), I.on("pong", z14), G.onerror = w14, A.setTimeout) A.setTimeout(0);
      if (A.setNoDelay) A.setNoDelay();
      if (B.length > 0) A.unshift(B);
      A.on("close", ngA), A.on("data", sB1), A.on("end", agA), A.on("error", sgA), this._readyState = _4.OPEN, this.emit("open")
    }
    emitClose() {
      if (!this._socket) {
        this._readyState = _4.CLOSED, this.emit("close", this._closeCode, this._closeMessage);
        return
      }
      if (this._extensions[FL.extensionName]) this._extensions[FL.extensionName].cleanup();
      this._receiver.removeAllListeners(), this._readyState = _4.CLOSED, this.emit("close", this._closeCode, this._closeMessage)
    }
    close(A, B) {
      if (this.readyState === _4.CLOSED) return;
      if (this.readyState === _4.CONNECTING) {
        XJ(this, this._req, "WebSocket was closed before the connection was established");
        return
      }
      if (this.readyState === _4.CLOSING) {
        if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) this._socket.end();
        return
      }
      this._readyState = _4.CLOSING, this._sender.close(A, B, !this._isServer, (Q) => {
        if (Q) return;
        if (this._closeFrameSent = !0, this._closeFrameReceived || this._receiver._writableState.errorEmitted) this._socket.end()
      }), igA(this)
    }
    pause() {
      if (this.readyState === _4.CONNECTING || this.readyState === _4.CLOSED) return;
      this._paused = !0, this._socket.pause()
    }
    ping(A, B, Q) {
      if (this.readyState === _4.CONNECTING) throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
      if (typeof A === "function") Q = A, A = B = void 0;
      else if (typeof B === "function") Q = B, B = void 0;
      if (typeof A === "number") A = A.toString();
      if (this.readyState !== _4.OPEN) {
        CS1(this, A, Q);
        return
      }
      if (B === void 0) B = !this._isServer;
      this._sender.ping(A || nB1, B, Q)
    }
    pong(A, B, Q) {
      if (this.readyState === _4.CONNECTING) throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
      if (typeof A === "function") Q = A, A = B = void 0;
      else if (typeof B === "function") Q = B, B = void 0;
      if (typeof A === "number") A = A.toString();
      if (this.readyState !== _4.OPEN) {
        CS1(this, A, Q);
        return
      }
      if (B === void 0) B = !this._isServer;
      this._sender.pong(A || nB1, B, Q)
    }
    resume() {
      if (this.readyState === _4.CONNECTING || this.readyState === _4.CLOSED) return;
      if (this._paused = !1, !this._receiver._writableState.needDrain) this._socket.resume()
    }
    send(A, B, Q) {
      if (this.readyState === _4.CONNECTING) throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
      if (typeof B === "function") Q = B, B = {};
      if (typeof A === "number") A = A.toString();
      if (this.readyState !== _4.OPEN) {
        CS1(this, A, Q);
        return
      }
      let I = {
        binary: typeof A !== "string",
        mask: !this._isServer,
        compress: !0,
        fin: !0,
        ...B
      };
      if (!this._extensions[FL.extensionName]) I.compress = !1;
      this._sender.send(A || nB1, I, Q)
    }
    terminate() {
      if (this.readyState === _4.CLOSED) return;
      if (this.readyState === _4.CONNECTING) {
        XJ(this, this._req, "WebSocket was closed before the connection was established");
        return
      }
      if (this._socket) this._readyState = _4.CLOSING, this._socket.destroy()
    }
  }
  Object.defineProperty(_4, "CONNECTING", {
    enumerable: !0,
    value: QN.indexOf("CONNECTING")
  });
  Object.defineProperty(_4.prototype, "CONNECTING", {
    enumerable: !0,
    value: QN.indexOf("CONNECTING")
  });
  Object.defineProperty(_4, "OPEN", {
    enumerable: !0,
    value: QN.indexOf("OPEN")
  });
  Object.defineProperty(_4.prototype, "OPEN", {
    enumerable: !0,
    value: QN.indexOf("OPEN")
  });
  Object.defineProperty(_4, "CLOSING", {
    enumerable: !0,
    value: QN.indexOf("CLOSING")
  });
  Object.defineProperty(_4.prototype, "CLOSING", {
    enumerable: !0,
    value: QN.indexOf("CLOSING")
  });
  Object.defineProperty(_4, "CLOSED", {
    enumerable: !0,
    value: QN.indexOf("CLOSED")
  });
  Object.defineProperty(_4.prototype, "CLOSED", {
    enumerable: !0,
    value: QN.indexOf("CLOSED")
  });
  ["binaryType", "bufferedAmount", "extensions", "isPaused", "protocol", "readyState", "url"].forEach((A) => {
    Object.defineProperty(_4.prototype, A, {
      enumerable: !0
    })
  });
  ["open", "error", "close", "message"].forEach((A) => {
    Object.defineProperty(_4.prototype, `on${A}`, {
      enumerable: !0,
      get() {
        for (let B of this.listeners(A))
          if (B[XS1]) return B[B14];
        return null
      },
      set(B) {
        for (let Q of this.listeners(A))
          if (Q[XS1]) {
            this.removeListener(A, Q);
            break
          } if (typeof B !== "function") return;
        this.addEventListener(A, B, {
          [XS1]: !0
        })
      }
    })
  });
  _4.prototype.addEventListener = I14;
  _4.prototype.removeEventListener = G14;
  rgA.exports = _4;

  function cgA(A, B, Q, I) {
    let G = {
      allowSynchronousEvents: !0,
      autoPong: !0,
      protocolVersion: VS1[1],
      maxPayload: 104857600,
      skipUTF8Validation: !1,
      perMessageDeflate: !0,
      followRedirects: !1,
      maxRedirects: 10,
      ...I,
      socketPath: void 0,
      hostname: void 0,
      protocol: void 0,
      timeout: void 0,
      method: "GET",
      host: void 0,
      path: void 0,
      port: void 0
    };
    if (A._autoPong = G.autoPong, !VS1.includes(G.protocolVersion)) throw new RangeError(`Unsupported protocol version: ${G.protocolVersion} (supported versions: ${VS1.join(", ")})`);
    let Z;
    if (B instanceof FS1) Z = B;
    else try {
      Z = new FS1(B)
    } catch (E) {
      throw new SyntaxError(`Invalid URL: ${B}`)
    }
    if (Z.protocol === "http:") Z.protocol = "ws:";
    else if (Z.protocol === "https:") Z.protocol = "wss:";
    A._url = Z.href;
    let D = Z.protocol === "wss:",
      Y = Z.protocol === "ws+unix:",
      W;
    if (Z.protocol !== "ws:" && !D && !Y) W = `The URL's protocol must be one of "ws:", "wss:", "http:", "https", or "ws+unix:"`;
    else if (Y && !Z.pathname) W = "The URL's pathname is empty";
    else if (Z.hash) W = "The URL contains a fragment identifier";
    if (W) {
      let E = new SyntaxError(W);
      if (A._redirects === 0) throw E;
      else {
        aB1(A, E);
        return
      }
    }
    let J = D ? 443 : 80,
      F = se9(16).toString("base64"),
      X = D ? ie9.request : ne9.request,
      V = new Set,
      C;
    if (G.createConnection = G.createConnection || (D ? F14 : J14), G.defaultPort = G.defaultPort || J, G.port = Z.port || J, G.host = Z.hostname.startsWith("[") ? Z.hostname.slice(1, -1) : Z.hostname, G.headers = {
        ...G.headers,
        "Sec-WebSocket-Version": G.protocolVersion,
        "Sec-WebSocket-Key": F,
        Connection: "Upgrade",
        Upgrade: "websocket"
      }, G.path = Z.pathname + Z.search, G.timeout = G.handshakeTimeout, G.perMessageDeflate) C = new FL(G.perMessageDeflate !== !0 ? G.perMessageDeflate : {}, !1, G.maxPayload), G.headers["Sec-WebSocket-Extensions"] = Z14({
      [FL.extensionName]: C.offer()
    });
    if (Q.length) {
      for (let E of Q) {
        if (typeof E !== "string" || !W14.test(E) || V.has(E)) throw new SyntaxError("An invalid or duplicated subprotocol was specified");
        V.add(E)
      }
      G.headers["Sec-WebSocket-Protocol"] = Q.join(",")
    }
    if (G.origin)
      if (G.protocolVersion < 13) G.headers["Sec-WebSocket-Origin"] = G.origin;
      else G.headers.Origin = G.origin;
    if (Z.username || Z.password) G.auth = `${Z.username}:${Z.password}`;
    if (Y) {
      let E = G.path.split(":");
      G.socketPath = E[0], G.path = E[1]
    }
    let K;
    if (G.followRedirects) {
      if (A._redirects === 0) {
        A._originalIpc = Y, A._originalSecure = D, A._originalHostOrSocketPath = Y ? G.socketPath : Z.host;
        let E = I && I.headers;
        if (I = {
            ...I,
            headers: {}
          }, E)
          for (let [N, q] of Object.entries(E)) I.headers[N.toLowerCase()] = q
      } else if (A.listenerCount("redirect") === 0) {
        let E = Y ? A._originalIpc ? G.socketPath === A._originalHostOrSocketPath : !1 : A._originalIpc ? !1 : Z.host === A._originalHostOrSocketPath;
        if (!E || A._originalSecure && !D) {
          if (delete G.headers.authorization, delete G.headers.cookie, !E) delete G.headers.host;
          G.auth = void 0
        }
      }
      if (G.auth && !I.headers.authorization) I.headers.authorization = "Basic " + Buffer.from(G.auth).toString("base64");
      if (K = A._req = X(G), A._redirects) A.emit("redirect", A.url, K)
    } else K = A._req = X(G);
    if (G.timeout) K.on("timeout", () => {
      XJ(A, K, "Opening handshake has timed out")
    });
    if (K.on("error", (E) => {
        if (K === null || K[pgA]) return;
        K = A._req = null, aB1(A, E)
      }), K.on("response", (E) => {
        let N = E.headers.location,
          q = E.statusCode;
        if (N && G.followRedirects && q >= 300 && q < 400) {
          if (++A._redirects > G.maxRedirects) {
            XJ(A, K, "Maximum redirects exceeded");
            return
          }
          K.abort();
          let O;
          try {
            O = new FS1(N, B)
          } catch (R) {
            let T = new SyntaxError(`Invalid URL: ${N}`);
            aB1(A, T);
            return
          }
          cgA(A, O, Q, I)
        } else if (!A.emit("unexpected-response", K, E)) XJ(A, K, `Unexpected server response: ${E.statusCode}`)
      }), K.on("upgrade", (E, N, q) => {
        if (A.emit("upgrade", E), A.readyState !== _4.CONNECTING) return;
        K = A._req = null;
        let O = E.headers.upgrade;
        if (O === void 0 || O.toLowerCase() !== "websocket") {
          XJ(A, N, "Invalid Upgrade header");
          return
        }
        let R = re9("sha1").update(F + A14).digest("base64");
        if (E.headers["sec-websocket-accept"] !== R) {
          XJ(A, N, "Invalid Sec-WebSocket-Accept header");
          return
        }
        let T = E.headers["sec-websocket-protocol"],
          L;
        if (T !== void 0) {
          if (!V.size) L = "Server sent a subprotocol but none was requested";
          else if (!V.has(T)) L = "Server sent an invalid subprotocol"
        } else if (V.size) L = "Server sent no subprotocol";
        if (L) {
          XJ(A, N, L);
          return
        }
        if (T) A._protocol = T;
        let _ = E.headers["sec-websocket-extensions"];
        if (_ !== void 0) {
          if (!C) {
            XJ(A, N, "Server sent a Sec-WebSocket-Extensions header but no extension was requested");
            return
          }
          let k;
          try {
            k = D14(_)
          } catch (x) {
            XJ(A, N, "Invalid Sec-WebSocket-Extensions header");
            return
          }
          let i = Object.keys(k);
          if (i.length !== 1 || i[0] !== FL.extensionName) {
            XJ(A, N, "Server indicated an extension that was not requested");
            return
          }
          try {
            C.accept(k[FL.extensionName])
          } catch (x) {
            XJ(A, N, "Invalid Sec-WebSocket-Extensions header");
            return
          }
          A._extensions[FL.extensionName] = C
        }
        A.setSocket(N, q, {
          allowSynchronousEvents: G.allowSynchronousEvents,
          generateMask: G.generateMask,
          maxPayload: G.maxPayload,
          skipUTF8Validation: G.skipUTF8Validation
        })
      }), G.finishRequest) G.finishRequest(K, A);
    else K.end()
  }

  function aB1(A, B) {
    A._readyState = _4.CLOSING, A._errorEmitted = !0, A.emit("error", B), A.emitClose()
  }

  function J14(A) {
    return A.path = A.socketPath, dgA.connect(A)
  }

  function F14(A) {
    if (A.path = void 0, !A.servername && A.servername !== "") A.servername = dgA.isIP(A.host) ? "" : A.host;
    return ae9.connect(A)
  }

  function XJ(A, B, Q) {
    A._readyState = _4.CLOSING;
    let I = new Error(Q);
    if (Error.captureStackTrace(I, XJ), B.setHeader) {
      if (B[pgA] = !0, B.abort(), B.socket && !B.socket.destroyed) B.socket.destroy();
      process.nextTick(aB1, A, I)
    } else B.destroy(I), B.once("error", A.emit.bind(A, "error")), B.once("close", A.emitClose.bind(A))
  }

  function CS1(A, B, Q) {
    if (B) {
      let I = ee9(B) ? B.size : Y14(B).length;
      if (A._socket) A._sender._bufferedBytes += I;
      else A._bufferedAmount += I
    }
    if (Q) {
      let I = new Error(`WebSocket is not open: readyState ${A.readyState} (${QN[A.readyState]})`);
      process.nextTick(Q, I)
    }
  }

  function X14(A, B) {
    let Q = this[EI];
    if (Q._closeFrameReceived = !0, Q._closeMessage = B, Q._closeCode = A, Q._socket[EI] === void 0) return;
    if (Q._socket.removeListener("data", sB1), process.nextTick(lgA, Q._socket), A === 1005) Q.close();
    else Q.close(A, B)
  }

  function V14() {
    let A = this[EI];
    if (!A.isPaused) A._socket.resume()
  }

  function C14(A) {
    let B = this[EI];
    if (B._socket[EI] !== void 0) B._socket.removeListener("data", sB1), process.nextTick(lgA, B._socket), B.close(A[Q14]);
    if (!B._errorEmitted) B._errorEmitted = !0, B.emit("error", A)
  }

  function mgA() {
    this[EI].emitClose()
  }

  function K14(A, B) {
    this[EI].emit("message", A, B)
  }

  function H14(A) {
    let B = this[EI];
    if (B._autoPong) B.pong(A, !this._isServer, ugA);
    B.emit("ping", A)
  }

  function z14(A) {
    this[EI].emit("pong", A)
  }

  function lgA(A) {
    A.resume()
  }

  function w14(A) {
    let B = this[EI];
    if (B.readyState === _4.CLOSED) return;
    if (B.readyState === _4.OPEN) B._readyState = _4.CLOSING, igA(B);
    if (this._socket.end(), !B._errorEmitted) B._errorEmitted = !0, B.emit("error", A)
  }

  function igA(A) {
    A._closeTimer = setTimeout(A._socket.destroy.bind(A._socket), 30000)
  }

  function ngA() {
    let A = this[EI];
    this.removeListener("close", ngA), this.removeListener("data", sB1), this.removeListener("end", agA), A._readyState = _4.CLOSING;
    let B;
    if (!this._readableState.endEmitted && !A._closeFrameReceived && !A._receiver._writableState.errorEmitted && (B = A._socket.read()) !== null) A._receiver.write(B);
    if (A._receiver.end(), this[EI] = void 0, clearTimeout(A._closeTimer), A._receiver._writableState.finished || A._receiver._writableState.errorEmitted) A.emitClose();
    else A._receiver.on("error", mgA), A._receiver.on("finish", mgA)
  }

  function sB1(A) {
    if (!this[EI]._receiver.write(A)) this.pause()
  }

  function agA() {
    let A = this[EI];
    A._readyState = _4.CLOSING, A._receiver.end(), this.end()
  }

  function sgA() {
    let A = this[EI];
    if (this.removeListener("error", sgA), this.on("error", ugA), A) A._readyState = _4.CLOSING, this.destroy()
  }
})
// @from(Start 2568573, End 2570553)
AhA = z((J48, egA) => {
  var W48 = rB1(),
    {
      Duplex: E14
    } = Z1("stream");

  function ogA(A) {
    A.emit("close")
  }

  function U14() {
    if (!this.destroyed && this._writableState.finished) this.destroy()
  }

  function tgA(A) {
    if (this.removeListener("error", tgA), this.destroy(), this.listenerCount("error") === 0) this.emit("error", A)
  }

  function N14(A, B) {
    let Q = !0,
      I = new E14({
        ...B,
        autoDestroy: !1,
        emitClose: !1,
        objectMode: !1,
        writableObjectMode: !1
      });
    return A.on("message", function G(Z, D) {
      let Y = !D && I._readableState.objectMode ? Z.toString() : Z;
      if (!I.push(Y)) A.pause()
    }), A.once("error", function G(Z) {
      if (I.destroyed) return;
      Q = !1, I.destroy(Z)
    }), A.once("close", function G() {
      if (I.destroyed) return;
      I.push(null)
    }), I._destroy = function(G, Z) {
      if (A.readyState === A.CLOSED) {
        Z(G), process.nextTick(ogA, I);
        return
      }
      let D = !1;
      if (A.once("error", function Y(W) {
          D = !0, Z(W)
        }), A.once("close", function Y() {
          if (!D) Z(G);
          process.nextTick(ogA, I)
        }), Q) A.terminate()
    }, I._final = function(G) {
      if (A.readyState === A.CONNECTING) {
        A.once("open", function Z() {
          I._final(G)
        });
        return
      }
      if (A._socket === null) return;
      if (A._socket._writableState.finished) {
        if (G(), I._readableState.endEmitted) I.destroy()
      } else A._socket.once("finish", function Z() {
        G()
      }), A.close()
    }, I._read = function() {
      if (A.isPaused) A.resume()
    }, I._write = function(G, Z, D) {
      if (A.readyState === A.CONNECTING) {
        A.once("open", function Y() {
          I._write(G, Z, D)
        });
        return
      }
      A.send(G, D)
    }, I.on("end", U14), I.on("error", tgA), I
  }
  egA.exports = N14
})
// @from(Start 2570559, End 2571548)
QhA = z((F48, BhA) => {
  var {
    tokenChars: $14
  } = lv();

  function q14(A) {
    let B = new Set,
      Q = -1,
      I = -1,
      G = 0;
    for (G; G < A.length; G++) {
      let D = A.charCodeAt(G);
      if (I === -1 && $14[D] === 1) {
        if (Q === -1) Q = G
      } else if (G !== 0 && (D === 32 || D === 9)) {
        if (I === -1 && Q !== -1) I = G
      } else if (D === 44) {
        if (Q === -1) throw new SyntaxError(`Unexpected character at index ${G}`);
        if (I === -1) I = G;
        let Y = A.slice(Q, I);
        if (B.has(Y)) throw new SyntaxError(`The "${Y}" subprotocol is duplicated`);
        B.add(Y), Q = I = -1
      } else throw new SyntaxError(`Unexpected character at index ${G}`)
    }
    if (Q === -1 || I !== -1) throw new SyntaxError("Unexpected end of input");
    let Z = A.slice(Q, G);
    if (B.has(Z)) throw new SyntaxError(`The "${Z}" subprotocol is duplicated`);
    return B.add(Z), B
  }
  BhA.exports = {
    parse: q14
  }
})
// @from(Start 2571554, End 2579166)
YhA = z((V48, DhA) => {
  var M14 = Z1("events"),
    oB1 = Z1("http"),
    {
      Duplex: X48
    } = Z1("stream"),
    {
      createHash: L14
    } = Z1("crypto"),
    IhA = JS1(),
    SS = qn(),
    R14 = QhA(),
    O14 = rB1(),
    {
      GUID: T14,
      kWebSocket: P14
    } = AN(),
    S14 = /^[+/0-9A-Za-z]{22}==$/;
  class ZhA extends M14 {
    constructor(A, B) {
      super();
      if (A = {
          allowSynchronousEvents: !0,
          autoPong: !0,
          maxPayload: 104857600,
          skipUTF8Validation: !1,
          perMessageDeflate: !1,
          handleProtocols: null,
          clientTracking: !0,
          verifyClient: null,
          noServer: !1,
          backlog: null,
          server: null,
          host: null,
          path: null,
          port: null,
          WebSocket: O14,
          ...A
        }, A.port == null && !A.server && !A.noServer || A.port != null && (A.server || A.noServer) || A.server && A.noServer) throw new TypeError('One and only one of the "port", "server", or "noServer" options must be specified');
      if (A.port != null) this._server = oB1.createServer((Q, I) => {
        let G = oB1.STATUS_CODES[426];
        I.writeHead(426, {
          "Content-Length": G.length,
          "Content-Type": "text/plain"
        }), I.end(G)
      }), this._server.listen(A.port, A.host, A.backlog, B);
      else if (A.server) this._server = A.server;
      if (this._server) {
        let Q = this.emit.bind(this, "connection");
        this._removeListeners = _14(this._server, {
          listening: this.emit.bind(this, "listening"),
          error: this.emit.bind(this, "error"),
          upgrade: (I, G, Z) => {
            this.handleUpgrade(I, G, Z, Q)
          }
        })
      }
      if (A.perMessageDeflate === !0) A.perMessageDeflate = {};
      if (A.clientTracking) this.clients = new Set, this._shouldEmitClose = !1;
      this.options = A, this._state = 0
    }
    address() {
      if (this.options.noServer) throw new Error('The server is operating in "noServer" mode');
      if (!this._server) return null;
      return this._server.address()
    }
    close(A) {
      if (this._state === 2) {
        if (A) this.once("close", () => {
          A(new Error("The server is not running"))
        });
        process.nextTick(On, this);
        return
      }
      if (A) this.once("close", A);
      if (this._state === 1) return;
      if (this._state = 1, this.options.noServer || this.options.server) {
        if (this._server) this._removeListeners(), this._removeListeners = this._server = null;
        if (this.clients)
          if (!this.clients.size) process.nextTick(On, this);
          else this._shouldEmitClose = !0;
        else process.nextTick(On, this)
      } else {
        let B = this._server;
        this._removeListeners(), this._removeListeners = this._server = null, B.close(() => {
          On(this)
        })
      }
    }
    shouldHandle(A) {
      if (this.options.path) {
        let B = A.url.indexOf("?");
        if ((B !== -1 ? A.url.slice(0, B) : A.url) !== this.options.path) return !1
      }
      return !0
    }
    handleUpgrade(A, B, Q, I) {
      B.on("error", GhA);
      let G = A.headers["sec-websocket-key"],
        Z = A.headers.upgrade,
        D = +A.headers["sec-websocket-version"];
      if (A.method !== "GET") {
        _S(this, A, B, 405, "Invalid HTTP method");
        return
      }
      if (Z === void 0 || Z.toLowerCase() !== "websocket") {
        _S(this, A, B, 400, "Invalid Upgrade header");
        return
      }
      if (G === void 0 || !S14.test(G)) {
        _S(this, A, B, 400, "Missing or invalid Sec-WebSocket-Key header");
        return
      }
      if (D !== 8 && D !== 13) {
        _S(this, A, B, 400, "Missing or invalid Sec-WebSocket-Version header");
        return
      }
      if (!this.shouldHandle(A)) {
        Tn(B, 400);
        return
      }
      let Y = A.headers["sec-websocket-protocol"],
        W = new Set;
      if (Y !== void 0) try {
        W = R14.parse(Y)
      } catch (X) {
        _S(this, A, B, 400, "Invalid Sec-WebSocket-Protocol header");
        return
      }
      let J = A.headers["sec-websocket-extensions"],
        F = {};
      if (this.options.perMessageDeflate && J !== void 0) {
        let X = new SS(this.options.perMessageDeflate, !0, this.options.maxPayload);
        try {
          let V = IhA.parse(J);
          if (V[SS.extensionName]) X.accept(V[SS.extensionName]), F[SS.extensionName] = X
        } catch (V) {
          _S(this, A, B, 400, "Invalid or unacceptable Sec-WebSocket-Extensions header");
          return
        }
      }
      if (this.options.verifyClient) {
        let X = {
          origin: A.headers[`${D===8?"sec-websocket-origin":"origin"}`],
          secure: !!(A.socket.authorized || A.socket.encrypted),
          req: A
        };
        if (this.options.verifyClient.length === 2) {
          this.options.verifyClient(X, (V, C, K, E) => {
            if (!V) return Tn(B, C || 401, K, E);
            this.completeUpgrade(F, G, W, A, B, Q, I)
          });
          return
        }
        if (!this.options.verifyClient(X)) return Tn(B, 401)
      }
      this.completeUpgrade(F, G, W, A, B, Q, I)
    }
    completeUpgrade(A, B, Q, I, G, Z, D) {
      if (!G.readable || !G.writable) return G.destroy();
      if (G[P14]) throw new Error("server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration");
      if (this._state > 0) return Tn(G, 503);
      let W = ["HTTP/1.1 101 Switching Protocols", "Upgrade: websocket", "Connection: Upgrade", `Sec-WebSocket-Accept: ${L14("sha1").update(B+T14).digest("base64")}`],
        J = new this.options.WebSocket(null, void 0, this.options);
      if (Q.size) {
        let F = this.options.handleProtocols ? this.options.handleProtocols(Q, I) : Q.values().next().value;
        if (F) W.push(`Sec-WebSocket-Protocol: ${F}`), J._protocol = F
      }
      if (A[SS.extensionName]) {
        let F = A[SS.extensionName].params,
          X = IhA.format({
            [SS.extensionName]: [F]
          });
        W.push(`Sec-WebSocket-Extensions: ${X}`), J._extensions = A
      }
      if (this.emit("headers", W, I), G.write(W.concat(`\r
`).join(`\r
`)), G.removeListener("error", GhA), J.setSocket(G, Z, {
          allowSynchronousEvents: this.options.allowSynchronousEvents,
          maxPayload: this.options.maxPayload,
          skipUTF8Validation: this.options.skipUTF8Validation
        }), this.clients) this.clients.add(J), J.on("close", () => {
        if (this.clients.delete(J), this._shouldEmitClose && !this.clients.size) process.nextTick(On, this)
      });
      D(J, I)
    }
  }
  DhA.exports = ZhA;

  function _14(A, B) {
    for (let Q of Object.keys(B)) A.on(Q, B[Q]);
    return function Q() {
      for (let I of Object.keys(B)) A.removeListener(I, B[I])
    }
  }

  function On(A) {
    A._state = 2, A.emit("close")
  }

  function GhA() {
    this.destroy()
  }

  function Tn(A, B, Q, I) {
    Q = Q || oB1.STATUS_CODES[B], I = {
      Connection: "close",
      "Content-Type": "text/html",
      "Content-Length": Buffer.byteLength(Q),
      ...I
    }, A.once("finish", A.destroy), A.end(`HTTP/1.1 ${B} ${oB1.STATUS_CODES[B]}\r
` + Object.keys(I).map((G) => `${G}: ${I[G]}`).join(`\r
`) + `\r
\r
` + Q)
  }

  function _S(A, B, Q, I, G) {
    if (A.listenerCount("wsClientError")) {
      let Z = new Error(G);
      Error.captureStackTrace(Z, _S), A.emit("wsClientError", Z, Q, B)
    } else Tn(Q, I, G)
  }
})
// @from(Start 2579172, End 2579175)
j14
// @from(Start 2579177, End 2579180)
y14
// @from(Start 2579182, End 2579185)
k14
// @from(Start 2579187, End 2579190)
tB1
// @from(Start 2579192, End 2579195)
x14
// @from(Start 2579197, End 2579199)
XL
// @from(Start 2579205, End 2579344)
eB1 = J21(() => {
  j14 = I1(AhA(), 1), y14 = I1(ZS1(), 1), k14 = I1(YS1(), 1), tB1 = I1(rB1(), 1), x14 = I1(YhA(), 1), XL = tB1.default
})
// @from(Start 2579350, End 2579353)
A31
// @from(Start 2579359, End 2580112)
WhA = J21(() => {
  eB1();
  A31 = global;
  A31.WebSocket ||= XL;
  A31.window ||= global;
  A31.self ||= global;
  A31.window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ = [{
    type: 1,
    value: 7,
    isEnabled: !0
  }, {
    type: 2,
    value: "InternalApp",
    isEnabled: !0,
    isValid: !0
  }, {
    type: 2,
    value: "InternalAppContext",
    isEnabled: !0,
    isValid: !0
  }, {
    type: 2,
    value: "InternalStdoutContext",
    isEnabled: !0,
    isValid: !0
  }, {
    type: 2,
    value: "InternalStderrContext",
    isEnabled: !0,
    isValid: !0
  }, {
    type: 2,
    value: "InternalStdinContext",
    isEnabled: !0,
    isValid: !0
  }, {
    type: 2,
    value: "InternalFocusContext",
    isEnabled: !0,
    isValid: !0
  }]
})
// @from(Start 2580118, End 2988203)
JhA = z((B31, KS1) => {
  (function A(B, Q) {
    if (typeof B31 === "object" && typeof KS1 === "object") KS1.exports = Q();
    else if (typeof define === "function" && define.amd) define([], Q);
    else if (typeof B31 === "object") B31.ReactDevToolsBackend = Q();
    else B.ReactDevToolsBackend = Q()
  })(self, () => {
    return (() => {
      var A = {
          786: (G, Z, D) => {
            var Y;

            function W(e1) {
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") W = function k1(Q1) {
                return typeof Q1
              };
              else W = function k1(Q1) {
                return Q1 && typeof Symbol === "function" && Q1.constructor === Symbol && Q1 !== Symbol.prototype ? "symbol" : typeof Q1
              };
              return W(e1)
            }
            var J = D(206),
              F = D(189),
              X = Object.assign,
              V = F.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
              C = Symbol.for("react.context"),
              K = Symbol.for("react.memo_cache_sentinel"),
              E = Object.prototype.hasOwnProperty,
              N = [],
              q = null;

            function O() {
              if (q === null) {
                var e1 = new Map;
                try {
                  if (x.useContext({
                      _currentValue: null
                    }), x.useState(null), x.useReducer(function(L1) {
                      return L1
                    }, null), x.useRef(null), typeof x.useCacheRefresh === "function" && x.useCacheRefresh(), x.useLayoutEffect(function() {}), x.useInsertionEffect(function() {}), x.useEffect(function() {}), x.useImperativeHandle(void 0, function() {
                      return null
                    }), x.useDebugValue(null), x.useCallback(function() {}), x.useTransition(), x.useSyncExternalStore(function() {
                      return function() {}
                    }, function() {
                      return null
                    }, function() {
                      return null
                    }), x.useDeferredValue(null), x.useMemo(function() {
                      return null
                    }), typeof x.useMemoCache === "function" && x.useMemoCache(0), typeof x.useOptimistic === "function" && x.useOptimistic(null, function(L1) {
                      return L1
                    }), typeof x.useFormState === "function" && x.useFormState(function(L1) {
                      return L1
                    }, null), typeof x.useActionState === "function" && x.useActionState(function(L1) {
                      return L1
                    }, null), typeof x.use === "function") {
                    x.use({
                      $$typeof: C,
                      _currentValue: null
                    }), x.use({
                      then: function L1() {},
                      status: "fulfilled",
                      value: null
                    });
                    try {
                      x.use({
                        then: function L1() {}
                      })
                    } catch (L1) {}
                  }
                  x.useId(), typeof x.useHostTransitionStatus === "function" && x.useHostTransitionStatus()
                } finally {
                  var k1 = N;
                  N = []
                }
                for (var Q1 = 0; Q1 < k1.length; Q1++) {
                  var v1 = k1[Q1];
                  e1.set(v1.primitive, J.parse(v1.stackError))
                }
                q = e1
              }
              return q
            }
            var R = null,
              T = null,
              L = null;

            function _() {
              var e1 = T;
              return e1 !== null && (T = e1.next), e1
            }

            function k(e1) {
              if (R === null) return e1._currentValue;
              if (L === null) throw Error("Context reads do not line up with context dependencies. This is a bug in React Debug Tools.");
              return E.call(L, "memoizedValue") ? (e1 = L.memoizedValue, L = L.next) : e1 = e1._currentValue, e1
            }
            var i = Error("Suspense Exception: This is not a real error! It's an implementation detail of `use` to interrupt the current render. You must either rethrow it immediately, or move the `use` call outside of the `try/catch` block. Capturing without rethrowing will lead to unexpected behavior.\n\nTo handle async errors, wrap your component in an error boundary, or call the promise's `.catch` method and pass the result to `use`"),
              x = {
                use: function e1(k1) {
                  if (k1 !== null && W(k1) === "object") {
                    if (typeof k1.then === "function") {
                      switch (k1.status) {
                        case "fulfilled":
                          var Q1 = k1.value;
                          return N.push({
                            displayName: null,
                            primitive: "Promise",
                            stackError: Error(),
                            value: Q1,
                            debugInfo: k1._debugInfo === void 0 ? null : k1._debugInfo,
                            dispatcherHookName: "Use"
                          }), Q1;
                        case "rejected":
                          throw k1.reason
                      }
                      throw N.push({
                        displayName: null,
                        primitive: "Unresolved",
                        stackError: Error(),
                        value: k1,
                        debugInfo: k1._debugInfo === void 0 ? null : k1._debugInfo,
                        dispatcherHookName: "Use"
                      }), i
                    }
                    if (k1.$$typeof === C) return Q1 = k(k1), N.push({
                      displayName: k1.displayName || "Context",
                      primitive: "Context (use)",
                      stackError: Error(),
                      value: Q1,
                      debugInfo: null,
                      dispatcherHookName: "Use"
                    }), Q1
                  }
                  throw Error("An unsupported type was passed to use(): " + String(k1))
                },
                readContext: k,
                useCacheRefresh: function e1() {
                  var k1 = _();
                  return N.push({
                      displayName: null,
                      primitive: "CacheRefresh",
                      stackError: Error(),
                      value: k1 !== null ? k1.memoizedState : function() {},
                      debugInfo: null,
                      dispatcherHookName: "CacheRefresh"
                    }),
                    function() {}
                },
                useCallback: function e1(k1) {
                  var Q1 = _();
                  return N.push({
                    displayName: null,
                    primitive: "Callback",
                    stackError: Error(),
                    value: Q1 !== null ? Q1.memoizedState[0] : k1,
                    debugInfo: null,
                    dispatcherHookName: "Callback"
                  }), k1
                },
                useContext: function e1(k1) {
                  var Q1 = k(k1);
                  return N.push({
                    displayName: k1.displayName || null,
                    primitive: "Context",
                    stackError: Error(),
                    value: Q1,
                    debugInfo: null,
                    dispatcherHookName: "Context"
                  }), Q1
                },
                useEffect: function e1(k1) {
                  _(), N.push({
                    displayName: null,
                    primitive: "Effect",
                    stackError: Error(),
                    value: k1,
                    debugInfo: null,
                    dispatcherHookName: "Effect"
                  })
                },
                useImperativeHandle: function e1(k1) {
                  _();
                  var Q1 = void 0;
                  k1 !== null && W(k1) === "object" && (Q1 = k1.current), N.push({
                    displayName: null,
                    primitive: "ImperativeHandle",
                    stackError: Error(),
                    value: Q1,
                    debugInfo: null,
                    dispatcherHookName: "ImperativeHandle"
                  })
                },
                useDebugValue: function e1(k1, Q1) {
                  N.push({
                    displayName: null,
                    primitive: "DebugValue",
                    stackError: Error(),
                    value: typeof Q1 === "function" ? Q1(k1) : k1,
                    debugInfo: null,
                    dispatcherHookName: "DebugValue"
                  })
                },
                useLayoutEffect: function e1(k1) {
                  _(), N.push({
                    displayName: null,
                    primitive: "LayoutEffect",
                    stackError: Error(),
                    value: k1,
                    debugInfo: null,
                    dispatcherHookName: "LayoutEffect"
                  })
                },
                useInsertionEffect: function e1(k1) {
                  _(), N.push({
                    displayName: null,
                    primitive: "InsertionEffect",
                    stackError: Error(),
                    value: k1,
                    debugInfo: null,
                    dispatcherHookName: "InsertionEffect"
                  })
                },
                useMemo: function e1(k1) {
                  var Q1 = _();
                  return k1 = Q1 !== null ? Q1.memoizedState[0] : k1(), N.push({
                    displayName: null,
                    primitive: "Memo",
                    stackError: Error(),
                    value: k1,
                    debugInfo: null,
                    dispatcherHookName: "Memo"
                  }), k1
                },
                useMemoCache: function e1(k1) {
                  var Q1 = R;
                  if (Q1 == null) return [];
                  var v1;
                  if (Q1 = (v1 = Q1.updateQueue) == null ? void 0 : v1.memoCache, Q1 == null) return [];
                  if (v1 = Q1.data[Q1.index], v1 === void 0) {
                    v1 = Q1.data[Q1.index] = Array(k1);
                    for (var L1 = 0; L1 < k1; L1++) v1[L1] = K
                  }
                  return Q1.index++, v1
                },
                useOptimistic: function e1(k1) {
                  var Q1 = _();
                  return k1 = Q1 !== null ? Q1.memoizedState : k1, N.push({
                    displayName: null,
                    primitive: "Optimistic",
                    stackError: Error(),
                    value: k1,
                    debugInfo: null,
                    dispatcherHookName: "Optimistic"
                  }), [k1, function() {}]
                },
                useReducer: function e1(k1, Q1, v1) {
                  return k1 = _(), Q1 = k1 !== null ? k1.memoizedState : v1 !== void 0 ? v1(Q1) : Q1, N.push({
                    displayName: null,
                    primitive: "Reducer",
                    stackError: Error(),
                    value: Q1,
                    debugInfo: null,
                    dispatcherHookName: "Reducer"
                  }), [Q1, function() {}]
                },
                useRef: function e1(k1) {
                  var Q1 = _();
                  return k1 = Q1 !== null ? Q1.memoizedState : {
                    current: k1
                  }, N.push({
                    displayName: null,
                    primitive: "Ref",
                    stackError: Error(),
                    value: k1.current,
                    debugInfo: null,
                    dispatcherHookName: "Ref"
                  }), k1
                },
                useState: function e1(k1) {
                  var Q1 = _();
                  return k1 = Q1 !== null ? Q1.memoizedState : typeof k1 === "function" ? k1() : k1, N.push({
                    displayName: null,
                    primitive: "State",
                    stackError: Error(),
                    value: k1,
                    debugInfo: null,
                    dispatcherHookName: "State"
                  }), [k1, function() {}]
                },
                useTransition: function e1() {
                  var k1 = _();
                  return _(), k1 = k1 !== null ? k1.memoizedState : !1, N.push({
                    displayName: null,
                    primitive: "Transition",
                    stackError: Error(),
                    value: k1,
                    debugInfo: null,
                    dispatcherHookName: "Transition"
                  }), [k1, function() {}]
                },
                useSyncExternalStore: function e1(k1, Q1) {
                  return _(), _(), k1 = Q1(), N.push({
                    displayName: null,
                    primitive: "SyncExternalStore",
                    stackError: Error(),
                    value: k1,
                    debugInfo: null,
                    dispatcherHookName: "SyncExternalStore"
                  }), k1
                },
                useDeferredValue: function e1(k1) {
                  var Q1 = _();
                  return k1 = Q1 !== null ? Q1.memoizedState : k1, N.push({
                    displayName: null,
                    primitive: "DeferredValue",
                    stackError: Error(),
                    value: k1,
                    debugInfo: null,
                    dispatcherHookName: "DeferredValue"
                  }), k1
                },
                useId: function e1() {
                  var k1 = _();
                  return k1 = k1 !== null ? k1.memoizedState : "", N.push({
                    displayName: null,
                    primitive: "Id",
                    stackError: Error(),
                    value: k1,
                    debugInfo: null,
                    dispatcherHookName: "Id"
                  }), k1
                },
                useFormState: function e1(k1, Q1) {
                  var v1 = _();
                  _(), _(), k1 = Error();
                  var L1 = null,
                    BA = null;
                  if (v1 !== null)
                    if (Q1 = v1.memoizedState, W(Q1) === "object" && Q1 !== null && typeof Q1.then === "function") switch (Q1.status) {
                      case "fulfilled":
                        var HA = Q1.value;
                        L1 = Q1._debugInfo === void 0 ? null : Q1._debugInfo;
                        break;
                      case "rejected":
                        BA = Q1.reason;
                        break;
                      default:
                        BA = i, L1 = Q1._debugInfo === void 0 ? null : Q1._debugInfo, HA = Q1
                    } else HA = Q1;
                    else HA = Q1;
                  if (N.push({
                      displayName: null,
                      primitive: "FormState",
                      stackError: k1,
                      value: HA,
                      debugInfo: L1,
                      dispatcherHookName: "FormState"
                    }), BA !== null) throw BA;
                  return [HA, function() {}, !1]
                },
                useActionState: function e1(k1, Q1) {
                  var v1 = _();
                  _(), _(), k1 = Error();
                  var L1 = null,
                    BA = null;
                  if (v1 !== null)
                    if (Q1 = v1.memoizedState, W(Q1) === "object" && Q1 !== null && typeof Q1.then === "function") switch (Q1.status) {
                      case "fulfilled":
                        var HA = Q1.value;
                        L1 = Q1._debugInfo === void 0 ? null : Q1._debugInfo;
                        break;
                      case "rejected":
                        BA = Q1.reason;
                        break;
                      default:
                        BA = i, L1 = Q1._debugInfo === void 0 ? null : Q1._debugInfo, HA = Q1
                    } else HA = Q1;
                    else HA = Q1;
                  if (N.push({
                      displayName: null,
                      primitive: "ActionState",
                      stackError: k1,
                      value: HA,
                      debugInfo: L1,
                      dispatcherHookName: "ActionState"
                    }), BA !== null) throw BA;
                  return [HA, function() {}, !1]
                },
                useHostTransitionStatus: function e1() {
                  var k1 = k({
                    _currentValue: null
                  });
                  return N.push({
                    displayName: null,
                    primitive: "HostTransitionStatus",
                    stackError: Error(),
                    value: k1,
                    debugInfo: null,
                    dispatcherHookName: "HostTransitionStatus"
                  }), k1
                }
              },
              s = {
                get: function e1(k1, Q1) {
                  if (k1.hasOwnProperty(Q1)) return k1[Q1];
                  throw k1 = Error("Missing method in Dispatcher: " + Q1), k1.name = "ReactDebugToolsUnsupportedHookError", k1
                }
              },
              d = typeof Proxy === "undefined" ? x : new Proxy(x, s),
              F1 = 0;

            function X1(e1, k1, Q1) {
              var v1 = k1[Q1].source,
                L1 = 0;
              A: for (; L1 < e1.length; L1++)
                if (e1[L1].source === v1) {
                  for (var BA = Q1 + 1, HA = L1 + 1; BA < k1.length && HA < e1.length; BA++, HA++)
                    if (e1[HA].source !== k1[BA].source) continue A;
                  return L1
                }
              return -1
            }

            function v(e1, k1) {
              return e1 = D1(e1), k1 === "HostTransitionStatus" ? e1 === k1 || e1 === "FormStatus" : e1 === k1
            }

            function D1(e1) {
              if (!e1) return "";
              var k1 = e1.lastIndexOf("[as ");
              if (k1 !== -1) return D1(e1.slice(k1 + 4, -1));
              if (k1 = e1.lastIndexOf("."), k1 = k1 === -1 ? 0 : k1 + 1, e1.slice(k1, k1 + 3) === "use") {
                if (e1.length - k1 === 3) return "Use";
                k1 += 3
              }
              return e1.slice(k1)
            }

            function N1(e1, k1) {
              for (var Q1 = [], v1 = null, L1 = Q1, BA = 0, HA = [], MA = 0; MA < k1.length; MA++) {
                var t = k1[MA],
                  B1 = e1,
                  W1 = J.parse(t.stackError);
                A: {
                  var w1 = W1,
                    P1 = X1(w1, B1, F1);
                  if (P1 !== -1) B1 = P1;
                  else {
                    for (var e = 0; e < B1.length && 5 > e; e++)
                      if (P1 = X1(w1, B1, e), P1 !== -1) {
                        F1 = e, B1 = P1;
                        break A
                      } B1 = -1
                  }
                }
                A: {
                  if (w1 = W1, P1 = O().get(t.primitive), P1 !== void 0) {
                    for (e = 0; e < P1.length && e < w1.length; e++)
                      if (P1[e].source !== w1[e].source) {
                        e < w1.length - 1 && v(w1[e].functionName, t.dispatcherHookName) && e++, e < w1.length - 1 && v(w1[e].functionName, t.dispatcherHookName) && e++, w1 = e;
                        break A
                      }
                  }
                  w1 = -1
                }
                if (W1 = B1 === -1 || w1 === -1 || 2 > B1 - w1 ? w1 === -1 ? [null, null] : [W1[w1 - 1], null] : [W1[w1 - 1], W1.slice(w1, B1 - 1)], w1 = W1[0], W1 = W1[1], B1 = t.displayName, B1 === null && w1 !== null && (B1 = D1(w1.functionName) || D1(t.dispatcherHookName)), W1 !== null) {
                  if (w1 = 0, v1 !== null) {
                    for (; w1 < W1.length && w1 < v1.length && W1[W1.length - w1 - 1].source === v1[v1.length - w1 - 1].source;) w1++;
                    for (v1 = v1.length - 1; v1 > w1; v1--) L1 = HA.pop()
                  }
                  for (v1 = W1.length - w1 - 1; 1 <= v1; v1--) w1 = [], P1 = W1[v1], P1 = {
                    id: null,
                    isStateEditable: !1,
                    name: D1(W1[v1 - 1].functionName),
                    value: void 0,
                    subHooks: w1,
                    debugInfo: null,
                    hookSource: {
                      lineNumber: P1.lineNumber,
                      columnNumber: P1.columnNumber,
                      functionName: P1.functionName,
                      fileName: P1.fileName
                    }
                  }, L1.push(P1), HA.push(L1), L1 = w1;
                  v1 = W1
                }
                w1 = t.primitive, P1 = t.debugInfo, t = {
                  id: w1 === "Context" || w1 === "Context (use)" || w1 === "DebugValue" || w1 === "Promise" || w1 === "Unresolved" || w1 === "HostTransitionStatus" ? null : BA++,
                  isStateEditable: w1 === "Reducer" || w1 === "State",
                  name: B1 || w1,
                  value: t.value,
                  subHooks: [],
                  debugInfo: P1,
                  hookSource: null
                }, B1 = {
                  lineNumber: null,
                  functionName: null,
                  fileName: null,
                  columnNumber: null
                }, W1 && 1 <= W1.length && (W1 = W1[0], B1.lineNumber = W1.lineNumber, B1.functionName = W1.functionName, B1.fileName = W1.fileName, B1.columnNumber = W1.columnNumber), t.hookSource = B1, L1.push(t)
              }
              return u1(Q1, null), Q1
            }

            function u1(e1, k1) {
              for (var Q1 = [], v1 = 0; v1 < e1.length; v1++) {
                var L1 = e1[v1];
                L1.name === "DebugValue" && L1.subHooks.length === 0 ? (e1.splice(v1, 1), v1--, Q1.push(L1)) : u1(L1.subHooks, L1)
              }
              k1 !== null && (Q1.length === 1 ? k1.value = Q1[0].value : 1 < Q1.length && (k1.value = Q1.map(function(BA) {
                return BA.value
              })))
            }

            function d1(e1) {
              if (e1 !== i) {
                if (e1 instanceof Error && e1.name === "ReactDebugToolsUnsupportedHookError") throw e1;
                var k1 = Error("Error rendering inspected component", {
                  cause: e1
                });
                throw k1.name = "ReactDebugToolsRenderError", k1.cause = e1, k1
              }
            }

            function YA(e1, k1, Q1) {
              Q1 == null && (Q1 = V);
              var v1 = Q1.H;
              Q1.H = d;
              try {
                var L1 = Error();
                e1(k1)
              } catch (BA) {
                d1(BA)
              } finally {
                e1 = N, N = [], Q1.H = v1
              }
              return Q1 = J.parse(L1), N1(Q1, e1)
            }

            function bA(e1) {
              e1.forEach(function(k1, Q1) {
                return Q1._currentValue = k1
              })
            }
            Y = YA, Z.inspectHooksOfFiber = function(e1, k1) {
              if (k1 == null && (k1 = V), e1.tag !== 0 && e1.tag !== 15 && e1.tag !== 11) throw Error("Unknown Fiber. Needs to be a function component to inspect hooks.");
              if (O(), T = e1.memoizedState, R = e1, E.call(R, "dependencies")) {
                var Q1 = R.dependencies;
                L = Q1 !== null ? Q1.firstContext : null
              } else if (E.call(R, "dependencies_old")) Q1 = R.dependencies_old, L = Q1 !== null ? Q1.firstContext : null;
              else if (E.call(R, "dependencies_new")) Q1 = R.dependencies_new, L = Q1 !== null ? Q1.firstContext : null;
              else if (E.call(R, "contextDependencies")) Q1 = R.contextDependencies, L = Q1 !== null ? Q1.first : null;
              else throw Error("Unsupported React version. This is a bug in React Debug Tools.");
              Q1 = e1.type;
              var v1 = e1.memoizedProps;
              if (Q1 !== e1.elementType && Q1 && Q1.defaultProps) {
                v1 = X({}, v1);
                var L1 = Q1.defaultProps;
                for (BA in L1) v1[BA] === void 0 && (v1[BA] = L1[BA])
              }
              var BA = new Map;
              try {
                if (L !== null && !E.call(L, "memoizedValue"))
                  for (L1 = e1; L1;) {
                    if (L1.tag === 10) {
                      var HA = L1.type;
                      HA._context !== void 0 && (HA = HA._context), BA.has(HA) || (BA.set(HA, HA._currentValue), HA._currentValue = L1.memoizedProps.value)
                    }
                    L1 = L1.return
                  }
                if (e1.tag === 11) {
                  var MA = Q1.render;
                  HA = v1;
                  var t = e1.ref;
                  e1 = k1;
                  var B1 = e1.H;
                  e1.H = d;
                  try {
                    var W1 = Error();
                    MA(HA, t)
                  } catch (e) {
                    d1(e)
                  } finally {
                    var w1 = N;
                    N = [], e1.H = B1
                  }
                  var P1 = J.parse(W1);
                  return N1(P1, w1)
                }
                return YA(Q1, v1, k1)
              } finally {
                L = T = R = null, bA(BA)
              }
            }
          },
          987: (G, Z, D) => {
            G.exports = D(786)
          },
          890: (G, Z) => {
            var D;

            function Y(k) {
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") Y = function i(x) {
                return typeof x
              };
              else Y = function i(x) {
                return x && typeof Symbol === "function" && x.constructor === Symbol && x !== Symbol.prototype ? "symbol" : typeof x
              };
              return Y(k)
            }
            var W = Symbol.for("react.transitional.element"),
              J = Symbol.for("react.portal"),
              F = Symbol.for("react.fragment"),
              X = Symbol.for("react.strict_mode"),
              V = Symbol.for("react.profiler");
            Symbol.for("react.provider");
            var C = Symbol.for("react.consumer"),
              K = Symbol.for("react.context"),
              E = Symbol.for("react.forward_ref"),
              N = Symbol.for("react.suspense"),
              q = Symbol.for("react.suspense_list"),
              O = Symbol.for("react.memo"),
              R = Symbol.for("react.lazy"),
              T = Symbol.for("react.offscreen"),
              L = Symbol.for("react.client.reference");

            function _(k) {
              if (Y(k) === "object" && k !== null) {
                var i = k.$$typeof;
                switch (i) {
                  case W:
                    switch (k = k.type, k) {
                      case F:
                      case V:
                      case X:
                      case N:
                      case q:
                        return k;
                      default:
                        switch (k = k && k.$$typeof, k) {
                          case K:
                          case E:
                          case R:
                          case O:
                            return k;
                          case C:
                            return k;
                          default:
                            return i
                        }
                    }
                  case J:
                    return i
                }
              }
            }
            Z.AI = C, Z.HQ = K, D = W, Z.A4 = E, Z.HY = F, Z.oM = R, Z._Y = O, Z.h_ = J, Z.Q1 = V, Z.nF = X, Z.n4 = N, D = q, D = function(k) {
              return _(k) === C
            }, D = function(k) {
              return _(k) === K
            }, Z.kK = function(k) {
              return Y(k) === "object" && k !== null && k.$$typeof === W
            }, D = function(k) {
              return _(k) === E
            }, D = function(k) {
              return _(k) === F
            }, D = function(k) {
              return _(k) === R
            }, D = function(k) {
              return _(k) === O
            }, D = function(k) {
              return _(k) === J
            }, D = function(k) {
              return _(k) === V
            }, D = function(k) {
              return _(k) === X
            }, D = function(k) {
              return _(k) === N
            }, D = function(k) {
              return _(k) === q
            }, D = function(k) {
              return typeof k === "string" || typeof k === "function" || k === F || k === V || k === X || k === N || k === q || k === T || Y(k) === "object" && k !== null && (k.$$typeof === R || k.$$typeof === O || k.$$typeof === K || k.$$typeof === C || k.$$typeof === E || k.$$typeof === L || k.getModuleId !== void 0) ? !0 : !1
            }, Z.kM = _
          },
          126: (G, Z, D) => {
            var Y = D(169);

            function W(e) {
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") W = function y1(O1) {
                return typeof O1
              };
              else W = function y1(O1) {
                return O1 && typeof Symbol === "function" && O1.constructor === Symbol && O1 !== Symbol.prototype ? "symbol" : typeof O1
              };
              return W(e)
            }
            var J = Symbol.for("react.transitional.element"),
              F = Symbol.for("react.portal"),
              X = Symbol.for("react.fragment"),
              V = Symbol.for("react.strict_mode"),
              C = Symbol.for("react.profiler"),
              K = Symbol.for("react.consumer"),
              E = Symbol.for("react.context"),
              N = Symbol.for("react.forward_ref"),
              q = Symbol.for("react.suspense"),
              O = Symbol.for("react.suspense_list"),
              R = Symbol.for("react.memo"),
              T = Symbol.for("react.lazy"),
              L = Symbol.for("react.debug_trace_mode"),
              _ = Symbol.for("react.offscreen"),
              k = Symbol.for("react.postpone"),
              i = Symbol.iterator;

            function x(e) {
              if (e === null || W(e) !== "object") return null;
              return e = i && e[i] || e["@@iterator"], typeof e === "function" ? e : null
            }
            var s = {
                isMounted: function e() {
                  return !1
                },
                enqueueForceUpdate: function e() {},
                enqueueReplaceState: function e() {},
                enqueueSetState: function e() {}
              },
              d = Object.assign,
              F1 = {};

            function X1(e, y1, O1) {
              this.props = e, this.context = y1, this.refs = F1, this.updater = O1 || s
            }
            X1.prototype.isReactComponent = {}, X1.prototype.setState = function(e, y1) {
              if (W(e) !== "object" && typeof e !== "function" && e != null) throw Error("takes an object of state variables to update or a function which returns an object of state variables.");
              this.updater.enqueueSetState(this, e, y1, "setState")
            }, X1.prototype.forceUpdate = function(e) {
              this.updater.enqueueForceUpdate(this, e, "forceUpdate")
            };

            function v() {}
            v.prototype = X1.prototype;

            function D1(e, y1, O1) {
              this.props = e, this.context = y1, this.refs = F1, this.updater = O1 || s
            }
            var N1 = D1.prototype = new v;
            N1.constructor = D1, d(N1, X1.prototype), N1.isPureReactComponent = !0;
            var u1 = Array.isArray,
              d1 = {
                H: null,
                A: null,
                T: null,
                S: null
              },
              YA = Object.prototype.hasOwnProperty;

            function bA(e, y1, O1, h1, o1, QA, zA) {
              return O1 = zA.ref, {
                $$typeof: J,
                type: e,
                key: y1,
                ref: O1 !== void 0 ? O1 : null,
                props: zA
              }
            }

            function e1(e, y1) {
              return bA(e.type, y1, null, void 0, void 0, void 0, e.props)
            }

            function k1(e) {
              return W(e) === "object" && e !== null && e.$$typeof === J
            }

            function Q1(e) {
              var y1 = {
                "=": "=0",
                ":": "=2"
              };
              return "$" + e.replace(/[=:]/g, function(O1) {
                return y1[O1]
              })
            }
            var v1 = /\/+/g;

            function L1(e, y1) {
              return W(e) === "object" && e !== null && e.key != null ? Q1("" + e.key) : y1.toString(36)
            }

            function BA() {}

            function HA(e) {
              switch (e.status) {
                case "fulfilled":
                  return e.value;
                case "rejected":
                  throw e.reason;
                default:
                  switch (typeof e.status === "string" ? e.then(BA, BA) : (e.status = "pending", e.then(function(y1) {
                      e.status === "pending" && (e.status = "fulfilled", e.value = y1)
                    }, function(y1) {
                      e.status === "pending" && (e.status = "rejected", e.reason = y1)
                    })), e.status) {
                    case "fulfilled":
                      return e.value;
                    case "rejected":
                      throw e.reason
                  }
              }
              throw e
            }

            function MA(e, y1, O1, h1, o1) {
              var QA = W(e);
              if (QA === "undefined" || QA === "boolean") e = null;
              var zA = !1;
              if (e === null) zA = !0;
              else switch (QA) {
                case "bigint":
                case "string":
                case "number":
                  zA = !0;
                  break;
                case "object":
                  switch (e.$$typeof) {
                    case J:
                    case F:
                      zA = !0;
                      break;
                    case T:
                      return zA = e._init, MA(zA(e._payload), y1, O1, h1, o1)
                  }
              }
              if (zA) return o1 = o1(e), zA = h1 === "" ? "." + L1(e, 0) : h1, u1(o1) ? (O1 = "", zA != null && (O1 = zA.replace(v1, "$&/") + "/"), MA(o1, y1, O1, "", function(H0) {
                return H0
              })) : o1 != null && (k1(o1) && (o1 = e1(o1, O1 + (o1.key == null || e && e.key === o1.key ? "" : ("" + o1.key).replace(v1, "$&/") + "/") + zA)), y1.push(o1)), 1;
              zA = 0;
              var Y0 = h1 === "" ? "." : h1 + ":";
              if (u1(e))
                for (var fA = 0; fA < e.length; fA++) h1 = e[fA], QA = Y0 + L1(h1, fA), zA += MA(h1, y1, O1, QA, o1);
              else if (fA = x(e), typeof fA === "function")
                for (e = fA.call(e), fA = 0; !(h1 = e.next()).done;) h1 = h1.value, QA = Y0 + L1(h1, fA++), zA += MA(h1, y1, O1, QA, o1);
              else if (QA === "object") {
                if (typeof e.then === "function") return MA(HA(e), y1, O1, h1, o1);
                throw y1 = String(e), Error("Objects are not valid as a React child (found: " + (y1 === "[object Object]" ? "object with keys {" + Object.keys(e).join(", ") + "}" : y1) + "). If you meant to render a collection of children, use an array instead.")
              }
              return zA
            }

            function t(e, y1, O1) {
              if (e == null) return e;
              var h1 = [],
                o1 = 0;
              return MA(e, h1, "", "", function(QA) {
                return y1.call(O1, QA, o1++)
              }), h1
            }

            function B1(e) {
              if (e._status === -1) {
                var y1 = e._result;
                y1 = y1(), y1.then(function(O1) {
                  if (e._status === 0 || e._status === -1) e._status = 1, e._result = O1
                }, function(O1) {
                  if (e._status === 0 || e._status === -1) e._status = 2, e._result = O1
                }), e._status === -1 && (e._status = 0, e._result = y1)
              }
              if (e._status === 1) return e._result.default;
              throw e._result
            }

            function W1(e, y1) {
              return d1.H.useOptimistic(e, y1)
            }
            var w1 = typeof reportError === "function" ? reportError : function(e) {
              if ((typeof window === "undefined" ? "undefined" : W(window)) === "object" && typeof window.ErrorEvent === "function") {
                var y1 = new window.ErrorEvent("error", {
                  bubbles: !0,
                  cancelable: !0,
                  message: W(e) === "object" && e !== null && typeof e.message === "string" ? String(e.message) : String(e),
                  error: e
                });
                if (!window.dispatchEvent(y1)) return
              } else if ((typeof Y === "undefined" ? "undefined" : W(Y)) === "object" && typeof Y.emit === "function") {
                Y.emit("uncaughtException", e);
                return
              }
              console.error(e)
            };

            function P1() {}
            Z.Children = {
              map: t,
              forEach: function e(y1, O1, h1) {
                t(y1, function() {
                  O1.apply(this, arguments)
                }, h1)
              },
              count: function e(y1) {
                var O1 = 0;
                return t(y1, function() {
                  O1++
                }), O1
              },
              toArray: function e(y1) {
                return t(y1, function(O1) {
                  return O1
                }) || []
              },
              only: function e(y1) {
                if (!k1(y1)) throw Error("React.Children.only expected to receive a single React element child.");
                return y1
              }
            }, Z.Component = X1, Z.Fragment = X, Z.Profiler = C, Z.PureComponent = D1, Z.StrictMode = V, Z.Suspense = q, Z.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = d1, Z.act = function() {
              throw Error("act(...) is not supported in production builds of React.")
            }, Z.cache = function(e) {
              return function() {
                return e.apply(null, arguments)
              }
            }, Z.captureOwnerStack = function() {
              return null
            }, Z.cloneElement = function(e, y1, O1) {
              if (e === null || e === void 0) throw Error("The argument must be a React element, but you passed " + e + ".");
              var h1 = d({}, e.props),
                o1 = e.key,
                QA = void 0;
              if (y1 != null)
                for (zA in y1.ref !== void 0 && (QA = void 0), y1.key !== void 0 && (o1 = "" + y1.key), y1) !YA.call(y1, zA) || zA === "key" || zA === "__self" || zA === "__source" || zA === "ref" && y1.ref === void 0 || (h1[zA] = y1[zA]);
              var zA = arguments.length - 2;
              if (zA === 1) h1.children = O1;
              else if (1 < zA) {
                for (var Y0 = Array(zA), fA = 0; fA < zA; fA++) Y0[fA] = arguments[fA + 2];
                h1.children = Y0
              }
              return bA(e.type, o1, null, void 0, void 0, QA, h1)
            }, Z.createContext = function(e) {
              return e = {
                $$typeof: E,
                _currentValue: e,
                _currentValue2: e,
                _threadCount: 0,
                Provider: null,
                Consumer: null
              }, e.Provider = e, e.Consumer = {
                $$typeof: K,
                _context: e
              }, e
            }, Z.createElement = function(e, y1, O1) {
              var h1, o1 = {},
                QA = null;
              if (y1 != null)
                for (h1 in y1.key !== void 0 && (QA = "" + y1.key), y1) YA.call(y1, h1) && h1 !== "key" && h1 !== "__self" && h1 !== "__source" && (o1[h1] = y1[h1]);
              var zA = arguments.length - 2;
              if (zA === 1) o1.children = O1;
              else if (1 < zA) {
                for (var Y0 = Array(zA), fA = 0; fA < zA; fA++) Y0[fA] = arguments[fA + 2];
                o1.children = Y0
              }
              if (e && e.defaultProps)
                for (h1 in zA = e.defaultProps, zA) o1[h1] === void 0 && (o1[h1] = zA[h1]);
              return bA(e, QA, null, void 0, void 0, null, o1)
            }, Z.createRef = function() {
              return {
                current: null
              }
            }, Z.experimental_useEffectEvent = function(e) {
              return d1.H.useEffectEvent(e)
            }, Z.experimental_useOptimistic = function(e, y1) {
              return W1(e, y1)
            }, Z.forwardRef = function(e) {
              return {
                $$typeof: N,
                render: e
              }
            }, Z.isValidElement = k1, Z.lazy = function(e) {
              return {
                $$typeof: T,
                _payload: {
                  _status: -1,
                  _result: e
                },
                _init: B1
              }
            }, Z.memo = function(e, y1) {
              return {
                $$typeof: R,
                type: e,
                compare: y1 === void 0 ? null : y1
              }
            }, Z.startTransition = function(e) {
              var y1 = d1.T,
                O1 = {};
              d1.T = O1;
              try {
                var h1 = e(),
                  o1 = d1.S;
                o1 !== null && o1(O1, h1), W(h1) === "object" && h1 !== null && typeof h1.then === "function" && h1.then(P1, w1)
              } catch (QA) {
                w1(QA)
              } finally {
                d1.T = y1
              }
            }, Z.unstable_Activity = _, Z.unstable_DebugTracingMode = L, Z.unstable_SuspenseList = O, Z.unstable_getCacheForType = function(e) {
              var y1 = d1.A;
              return y1 ? y1.getCacheForType(e) : e()
            }, Z.unstable_postpone = function(e) {
              throw e = Error(e), e.$$typeof = k, e
            }, Z.unstable_useCacheRefresh = function() {
              return d1.H.useCacheRefresh()
            }, Z.use = function(e) {
              return d1.H.use(e)
            }, Z.useActionState = function(e, y1, O1) {
              return d1.H.useActionState(e, y1, O1)
            }, Z.useCallback = function(e, y1) {
              return d1.H.useCallback(e, y1)
            }, Z.useContext = function(e) {
              return d1.H.useContext(e)
            }, Z.useDebugValue = function() {}, Z.useDeferredValue = function(e, y1) {
              return d1.H.useDeferredValue(e, y1)
            }, Z.useEffect = function(e, y1) {
              return d1.H.useEffect(e, y1)
            }, Z.useId = function() {
              return d1.H.useId()
            }, Z.useImperativeHandle = function(e, y1, O1) {
              return d1.H.useImperativeHandle(e, y1, O1)
            }, Z.useInsertionEffect = function(e, y1) {
              return d1.H.useInsertionEffect(e, y1)
            }, Z.useLayoutEffect = function(e, y1) {
              return d1.H.useLayoutEffect(e, y1)
            }, Z.useMemo = function(e, y1) {
              return d1.H.useMemo(e, y1)
            }, Z.useOptimistic = W1, Z.useReducer = function(e, y1, O1) {
              return d1.H.useReducer(e, y1, O1)
            }, Z.useRef = function(e) {
              return d1.H.useRef(e)
            }, Z.useState = function(e) {
              return d1.H.useState(e)
            }, Z.useSyncExternalStore = function(e, y1, O1) {
              return d1.H.useSyncExternalStore(e, y1, O1)
            }, Z.useTransition = function() {
              return d1.H.useTransition()
            }, Z.version = "19.0.0-experimental-c82bcbeb2b-20241009"
          },
          189: (G, Z, D) => {
            G.exports = D(126)
          },
          206: function(G, Z, D) {
            var Y, W, J;

            function F(X) {
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") F = function V(C) {
                return typeof C
              };
              else F = function V(C) {
                return C && typeof Symbol === "function" && C.constructor === Symbol && C !== Symbol.prototype ? "symbol" : typeof C
              };
              return F(X)
            }(function(X, V) {
              W = [D(430)], Y = V, J = typeof Y === "function" ? Y.apply(Z, W) : Y, J !== void 0 && (G.exports = J)
            })(this, function X(V) {
              var C = /(^|@)\S+:\d+/,
                K = /^\s*at .*(\S+:\d+|\(native\))/m,
                E = /^(eval@)?(\[native code])?$/;
              return {
                parse: function N(q) {
                  if (typeof q.stacktrace !== "undefined" || typeof q["opera#sourceloc"] !== "undefined") return this.parseOpera(q);
                  else if (q.stack && q.stack.match(K)) return this.parseV8OrIE(q);
                  else if (q.stack) return this.parseFFOrSafari(q);
                  else throw new Error("Cannot parse given Error object")
                },
                extractLocation: function N(q) {
                  if (q.indexOf(":") === -1) return [q];
                  var O = /(.+?)(?::(\d+))?(?::(\d+))?$/,
                    R = O.exec(q.replace(/[()]/g, ""));
                  return [R[1], R[2] || void 0, R[3] || void 0]
                },
                parseV8OrIE: function N(q) {
                  var O = q.stack.split(`
`).filter(function(R) {
                    return !!R.match(K)
                  }, this);
                  return O.map(function(R) {
                    if (R.indexOf("(eval ") > -1) R = R.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(\),.*$)/g, "");
                    var T = R.replace(/^\s+/, "").replace(/\(eval code/g, "("),
                      L = T.match(/ (\((.+):(\d+):(\d+)\)$)/);
                    T = L ? T.replace(L[0], "") : T;
                    var _ = T.split(/\s+/).slice(1),
                      k = this.extractLocation(L ? L[1] : _.pop()),
                      i = _.join(" ") || void 0,
                      x = ["eval", "<anonymous>"].indexOf(k[0]) > -1 ? void 0 : k[0];
                    return new V({
                      functionName: i,
                      fileName: x,
                      lineNumber: k[1],
                      columnNumber: k[2],
                      source: R
                    })
                  }, this)
                },
                parseFFOrSafari: function N(q) {
                  var O = q.stack.split(`
`).filter(function(R) {
                    return !R.match(E)
                  }, this);
                  return O.map(function(R) {
                    if (R.indexOf(" > eval") > -1) R = R.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
                    if (R.indexOf("@") === -1 && R.indexOf(":") === -1) return new V({
                      functionName: R
                    });
                    else {
                      var T = /((.*".+"[^@]*)?[^@]*)(?:@)/,
                        L = R.match(T),
                        _ = L && L[1] ? L[1] : void 0,
                        k = this.extractLocation(R.replace(T, ""));
                      return new V({
                        functionName: _,
                        fileName: k[0],
                        lineNumber: k[1],
                        columnNumber: k[2],
                        source: R
                      })
                    }
                  }, this)
                },
                parseOpera: function N(q) {
                  if (!q.stacktrace || q.message.indexOf(`
`) > -1 && q.message.split(`
`).length > q.stacktrace.split(`
`).length) return this.parseOpera9(q);
                  else if (!q.stack) return this.parseOpera10(q);
                  else return this.parseOpera11(q)
                },
                parseOpera9: function N(q) {
                  var O = /Line (\d+).*script (?:in )?(\S+)/i,
                    R = q.message.split(`
`),
                    T = [];
                  for (var L = 2, _ = R.length; L < _; L += 2) {
                    var k = O.exec(R[L]);
                    if (k) T.push(new V({
                      fileName: k[2],
                      lineNumber: k[1],
                      source: R[L]
                    }))
                  }
                  return T
                },
                parseOpera10: function N(q) {
                  var O = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i,
                    R = q.stacktrace.split(`
`),
                    T = [];
                  for (var L = 0, _ = R.length; L < _; L += 2) {
                    var k = O.exec(R[L]);
                    if (k) T.push(new V({
                      functionName: k[3] || void 0,
                      fileName: k[2],
                      lineNumber: k[1],
                      source: R[L]
                    }))
                  }
                  return T
                },
                parseOpera11: function N(q) {
                  var O = q.stack.split(`
`).filter(function(R) {
                    return !!R.match(C) && !R.match(/^Error created at/)
                  }, this);
                  return O.map(function(R) {
                    var T = R.split("@"),
                      L = this.extractLocation(T.pop()),
                      _ = T.shift() || "",
                      k = _.replace(/<anonymous function(: (\w+))?>/, "$2").replace(/\([^)]*\)/g, "") || void 0,
                      i;
                    if (_.match(/\(([^)]*)\)/)) i = _.replace(/^[^(]+\(([^)]*)\)$/, "$1");
                    var x = i === void 0 || i === "[arguments not available]" ? void 0 : i.split(",");
                    return new V({
                      functionName: k,
                      args: x,
                      fileName: L[0],
                      lineNumber: L[1],
                      columnNumber: L[2],
                      source: R
                    })
                  }, this)
                }
              }
            })
          },
          172: (G) => {
            function Z(F1) {
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") Z = function X1(v) {
                return typeof v
              };
              else Z = function X1(v) {
                return v && typeof Symbol === "function" && v.constructor === Symbol && v !== Symbol.prototype ? "symbol" : typeof v
              };
              return Z(F1)
            }
            var D = "Expected a function",
              Y = NaN,
              W = "[object Symbol]",
              J = /^\s+|\s+$/g,
              F = /^[-+]0x[0-9a-f]+$/i,
              X = /^0b[01]+$/i,
              V = /^0o[0-7]+$/i,
              C = parseInt,
              K = (typeof global === "undefined" ? "undefined" : Z(global)) == "object" && global && global.Object === Object && global,
              E = (typeof self === "undefined" ? "undefined" : Z(self)) == "object" && self && self.Object === Object && self,
              N = K || E || Function("return this")(),
              q = Object.prototype,
              O = q.toString,
              R = Math.max,
              T = Math.min,
              L = function F1() {
                return N.Date.now()
              };

            function _(F1, X1, v) {
              var D1, N1, u1, d1, YA, bA, e1 = 0,
                k1 = !1,
                Q1 = !1,
                v1 = !0;
              if (typeof F1 != "function") throw new TypeError(D);
              if (X1 = d(X1) || 0, i(v)) k1 = !!v.leading, Q1 = "maxWait" in v, u1 = Q1 ? R(d(v.maxWait) || 0, X1) : u1, v1 = "trailing" in v ? !!v.trailing : v1;

              function L1(e) {
                var y1 = D1,
                  O1 = N1;
                return D1 = N1 = void 0, e1 = e, d1 = F1.apply(O1, y1), d1
              }

              function BA(e) {
                return e1 = e, YA = setTimeout(t, X1), k1 ? L1(e) : d1
              }

              function HA(e) {
                var y1 = e - bA,
                  O1 = e - e1,
                  h1 = X1 - y1;
                return Q1 ? T(h1, u1 - O1) : h1
              }

              function MA(e) {
                var y1 = e - bA,
                  O1 = e - e1;
                return bA === void 0 || y1 >= X1 || y1 < 0 || Q1 && O1 >= u1
              }

              function t() {
                var e = L();
                if (MA(e)) return B1(e);
                YA = setTimeout(t, HA(e))
              }

              function B1(e) {
                if (YA = void 0, v1 && D1) return L1(e);
                return D1 = N1 = void 0, d1
              }

              function W1() {
                if (YA !== void 0) clearTimeout(YA);
                e1 = 0, D1 = bA = N1 = YA = void 0
              }

              function w1() {
                return YA === void 0 ? d1 : B1(L())
              }

              function P1() {
                var e = L(),
                  y1 = MA(e);
                if (D1 = arguments, N1 = this, bA = e, y1) {
                  if (YA === void 0) return BA(bA);
                  if (Q1) return YA = setTimeout(t, X1), L1(bA)
                }
                if (YA === void 0) YA = setTimeout(t, X1);
                return d1
              }
              return P1.cancel = W1, P1.flush = w1, P1
            }

            function k(F1, X1, v) {
              var D1 = !0,
                N1 = !0;
              if (typeof F1 != "function") throw new TypeError(D);
              if (i(v)) D1 = "leading" in v ? !!v.leading : D1, N1 = "trailing" in v ? !!v.trailing : N1;
              return _(F1, X1, {
                leading: D1,
                maxWait: X1,
                trailing: N1
              })
            }

            function i(F1) {
              var X1 = Z(F1);
              return !!F1 && (X1 == "object" || X1 == "function")
            }

            function x(F1) {
              return !!F1 && Z(F1) == "object"
            }

            function s(F1) {
              return Z(F1) == "symbol" || x(F1) && O.call(F1) == W
            }

            function d(F1) {
              if (typeof F1 == "number") return F1;
              if (s(F1)) return Y;
              if (i(F1)) {
                var X1 = typeof F1.valueOf == "function" ? F1.valueOf() : F1;
                F1 = i(X1) ? X1 + "" : X1
              }
              if (typeof F1 != "string") return F1 === 0 ? F1 : +F1;
              F1 = F1.replace(J, "");
              var v = X.test(F1);
              return v || V.test(F1) ? C(F1.slice(2), v ? 2 : 8) : F.test(F1) ? Y : +F1
            }
            G.exports = k
          },
          730: (G, Z, D) => {
            var Y = D(169);
            G.exports = k;
            var W = D(307),
              J = D(82),
              F = D(695),
              X = typeof Symbol === "function" && Y.env._nodeLRUCacheForceNoSymbol !== "1",
              V;
            if (X) V = function v(D1) {
              return Symbol(D1)
            };
            else V = function v(D1) {
              return "_" + D1
            };
            var C = V("max"),
              K = V("length"),
              E = V("lengthCalculator"),
              N = V("allowStale"),
              q = V("maxAge"),
              O = V("dispose"),
              R = V("noDisposeOnSet"),
              T = V("lruList"),
              L = V("cache");

            function _() {
              return 1
            }

            function k(v) {
              if (!(this instanceof k)) return new k(v);
              if (typeof v === "number") v = {
                max: v
              };
              if (!v) v = {};
              var D1 = this[C] = v.max;
              if (!D1 || typeof D1 !== "number" || D1 <= 0) this[C] = 1 / 0;
              var N1 = v.length || _;
              if (typeof N1 !== "function") N1 = _;
              this[E] = N1, this[N] = v.stale || !1, this[q] = v.maxAge || 0, this[O] = v.dispose, this[R] = v.noDisposeOnSet || !1, this.reset()
            }
            Object.defineProperty(k.prototype, "max", {
              set: function v(D1) {
                if (!D1 || typeof D1 !== "number" || D1 <= 0) D1 = 1 / 0;
                this[C] = D1, d(this)
              },
              get: function v() {
                return this[C]
              },
              enumerable: !0
            }), Object.defineProperty(k.prototype, "allowStale", {
              set: function v(D1) {
                this[N] = !!D1
              },
              get: function v() {
                return this[N]
              },
              enumerable: !0
            }), Object.defineProperty(k.prototype, "maxAge", {
              set: function v(D1) {
                if (!D1 || typeof D1 !== "number" || D1 < 0) D1 = 0;
                this[q] = D1, d(this)
              },
              get: function v() {
                return this[q]
              },
              enumerable: !0
            }), Object.defineProperty(k.prototype, "lengthCalculator", {
              set: function v(D1) {
                if (typeof D1 !== "function") D1 = _;
                if (D1 !== this[E]) this[E] = D1, this[K] = 0, this[T].forEach(function(N1) {
                  N1.length = this[E](N1.value, N1.key), this[K] += N1.length
                }, this);
                d(this)
              },
              get: function v() {
                return this[E]
              },
              enumerable: !0
            }), Object.defineProperty(k.prototype, "length", {
              get: function v() {
                return this[K]
              },
              enumerable: !0
            }), Object.defineProperty(k.prototype, "itemCount", {
              get: function v() {
                return this[T].length
              },
              enumerable: !0
            }), k.prototype.rforEach = function(v, D1) {
              D1 = D1 || this;
              for (var N1 = this[T].tail; N1 !== null;) {
                var u1 = N1.prev;
                i(this, v, N1, D1), N1 = u1
              }
            };

            function i(v, D1, N1, u1) {
              var d1 = N1.value;
              if (s(v, d1)) {
                if (F1(v, N1), !v[N]) d1 = void 0
              }
              if (d1) D1.call(u1, d1.value, d1.key, v)
            }
            k.prototype.forEach = function(v, D1) {
              D1 = D1 || this;
              for (var N1 = this[T].head; N1 !== null;) {
                var u1 = N1.next;
                i(this, v, N1, D1), N1 = u1
              }
            }, k.prototype.keys = function() {
              return this[T].toArray().map(function(v) {
                return v.key
              }, this)
            }, k.prototype.values = function() {
              return this[T].toArray().map(function(v) {
                return v.value
              }, this)
            }, k.prototype.reset = function() {
              if (this[O] && this[T] && this[T].length) this[T].forEach(function(v) {
                this[O](v.key, v.value)
              }, this);
              this[L] = new W, this[T] = new F, this[K] = 0
            }, k.prototype.dump = function() {
              return this[T].map(function(v) {
                if (!s(this, v)) return {
                  k: v.key,
                  v: v.value,
                  e: v.now + (v.maxAge || 0)
                }
              }, this).toArray().filter(function(v) {
                return v
              })
            }, k.prototype.dumpLru = function() {
              return this[T]
            }, k.prototype.inspect = function(v, D1) {
              var N1 = "LRUCache {",
                u1 = !1,
                d1 = this[N];
              if (d1) N1 += `
  allowStale: true`, u1 = !0;
              var YA = this[C];
              if (YA && YA !== 1 / 0) {
                if (u1) N1 += ",";
                N1 += `
  max: ` + J.inspect(YA, D1), u1 = !0
              }
              var bA = this[q];
              if (bA) {
                if (u1) N1 += ",";
                N1 += `
  maxAge: ` + J.inspect(bA, D1), u1 = !0
              }
              var e1 = this[E];
              if (e1 && e1 !== _) {
                if (u1) N1 += ",";
                N1 += `
  length: ` + J.inspect(this[K], D1), u1 = !0
              }
              var k1 = !1;
              if (this[T].forEach(function(Q1) {
                  if (k1) N1 += `,
  `;
                  else {
                    if (u1) N1 += `,
`;
                    k1 = !0, N1 += `
  `
                  }
                  var v1 = J.inspect(Q1.key).split(`
`).join(`
  `),
                    L1 = {
                      value: Q1.value
                    };
                  if (Q1.maxAge !== bA) L1.maxAge = Q1.maxAge;
                  if (e1 !== _) L1.length = Q1.length;
                  if (s(this, Q1)) L1.stale = !0;
                  L1 = J.inspect(L1, D1).split(`
`).join(`
  `), N1 += v1 + " => " + L1
                }), k1 || u1) N1 += `
`;
              return N1 += "}", N1
            }, k.prototype.set = function(v, D1, N1) {
              N1 = N1 || this[q];
              var u1 = N1 ? Date.now() : 0,
                d1 = this[E](D1, v);
              if (this[L].has(v)) {
                if (d1 > this[C]) return F1(this, this[L].get(v)), !1;
                var YA = this[L].get(v),
                  bA = YA.value;
                if (this[O]) {
                  if (!this[R]) this[O](v, bA.value)
                }
                return bA.now = u1, bA.maxAge = N1, bA.value = D1, this[K] += d1 - bA.length, bA.length = d1, this.get(v), d(this), !0
              }
              var e1 = new X1(v, D1, d1, u1, N1);
              if (e1.length > this[C]) {
                if (this[O]) this[O](v, D1);
                return !1
              }
              return this[K] += e1.length, this[T].unshift(e1), this[L].set(v, this[T].head), d(this), !0
            }, k.prototype.has = function(v) {
              if (!this[L].has(v)) return !1;
              var D1 = this[L].get(v).value;
              if (s(this, D1)) return !1;
              return !0
            }, k.prototype.get = function(v) {
              return x(this, v, !0)
            }, k.prototype.peek = function(v) {
              return x(this, v, !1)
            }, k.prototype.pop = function() {
              var v = this[T].tail;
              if (!v) return null;
              return F1(this, v), v.value
            }, k.prototype.del = function(v) {
              F1(this, this[L].get(v))
            }, k.prototype.load = function(v) {
              this.reset();
              var D1 = Date.now();
              for (var N1 = v.length - 1; N1 >= 0; N1--) {
                var u1 = v[N1],
                  d1 = u1.e || 0;
                if (d1 === 0) this.set(u1.k, u1.v);
                else {
                  var YA = d1 - D1;
                  if (YA > 0) this.set(u1.k, u1.v, YA)
                }
              }
            }, k.prototype.prune = function() {
              var v = this;
              this[L].forEach(function(D1, N1) {
                x(v, N1, !1)
              })
            };

            function x(v, D1, N1) {
              var u1 = v[L].get(D1);
              if (u1) {
                var d1 = u1.value;
                if (s(v, d1)) {
                  if (F1(v, u1), !v[N]) d1 = void 0
                } else if (N1) v[T].unshiftNode(u1);
                if (d1) d1 = d1.value
              }
              return d1
            }

            function s(v, D1) {
              if (!D1 || !D1.maxAge && !v[q]) return !1;
              var N1 = !1,
                u1 = Date.now() - D1.now;
              if (D1.maxAge) N1 = u1 > D1.maxAge;
              else N1 = v[q] && u1 > v[q];
              return N1
            }

            function d(v) {
              if (v[K] > v[C])
                for (var D1 = v[T].tail; v[K] > v[C] && D1 !== null;) {
                  var N1 = D1.prev;
                  F1(v, D1), D1 = N1
                }
            }

            function F1(v, D1) {
              if (D1) {
                var N1 = D1.value;
                if (v[O]) v[O](N1.key, N1.value);
                v[K] -= N1.length, v[L].delete(N1.key), v[T].removeNode(D1)
              }
            }

            function X1(v, D1, N1, u1, d1) {
              this.key = v, this.value = D1, this.length = N1, this.now = u1, this.maxAge = d1 || 0
            }
          },
          169: (G) => {
            var Z = G.exports = {},
              D, Y;

            function W() {
              throw new Error("setTimeout has not been defined")
            }

            function J() {
              throw new Error("clearTimeout has not been defined")
            }(function() {
              try {
                if (typeof setTimeout === "function") D = setTimeout;
                else D = W
              } catch (T) {
                D = W
              }
              try {
                if (typeof clearTimeout === "function") Y = clearTimeout;
                else Y = J
              } catch (T) {
                Y = J
              }
            })();

            function F(T) {
              if (D === setTimeout) return setTimeout(T, 0);
              if ((D === W || !D) && setTimeout) return D = setTimeout, setTimeout(T, 0);
              try {
                return D(T, 0)
              } catch (L) {
                try {
                  return D.call(null, T, 0)
                } catch (_) {
                  return D.call(this, T, 0)
                }
              }
            }

            function X(T) {
              if (Y === clearTimeout) return clearTimeout(T);
              if ((Y === J || !Y) && clearTimeout) return Y = clearTimeout, clearTimeout(T);
              try {
                return Y(T)
              } catch (L) {
                try {
                  return Y.call(null, T)
                } catch (_) {
                  return Y.call(this, T)
                }
              }
            }
            var V = [],
              C = !1,
              K, E = -1;

            function N() {
              if (!C || !K) return;
              if (C = !1, K.length) V = K.concat(V);
              else E = -1;
              if (V.length) q()
            }

            function q() {
              if (C) return;
              var T = F(N);
              C = !0;
              var L = V.length;
              while (L) {
                K = V, V = [];
                while (++E < L)
                  if (K) K[E].run();
                E = -1, L = V.length
              }
              K = null, C = !1, X(T)
            }
            Z.nextTick = function(T) {
              var L = new Array(arguments.length - 1);
              if (arguments.length > 1)
                for (var _ = 1; _ < arguments.length; _++) L[_ - 1] = arguments[_];
              if (V.push(new O(T, L)), V.length === 1 && !C) F(q)
            };

            function O(T, L) {
              this.fun = T, this.array = L
            }
            O.prototype.run = function() {
              this.fun.apply(null, this.array)
            }, Z.title = "browser", Z.browser = !0, Z.env = {}, Z.argv = [], Z.version = "", Z.versions = {};

            function R() {}
            Z.on = R, Z.addListener = R, Z.once = R, Z.off = R, Z.removeListener = R, Z.removeAllListeners = R, Z.emit = R, Z.prependListener = R, Z.prependOnceListener = R, Z.listeners = function(T) {
              return []
            }, Z.binding = function(T) {
              throw new Error("process.binding is not supported")
            }, Z.cwd = function() {
              return "/"
            }, Z.chdir = function(T) {
              throw new Error("process.chdir is not supported")
            }, Z.umask = function() {
              return 0
            }
          },
          307: (G, Z, D) => {
            var Y = D(169);
            if (Y.env.npm_package_name === "pseudomap" && Y.env.npm_lifecycle_script === "test") Y.env.TEST_PSEUDOMAP = "true";
            if (typeof Map === "function" && !Y.env.TEST_PSEUDOMAP) G.exports = Map;
            else G.exports = D(761)
          },
          761: (G) => {
            var Z = Object.prototype.hasOwnProperty;
            G.exports = D;

            function D(X) {
              if (!(this instanceof D)) throw new TypeError("Constructor PseudoMap requires 'new'");
              if (this.clear(), X)
                if (X instanceof D || typeof Map === "function" && X instanceof Map) X.forEach(function(V, C) {
                  this.set(C, V)
                }, this);
                else if (Array.isArray(X)) X.forEach(function(V) {
                this.set(V[0], V[1])
              }, this);
              else throw new TypeError("invalid argument")
            }
            D.prototype.forEach = function(X, V) {
              V = V || this, Object.keys(this._data).forEach(function(C) {
                if (C !== "size") X.call(V, this._data[C].value, this._data[C].key)
              }, this)
            }, D.prototype.has = function(X) {
              return !!J(this._data, X)
            }, D.prototype.get = function(X) {
              var V = J(this._data, X);
              return V && V.value
            }, D.prototype.set = function(X, V) {
              F(this._data, X, V)
            }, D.prototype.delete = function(X) {
              var V = J(this._data, X);
              if (V) delete this._data[V._index], this._data.size--
            }, D.prototype.clear = function() {
              var X = Object.create(null);
              X.size = 0, Object.defineProperty(this, "_data", {
                value: X,
                enumerable: !1,
                configurable: !0,
                writable: !1
              })
            }, Object.defineProperty(D.prototype, "size", {
              get: function X() {
                return this._data.size
              },
              set: function X(V) {},
              enumerable: !0,
              configurable: !0
            }), D.prototype.values = D.prototype.keys = D.prototype.entries = function() {
              throw new Error("iterators are not implemented in this version")
            };

            function Y(X, V) {
              return X === V || X !== X && V !== V
            }

            function W(X, V, C) {
              this.key = X, this.value = V, this._index = C
            }

            function J(X, V) {
              for (var C = 0, K = "_" + V, E = K; Z.call(X, E); E = K + C++)
                if (Y(X[E].key, V)) return X[E]
            }

            function F(X, V, C) {
              for (var K = 0, E = "_" + V, N = E; Z.call(X, N); N = E + K++)
                if (Y(X[N].key, V)) {
                  X[N].value = C;
                  return
                } X.size++, X[N] = new W(V, C, N)
            }
          },
          430: function(G, Z) {
            var D, Y, W;

            function J(F) {
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") J = function X(V) {
                return typeof V
              };
              else J = function X(V) {
                return V && typeof Symbol === "function" && V.constructor === Symbol && V !== Symbol.prototype ? "symbol" : typeof V
              };
              return J(F)
            }(function(F, X) {
              Y = [], D = X, W = typeof D === "function" ? D.apply(Z, Y) : D, W !== void 0 && (G.exports = W)
            })(this, function() {
              function F(_) {
                return !isNaN(parseFloat(_)) && isFinite(_)
              }

              function X(_) {
                return _.charAt(0).toUpperCase() + _.substring(1)
              }

              function V(_) {
                return function() {
                  return this[_]
                }
              }
              var C = ["isConstructor", "isEval", "isNative", "isToplevel"],
                K = ["columnNumber", "lineNumber"],
                E = ["fileName", "functionName", "source"],
                N = ["args"],
                q = C.concat(K, E, N);

              function O(_) {
                if (!_) return;
                for (var k = 0; k < q.length; k++)
                  if (_[q[k]] !== void 0) this["set" + X(q[k])](_[q[k]])
              }
              O.prototype = {
                getArgs: function _() {
                  return this.args
                },
                setArgs: function _(k) {
                  if (Object.prototype.toString.call(k) !== "[object Array]") throw new TypeError("Args must be an Array");
                  this.args = k
                },
                getEvalOrigin: function _() {
                  return this.evalOrigin
                },
                setEvalOrigin: function _(k) {
                  if (k instanceof O) this.evalOrigin = k;
                  else if (k instanceof Object) this.evalOrigin = new O(k);
                  else throw new TypeError("Eval Origin must be an Object or StackFrame")
                },
                toString: function _() {
                  var k = this.getFileName() || "",
                    i = this.getLineNumber() || "",
                    x = this.getColumnNumber() || "",
                    s = this.getFunctionName() || "";
                  if (this.getIsEval()) {
                    if (k) return "[eval] (" + k + ":" + i + ":" + x + ")";
                    return "[eval]:" + i + ":" + x
                  }
                  if (s) return s + " (" + k + ":" + i + ":" + x + ")";
                  return k + ":" + i + ":" + x
                }
              }, O.fromString = function _(k) {
                var i = k.indexOf("("),
                  x = k.lastIndexOf(")"),
                  s = k.substring(0, i),
                  d = k.substring(i + 1, x).split(","),
                  F1 = k.substring(x + 1);
                if (F1.indexOf("@") === 0) var X1 = /@(.+?)(?::(\d+))?(?::(\d+))?$/.exec(F1, ""),
                  v = X1[1],
                  D1 = X1[2],
                  N1 = X1[3];
                return new O({
                  functionName: s,
                  args: d || void 0,
                  fileName: v,
                  lineNumber: D1 || void 0,
                  columnNumber: N1 || void 0
                })
              };
              for (var R = 0; R < C.length; R++) O.prototype["get" + X(C[R])] = V(C[R]), O.prototype["set" + X(C[R])] = function(_) {
                return function(k) {
                  this[_] = Boolean(k)
                }
              }(C[R]);
              for (var T = 0; T < K.length; T++) O.prototype["get" + X(K[T])] = V(K[T]), O.prototype["set" + X(K[T])] = function(_) {
                return function(k) {
                  if (!F(k)) throw new TypeError(_ + " must be a Number");
                  this[_] = Number(k)
                }
              }(K[T]);
              for (var L = 0; L < E.length; L++) O.prototype["get" + X(E[L])] = V(E[L]), O.prototype["set" + X(E[L])] = function(_) {
                return function(k) {
                  this[_] = String(k)
                }
              }(E[L]);
              return O
            })
          },
          718: (G) => {
            if (typeof Object.create === "function") G.exports = function Z(D, Y) {
              D.super_ = Y, D.prototype = Object.create(Y.prototype, {
                constructor: {
                  value: D,
                  enumerable: !1,
                  writable: !0,
                  configurable: !0
                }
              })
            };
            else G.exports = function Z(D, Y) {
              D.super_ = Y;
              var W = function J() {};
              W.prototype = Y.prototype, D.prototype = new W, D.prototype.constructor = D
            }
          },
          715: (G) => {
            function Z(D) {
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") Z = function Y(W) {
                return typeof W
              };
              else Z = function Y(W) {
                return W && typeof Symbol === "function" && W.constructor === Symbol && W !== Symbol.prototype ? "symbol" : typeof W
              };
              return Z(D)
            }
            G.exports = function D(Y) {
              return Y && Z(Y) === "object" && typeof Y.copy === "function" && typeof Y.fill === "function" && typeof Y.readUInt8 === "function"
            }
          },
          82: (G, Z, D) => {
            var Y = D(169);

            function W(L1) {
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") W = function BA(HA) {
                return typeof HA
              };
              else W = function BA(HA) {
                return HA && typeof Symbol === "function" && HA.constructor === Symbol && HA !== Symbol.prototype ? "symbol" : typeof HA
              };
              return W(L1)
            }
            var J = /%[sdj%]/g;
            Z.format = function(L1) {
              if (!d(L1)) {
                var BA = [];
                for (var HA = 0; HA < arguments.length; HA++) BA.push(V(arguments[HA]));
                return BA.join(" ")
              }
              var HA = 1,
                MA = arguments,
                t = MA.length,
                B1 = String(L1).replace(J, function(w1) {
                  if (w1 === "%%") return "%";
                  if (HA >= t) return w1;
                  switch (w1) {
                    case "%s":
                      return String(MA[HA++]);
                    case "%d":
                      return Number(MA[HA++]);
                    case "%j":
                      try {
                        return JSON.stringify(MA[HA++])
                      } catch (P1) {
                        return "[Circular]"
                      }
                    default:
                      return w1
                  }
                });
              for (var W1 = MA[HA]; HA < t; W1 = MA[++HA])
                if (i(W1) || !D1(W1)) B1 += " " + W1;
                else B1 += " " + V(W1);
              return B1
            }, Z.deprecate = function(L1, BA) {
              if (X1(global.process)) return function() {
                return Z.deprecate(L1, BA).apply(this, arguments)
              };
              if (Y.noDeprecation === !0) return L1;
              var HA = !1;

              function MA() {
                if (!HA) {
                  if (Y.throwDeprecation) throw new Error(BA);
                  else if (Y.traceDeprecation) console.trace(BA);
                  else console.error(BA);
                  HA = !0
                }
                return L1.apply(this, arguments)
              }
              return MA
            };
            var F = {},
              X;
            Z.debuglog = function(L1) {
              if (X1(X)) X = Y.env.NODE_DEBUG || "";
              if (L1 = L1.toUpperCase(), !F[L1])
                if (new RegExp("\\b" + L1 + "\\b", "i").test(X)) {
                  var BA = Y.pid;
                  F[L1] = function() {
                    var HA = Z.format.apply(Z, arguments);
                    console.error("%s %d: %s", L1, BA, HA)
                  }
                } else F[L1] = function() {};
              return F[L1]
            };

            function V(L1, BA) {
              var HA = {
                seen: [],
                stylize: K
              };
              if (arguments.length >= 3) HA.depth = arguments[2];
              if (arguments.length >= 4) HA.colors = arguments[3];
              if (k(BA)) HA.showHidden = BA;
              else if (BA) Z._extend(HA, BA);
              if (X1(HA.showHidden)) HA.showHidden = !1;
              if (X1(HA.depth)) HA.depth = 2;
              if (X1(HA.colors)) HA.colors = !1;
              if (X1(HA.customInspect)) HA.customInspect = !0;
              if (HA.colors) HA.stylize = C;
              return N(HA, L1, HA.depth)
            }
            Z.inspect = V, V.colors = {
              bold: [1, 22],
              italic: [3, 23],
              underline: [4, 24],
              inverse: [7, 27],
              white: [37, 39],
              grey: [90, 39],
              black: [30, 39],
              blue: [34, 39],
              cyan: [36, 39],
              green: [32, 39],
              magenta: [35, 39],
              red: [31, 39],
              yellow: [33, 39]
            }, V.styles = {
              special: "cyan",
              number: "yellow",
              boolean: "yellow",
              undefined: "grey",
              null: "bold",
              string: "green",
              date: "magenta",
              regexp: "red"
            };

            function C(L1, BA) {
              var HA = V.styles[BA];
              if (HA) return "\x1B[" + V.colors[HA][0] + "m" + L1 + "\x1B[" + V.colors[HA][1] + "m";
              else return L1
            }

            function K(L1, BA) {
              return L1
            }

            function E(L1) {
              var BA = {};
              return L1.forEach(function(HA, MA) {
                BA[HA] = !0
              }), BA
            }

            function N(L1, BA, HA) {
              if (L1.customInspect && BA && d1(BA.inspect) && BA.inspect !== Z.inspect && !(BA.constructor && BA.constructor.prototype === BA)) {
                var MA = BA.inspect(HA, L1);
                if (!d(MA)) MA = N(L1, MA, HA);
                return MA
              }
              var t = q(L1, BA);
              if (t) return t;
              var B1 = Object.keys(BA),
                W1 = E(B1);
              if (L1.showHidden) B1 = Object.getOwnPropertyNames(BA);
              if (u1(BA) && (B1.indexOf("message") >= 0 || B1.indexOf("description") >= 0)) return O(BA);
              if (B1.length === 0) {
                if (d1(BA)) {
                  var w1 = BA.name ? ": " + BA.name : "";
                  return L1.stylize("[Function" + w1 + "]", "special")
                }
                if (v(BA)) return L1.stylize(RegExp.prototype.toString.call(BA), "regexp");
                if (N1(BA)) return L1.stylize(Date.prototype.toString.call(BA), "date");
                if (u1(BA)) return O(BA)
              }
              var P1 = "",
                e = !1,
                y1 = ["{", "}"];
              if (_(BA)) e = !0, y1 = ["[", "]"];
              if (d1(BA)) {
                var O1 = BA.name ? ": " + BA.name : "";
                P1 = " [Function" + O1 + "]"
              }
              if (v(BA)) P1 = " " + RegExp.prototype.toString.call(BA);
              if (N1(BA)) P1 = " " + Date.prototype.toUTCString.call(BA);
              if (u1(BA)) P1 = " " + O(BA);
              if (B1.length === 0 && (!e || BA.length == 0)) return y1[0] + P1 + y1[1];
              if (HA < 0)
                if (v(BA)) return L1.stylize(RegExp.prototype.toString.call(BA), "regexp");
                else return L1.stylize("[Object]", "special");
              L1.seen.push(BA);
              var h1;
              if (e) h1 = R(L1, BA, HA, W1, B1);
              else h1 = B1.map(function(o1) {
                return T(L1, BA, HA, W1, o1, e)
              });
              return L1.seen.pop(), L(h1, P1, y1)
            }

            function q(L1, BA) {
              if (X1(BA)) return L1.stylize("undefined", "undefined");
              if (d(BA)) {
                var HA = "'" + JSON.stringify(BA).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
                return L1.stylize(HA, "string")
              }
              if (s(BA)) return L1.stylize("" + BA, "number");
              if (k(BA)) return L1.stylize("" + BA, "boolean");
              if (i(BA)) return L1.stylize("null", "null")
            }

            function O(L1) {
              return "[" + Error.prototype.toString.call(L1) + "]"
            }

            function R(L1, BA, HA, MA, t) {
              var B1 = [];
              for (var W1 = 0, w1 = BA.length; W1 < w1; ++W1)
                if (v1(BA, String(W1))) B1.push(T(L1, BA, HA, MA, String(W1), !0));
                else B1.push("");
              return t.forEach(function(P1) {
                if (!P1.match(/^\d+$/)) B1.push(T(L1, BA, HA, MA, P1, !0))
              }), B1
            }

            function T(L1, BA, HA, MA, t, B1) {
              var W1, w1, P1;
              if (P1 = Object.getOwnPropertyDescriptor(BA, t) || {
                  value: BA[t]
                }, P1.get)
                if (P1.set) w1 = L1.stylize("[Getter/Setter]", "special");
                else w1 = L1.stylize("[Getter]", "special");
              else if (P1.set) w1 = L1.stylize("[Setter]", "special");
              if (!v1(MA, t)) W1 = "[" + t + "]";
              if (!w1)
                if (L1.seen.indexOf(P1.value) < 0) {
                  if (i(HA)) w1 = N(L1, P1.value, null);
                  else w1 = N(L1, P1.value, HA - 1);
                  if (w1.indexOf(`
`) > -1)
                    if (B1) w1 = w1.split(`
`).map(function(e) {
                      return "  " + e
                    }).join(`
`).substr(2);
                    else w1 = `
` + w1.split(`
`).map(function(e) {
                      return "   " + e
                    }).join(`
`)
                } else w1 = L1.stylize("[Circular]", "special");
              if (X1(W1)) {
                if (B1 && t.match(/^\d+$/)) return w1;
                if (W1 = JSON.stringify("" + t), W1.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) W1 = W1.substr(1, W1.length - 2), W1 = L1.stylize(W1, "name");
                else W1 = W1.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), W1 = L1.stylize(W1, "string")
              }
              return W1 + ": " + w1
            }

            function L(L1, BA, HA) {
              var MA = 0,
                t = L1.reduce(function(B1, W1) {
                  if (MA++, W1.indexOf(`
`) >= 0) MA++;
                  return B1 + W1.replace(/\u001b\[\d\d?m/g, "").length + 1
                }, 0);
              if (t > 60) return HA[0] + (BA === "" ? "" : BA + `
 `) + " " + L1.join(`,
  `) + " " + HA[1];
              return HA[0] + BA + " " + L1.join(", ") + " " + HA[1]
            }

            function _(L1) {
              return Array.isArray(L1)
            }
            Z.isArray = _;

            function k(L1) {
              return typeof L1 === "boolean"
            }
            Z.isBoolean = k;

            function i(L1) {
              return L1 === null
            }
            Z.isNull = i;

            function x(L1) {
              return L1 == null
            }
            Z.isNullOrUndefined = x;

            function s(L1) {
              return typeof L1 === "number"
            }
            Z.isNumber = s;

            function d(L1) {
              return typeof L1 === "string"
            }
            Z.isString = d;

            function F1(L1) {
              return W(L1) === "symbol"
            }
            Z.isSymbol = F1;

            function X1(L1) {
              return L1 === void 0
            }
            Z.isUndefined = X1;

            function v(L1) {
              return D1(L1) && bA(L1) === "[object RegExp]"
            }
            Z.isRegExp = v;

            function D1(L1) {
              return W(L1) === "object" && L1 !== null
            }
            Z.isObject = D1;

            function N1(L1) {
              return D1(L1) && bA(L1) === "[object Date]"
            }
            Z.isDate = N1;

            function u1(L1) {
              return D1(L1) && (bA(L1) === "[object Error]" || L1 instanceof Error)
            }
            Z.isError = u1;

            function d1(L1) {
              return typeof L1 === "function"
            }
            Z.isFunction = d1;

            function YA(L1) {
              return L1 === null || typeof L1 === "boolean" || typeof L1 === "number" || typeof L1 === "string" || W(L1) === "symbol" || typeof L1 === "undefined"
            }
            Z.isPrimitive = YA, Z.isBuffer = D(715);

            function bA(L1) {
              return Object.prototype.toString.call(L1)
            }

            function e1(L1) {
              return L1 < 10 ? "0" + L1.toString(10) : L1.toString(10)
            }
            var k1 = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];

            function Q1() {
              var L1 = new Date,
                BA = [e1(L1.getHours()), e1(L1.getMinutes()), e1(L1.getSeconds())].join(":");
              return [L1.getDate(), k1[L1.getMonth()], BA].join(" ")
            }
            Z.log = function() {
              console.log("%s - %s", Q1(), Z.format.apply(Z, arguments))
            }, Z.inherits = D(718), Z._extend = function(L1, BA) {
              if (!BA || !D1(BA)) return L1;
              var HA = Object.keys(BA),
                MA = HA.length;
              while (MA--) L1[HA[MA]] = BA[HA[MA]];
              return L1
            };

            function v1(L1, BA) {
              return Object.prototype.hasOwnProperty.call(L1, BA)
            }
          },
          695: (G) => {
            G.exports = Z, Z.Node = W, Z.create = Z;

            function Z(J) {
              var F = this;
              if (!(F instanceof Z)) F = new Z;
              if (F.tail = null, F.head = null, F.length = 0, J && typeof J.forEach === "function") J.forEach(function(C) {
                F.push(C)
              });
              else if (arguments.length > 0)
                for (var X = 0, V = arguments.length; X < V; X++) F.push(arguments[X]);
              return F
            }
            Z.prototype.removeNode = function(J) {
              if (J.list !== this) throw new Error("removing node which does not belong to this list");
              var {
                next: F,
                prev: X
              } = J;
              if (F) F.prev = X;
              if (X) X.next = F;
              if (J === this.head) this.head = F;
              if (J === this.tail) this.tail = X;
              J.list.length--, J.next = null, J.prev = null, J.list = null
            }, Z.prototype.unshiftNode = function(J) {
              if (J === this.head) return;
              if (J.list) J.list.removeNode(J);
              var F = this.head;
              if (J.list = this, J.next = F, F) F.prev = J;
              if (this.head = J, !this.tail) this.tail = J;
              this.length++
            }, Z.prototype.pushNode = function(J) {
              if (J === this.tail) return;
              if (J.list) J.list.removeNode(J);
              var F = this.tail;
              if (J.list = this, J.prev = F, F) F.next = J;
              if (this.tail = J, !this.head) this.head = J;
              this.length++
            }, Z.prototype.push = function() {
              for (var J = 0, F = arguments.length; J < F; J++) D(this, arguments[J]);
              return this.length
            }, Z.prototype.unshift = function() {
              for (var J = 0, F = arguments.length; J < F; J++) Y(this, arguments[J]);
              return this.length
            }, Z.prototype.pop = function() {
              if (!this.tail) return;
              var J = this.tail.value;
              if (this.tail = this.tail.prev, this.tail) this.tail.next = null;
              else this.head = null;
              return this.length--, J
            }, Z.prototype.shift = function() {
              if (!this.head) return;
              var J = this.head.value;
              if (this.head = this.head.next, this.head) this.head.prev = null;
              else this.tail = null;
              return this.length--, J
            }, Z.prototype.forEach = function(J, F) {
              F = F || this;
              for (var X = this.head, V = 0; X !== null; V++) J.call(F, X.value, V, this), X = X.next
            }, Z.prototype.forEachReverse = function(J, F) {
              F = F || this;
              for (var X = this.tail, V = this.length - 1; X !== null; V--) J.call(F, X.value, V, this), X = X.prev
            }, Z.prototype.get = function(J) {
              for (var F = 0, X = this.head; X !== null && F < J; F++) X = X.next;
              if (F === J && X !== null) return X.value
            }, Z.prototype.getReverse = function(J) {
              for (var F = 0, X = this.tail; X !== null && F < J; F++) X = X.prev;
              if (F === J && X !== null) return X.value
            }, Z.prototype.map = function(J, F) {
              F = F || this;
              var X = new Z;
              for (var V = this.head; V !== null;) X.push(J.call(F, V.value, this)), V = V.next;
              return X
            }, Z.prototype.mapReverse = function(J, F) {
              F = F || this;
              var X = new Z;
              for (var V = this.tail; V !== null;) X.push(J.call(F, V.value, this)), V = V.prev;
              return X
            }, Z.prototype.reduce = function(J, F) {
              var X, V = this.head;
              if (arguments.length > 1) X = F;
              else if (this.head) V = this.head.next, X = this.head.value;
              else throw new TypeError("Reduce of empty list with no initial value");
              for (var C = 0; V !== null; C++) X = J(X, V.value, C), V = V.next;
              return X
            }, Z.prototype.reduceReverse = function(J, F) {
              var X, V = this.tail;
              if (arguments.length > 1) X = F;
              else if (this.tail) V = this.tail.prev, X = this.tail.value;
              else throw new TypeError("Reduce of empty list with no initial value");
              for (var C = this.length - 1; V !== null; C--) X = J(X, V.value, C), V = V.prev;
              return X
            }, Z.prototype.toArray = function() {
              var J = new Array(this.length);
              for (var F = 0, X = this.head; X !== null; F++) J[F] = X.value, X = X.next;
              return J
            }, Z.prototype.toArrayReverse = function() {
              var J = new Array(this.length);
              for (var F = 0, X = this.tail; X !== null; F++) J[F] = X.value, X = X.prev;
              return J
            }, Z.prototype.slice = function(J, F) {
              if (F = F || this.length, F < 0) F += this.length;
              if (J = J || 0, J < 0) J += this.length;
              var X = new Z;
              if (F < J || F < 0) return X;
              if (J < 0) J = 0;
              if (F > this.length) F = this.length;
              for (var V = 0, C = this.head; C !== null && V < J; V++) C = C.next;
              for (; C !== null && V < F; V++, C = C.next) X.push(C.value);
              return X
            }, Z.prototype.sliceReverse = function(J, F) {
              if (F = F || this.length, F < 0) F += this.length;
              if (J = J || 0, J < 0) J += this.length;
              var X = new Z;
              if (F < J || F < 0) return X;
              if (J < 0) J = 0;
              if (F > this.length) F = this.length;
              for (var V = this.length, C = this.tail; C !== null && V > F; V--) C = C.prev;
              for (; C !== null && V > J; V--, C = C.prev) X.push(C.value);
              return X
            }, Z.prototype.reverse = function() {
              var J = this.head,
                F = this.tail;
              for (var X = J; X !== null; X = X.prev) {
                var V = X.prev;
                X.prev = X.next, X.next = V
              }
              return this.head = F, this.tail = J, this
            };

            function D(J, F) {
              if (J.tail = new W(F, J.tail, null, J), !J.head) J.head = J.tail;
              J.length++
            }

            function Y(J, F) {
              if (J.head = new W(F, null, J.head, J), !J.tail) J.tail = J.head;
              J.length++
            }

            function W(J, F, X, V) {
              if (!(this instanceof W)) return new W(J, F, X, V);
              if (this.list = V, this.value = J, F) F.next = this, this.prev = F;
              else this.prev = null;
              if (X) X.prev = this, this.next = X;
              else this.next = null
            }
          }
        },
        B = {};

      function Q(G) {
        var Z = B[G];
        if (Z !== void 0) return Z.exports;
        var D = B[G] = {
          exports: {}
        };
        return A[G].call(D.exports, D, D.exports, Q), D.exports
      }(() => {
        Q.n = (G) => {
          var Z = G && G.__esModule ? () => G.default : () => G;
          return Q.d(Z, {
            a: Z
          }), Z
        }
      })(), (() => {
        Q.d = (G, Z) => {
          for (var D in Z)
            if (Q.o(Z, D) && !Q.o(G, D)) Object.defineProperty(G, D, {
              enumerable: !0,
              get: Z[D]
            })
        }
      })(), (() => {
        Q.o = (G, Z) => Object.prototype.hasOwnProperty.call(G, Z)
      })(), (() => {
        Q.r = (G) => {
          if (typeof Symbol !== "undefined" && Symbol.toStringTag) Object.defineProperty(G, Symbol.toStringTag, {
            value: "Module"
          });
          Object.defineProperty(G, "__esModule", {
            value: !0
          })
        }
      })();
      var I = {};
      return (() => {
        Q.r(I), Q.d(I, {
          connectToDevTools: () => b01,
          connectWithCustomMessagingProtocol: () => yE1
        });

        function G(M, f) {
          if (!(M instanceof f)) throw new TypeError("Cannot call a class as a function")
        }

        function Z(M, f) {
          for (var b = 0; b < f.length; b++) {
            var p = f[b];
            if (p.enumerable = p.enumerable || !1, p.configurable = !0, "value" in p) p.writable = !0;
            Object.defineProperty(M, p.key, p)
          }
        }

        function D(M, f, b) {
          if (f) Z(M.prototype, f);
          if (b) Z(M, b);
          return M
        }

        function Y(M, f, b) {
          if (f in M) Object.defineProperty(M, f, {
            value: b,
            enumerable: !0,
            configurable: !0,
            writable: !0
          });
          else M[f] = b;
          return M
        }
        var W = function() {
            function M() {
              G(this, M), Y(this, "listenersMap", new Map)
            }
            return D(M, [{
              key: "addListener",
              value: function f(b, p) {
                var c = this.listenersMap.get(b);
                if (c === void 0) this.listenersMap.set(b, [p]);
                else {
                  var q1 = c.indexOf(p);
                  if (q1 < 0) c.push(p)
                }
              }
            }, {
              key: "emit",
              value: function f(b) {
                var p = this.listenersMap.get(b);
                if (p !== void 0) {
                  for (var c = arguments.length, q1 = new Array(c > 1 ? c - 1 : 0), m1 = 1; m1 < c; m1++) q1[m1 - 1] = arguments[m1];
                  if (p.length === 1) {
                    var l1 = p[0];
                    l1.apply(null, q1)
                  } else {
                    var $1 = !1,
                      s1 = null,
                      XA = Array.from(p);
                    for (var jA = 0; jA < XA.length; jA++) {
                      var wA = XA[jA];
                      try {
                        wA.apply(null, q1)
                      } catch (pA) {
                        if (s1 === null) $1 = !0, s1 = pA
                      }
                    }
                    if ($1) throw s1
                  }
                }
              }
            }, {
              key: "removeAllListeners",
              value: function f() {
                this.listenersMap.clear()
              }
            }, {
              key: "removeListener",
              value: function f(b, p) {
                var c = this.listenersMap.get(b);
                if (c !== void 0) {
                  var q1 = c.indexOf(p);
                  if (q1 >= 0) c.splice(q1, 1)
                }
              }
            }]), M
          }(),
          J = Q(172),
          F = Q.n(J),
          X = "fmkadmapgofadopljbjfkapdkoienihi",
          V = "dnjnjgbfilfphmojnmhliehogmojhclc",
          C = "ikiahnapldjmdmpkmfhjdjilojjhgcbf",
          K = !1,
          E = !1,
          N = 1,
          q = 2,
          O = 3,
          R = 4,
          T = 5,
          L = 6,
          _ = 7,
          k = 1,
          i = 2,
          x = "React::DevTools::defaultTab",
          s = "React::DevTools::componentFilters",
          d = "React::DevTools::lastSelection",
          F1 = "React::DevTools::openInEditorUrl",
          X1 = "React::DevTools::openInEditorUrlPreset",
          v = "React::DevTools::parseHookNames",
          D1 = "React::DevTools::recordChangeDescriptions",
          N1 = "React::DevTools::reloadAndProfile",
          u1 = "React::DevTools::breakOnConsoleErrors",
          d1 = "React::DevTools::theme",
          YA = "React::DevTools::appendComponentStack",
          bA = "React::DevTools::showInlineWarningsAndErrors",
          e1 = "React::DevTools::traceUpdatesEnabled",
          k1 = "React::DevTools::hideConsoleLogsInStrictMode",
          Q1 = "React::DevTools::supportsProfiling",
          v1 = 5,
          L1 = "color: rgba(124, 124, 124, 0.75)",
          BA = "\x1B[2;38;2;124;124;124m%s\x1B[0m",
          HA = "\x1B[2;38;2;124;124;124m%s %o\x1B[0m";

        function MA(M) {
          try {
            return localStorage.getItem(M)
          } catch (f) {
            return null
          }
        }

        function t(M) {
          try {
            localStorage.removeItem(M)
          } catch (f) {}
        }

        function B1(M, f) {
          try {
            return localStorage.setItem(M, f)
          } catch (b) {}
        }

        function W1(M) {
          try {
            return sessionStorage.getItem(M)
          } catch (f) {
            return null
          }
        }

        function w1(M) {
          try {
            sessionStorage.removeItem(M)
          } catch (f) {}
        }

        function P1(M, f) {
          try {
            return sessionStorage.setItem(M, f)
          } catch (b) {}
        }
        var e = function M(f, b) {
          return f === b
        };

        function y1(M) {
          var f = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : e,
            b = void 0,
            p = [],
            c = void 0,
            q1 = !1,
            m1 = function $1(s1, XA) {
              return f(s1, p[XA])
            },
            l1 = function $1() {
              for (var s1 = arguments.length, XA = Array(s1), jA = 0; jA < s1; jA++) XA[jA] = arguments[jA];
              if (q1 && b === this && XA.length === p.length && XA.every(m1)) return c;
              return q1 = !0, b = this, p = XA, c = M.apply(this, XA), c
            };
          return l1
        }

        function O1(M) {
          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") O1 = function f(b) {
            return typeof b
          };
          else O1 = function f(b) {
            return b && typeof Symbol === "function" && b.constructor === Symbol && b !== Symbol.prototype ? "symbol" : typeof b
          };
          return O1(M)
        }

        function h1(M, f) {
          return fA(M) || Y0(M, f) || QA(M, f) || o1()
        }

        function o1() {
          throw new TypeError(`Invalid attempt to destructure non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
        }

        function QA(M, f) {
          if (!M) return;
          if (typeof M === "string") return zA(M, f);
          var b = Object.prototype.toString.call(M).slice(8, -1);
          if (b === "Object" && M.constructor) b = M.constructor.name;
          if (b === "Map" || b === "Set") return Array.from(M);
          if (b === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(b)) return zA(M, f)
        }

        function zA(M, f) {
          if (f == null || f > M.length) f = M.length;
          for (var b = 0, p = new Array(f); b < f; b++) p[b] = M[b];
          return p
        }

        function Y0(M, f) {
          if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(M))) return;
          var b = [],
            p = !0,
            c = !1,
            q1 = void 0;
          try {
            for (var m1 = M[Symbol.iterator](), l1; !(p = (l1 = m1.next()).done); p = !0)
              if (b.push(l1.value), f && b.length === f) break
          } catch ($1) {
            c = !0, q1 = $1
          } finally {
            try {
              if (!p && m1.return != null) m1.return()
            } finally {
              if (c) throw q1
            }
          }
          return b
        }

        function fA(M) {
          if (Array.isArray(M)) return M
        }
        var H0 = function M(f, b) {
            var p = j9(f),
              c = j9(b),
              q1 = p.pop(),
              m1 = c.pop(),
              l1 = T0(p, c);
            if (l1 !== 0) return l1;
            if (q1 && m1) return T0(q1.split("."), m1.split("."));
            else if (q1 || m1) return q1 ? -1 : 1;
            return 0
          },
          k2 = function M(f) {
            return typeof f === "string" && /^[v\d]/.test(f) && h2.test(f)
          },
          s0 = function M(f, b, p) {
            h9(p);
            var c = H0(f, b);
            return V0[p].includes(c)
          },
          q2 = function M(f, b) {
            var p = b.match(/^([<>=~^]+)/),
              c = p ? p[1] : "=";
            if (c !== "^" && c !== "~") return s0(f, b, c);
            var q1 = j9(f),
              m1 = h1(q1, 5),
              l1 = m1[0],
              $1 = m1[1],
              s1 = m1[2],
              XA = m1[4],
              jA = j9(b),
              wA = h1(jA, 5),
              pA = wA[0],
              W0 = wA[1],
              E2 = wA[2],
              N0 = wA[4],
              m2 = [l1, $1, s1],
              K4 = [pA, W0 !== null && W0 !== void 0 ? W0 : "x", E2 !== null && E2 !== void 0 ? E2 : "x"];
            if (N0) {
              if (!XA) return !1;
              if (T0(m2, K4) !== 0) return !1;
              if (T0(XA.split("."), N0.split(".")) === -1) return !1
            }
            var E6 = K4.findIndex(function(m4) {
                return m4 !== "0"
              }) + 1,
              D2 = c === "~" ? 2 : E6 > 1 ? E6 : 1;
            if (T0(m2.slice(0, D2), K4.slice(0, D2)) !== 0) return !1;
            if (T0(m2.slice(D2), K4.slice(D2)) === -1) return !1;
            return !0
          },
          h2 = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i,
          j9 = function M(f) {
            if (typeof f !== "string") throw new TypeError("Invalid argument expected string");
            var b = f.match(h2);
            if (!b) throw new Error("Invalid argument not valid semver ('".concat(f, "' received)"));
            return b.shift(), b
          },
          w6 = function M(f) {
            return f === "*" || f === "x" || f === "X"
          },
          E0 = function M(f) {
            var b = parseInt(f, 10);
            return isNaN(b) ? f : b
          },
          g0 = function M(f, b) {
            return O1(f) !== O1(b) ? [String(f), String(b)] : [f, b]
          },
          y0 = function M(f, b) {
            if (w6(f) || w6(b)) return 0;
            var p = g0(E0(f), E0(b)),
              c = h1(p, 2),
              q1 = c[0],
              m1 = c[1];
            if (q1 > m1) return 1;
            if (q1 < m1) return -1;
            return 0
          },
          T0 = function M(f, b) {
            for (var p = 0; p < Math.max(f.length, b.length); p++) {
              var c = y0(f[p] || "0", b[p] || "0");
              if (c !== 0) return c
            }
            return 0
          },
          V0 = {
            ">": [1],
            ">=": [0, 1],
            "=": [0],
            "<=": [-1, 0],
            "<": [-1]
          },
          N2 = Object.keys(V0),
          h9 = function M(f) {
            if (typeof f !== "string") throw new TypeError("Invalid operator type, expected string but got ".concat(O1(f)));
            if (N2.indexOf(f) === -1) throw new Error("Invalid operator, expected one of ".concat(N2.join("|")))
          },
          z5 = Q(730),
          W3 = Q.n(z5),
          Z6 = Q(890),
          r2 = !0,
          v6 = !0,
          J3 = !0,
          uQ = !1,
          x0 = !0,
          d0 = !0,
          L9 = !1,
          w5 = !1,
          _B = !1,
          D6 = !1,
          F3 = !0,
          X3 = null,
          q7 = !0,
          V3 = !0,
          H2 = null,
          w9 = null,
          j5 = null,
          j8 = !1,
          y3 = !1,
          WQ = !1,
          nI = !1,
          AD = !1,
          aI = null,
          pQ = !0,
          BD = !1,
          cQ = null,
          rG = null,
          zB = !0,
          e7 = !1,
          S1 = null,
          T1 = !1,
          VA = null,
          OA = !1,
          KA = !1,
          PA = 5000,
          D0 = 250,
          lA = 5000,
          NA = !0,
          SA = !0,
          uA = !0,
          W2 = !0,
          c0 = !0,
          z2 = !0,
          V1 = !0,
          c1 = !0,
          _1 = !0,
          t1 = !0,
          DA = !0,
          IA = !0,
          xA = !0,
          oA = !0,
          sA = !1,
          C0 = !1,
          U0 = !0,
          i0 = !1,
          R9 = !1,
          Z4 = !1,
          x4 = null,
          W5 = null,
          b6 = null,
          C3 = null,
          AI = null,
          QD = !1,
          jW = null,
          BI = null,
          yW = !1,
          ID = !0,
          L4 = !1;

        function QI(M) {
          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") QI = function f(b) {
            return typeof b
          };
          else QI = function f(b) {
            return b && typeof Symbol === "function" && b.constructor === Symbol && b !== Symbol.prototype ? "symbol" : typeof b
          };
          return QI(M)
        }
        var GD = Symbol.for("react.element"),
          qV = NA ? Symbol.for("react.transitional.element") : GD,
          e$ = Symbol.for("react.portal"),
          eK = Symbol.for("react.fragment"),
          wB = Symbol.for("react.strict_mode"),
          AH = Symbol.for("react.profiler"),
          Aq = Symbol.for("react.provider"),
          jE = Symbol.for("react.consumer"),
          MT = Symbol.for("react.context"),
          i6 = Symbol.for("react.forward_ref"),
          R4 = Symbol.for("react.suspense"),
          MV = Symbol.for("react.suspense_list"),
          Bq = Symbol.for("react.memo"),
          jB = Symbol.for("react.lazy"),
          oG = Symbol.for("react.scope"),
          yE = Symbol.for("react.debug_trace_mode"),
          Qq = Symbol.for("react.offscreen"),
          XF = Symbol.for("react.legacy_hidden"),
          Iq = Symbol.for("react.tracing_marker"),
          E5 = Symbol.for("react.memo_cache_sentinel"),
          kW = Symbol.for("react.postpone"),
          M7 = Symbol.iterator,
          LV = "@@iterator";

        function RV(M) {
          if (M === null || QI(M) !== "object") return null;
          var f = M7 && M[M7] || M[LV];
          if (typeof f === "function") return f;
          return null
        }
        var y5 = Symbol.asyncIterator,
          n6 = 1,
          tG = 2,
          EB = 5,
          yB = 6,
          t4 = 7,
          ZD = 8,
          J5 = 9,
          Z9 = 10,
          P6 = 11,
          Q8 = 12,
          k5 = 13,
          lQ = 14,
          kB = 1,
          eG = 2,
          S6 = 3,
          JQ = 4,
          L7 = 1,
          OV = Array.isArray;
        let K3 = OV;
        var BH = Q(169);

        function DD(M, f) {
          var b = Object.keys(M);
          if (Object.getOwnPropertySymbols) {
            var p = Object.getOwnPropertySymbols(M);
            if (f) p = p.filter(function(c) {
              return Object.getOwnPropertyDescriptor(M, c).enumerable
            });
            b.push.apply(b, p)
          }
          return b
        }

        function QH(M) {
          for (var f = 1; f < arguments.length; f++) {
            var b = arguments[f] != null ? arguments[f] : {};
            if (f % 2) DD(Object(b), !0).forEach(function(p) {
              Gq(M, p, b[p])
            });
            else if (Object.getOwnPropertyDescriptors) Object.defineProperties(M, Object.getOwnPropertyDescriptors(b));
            else DD(Object(b)).forEach(function(p) {
              Object.defineProperty(M, p, Object.getOwnPropertyDescriptor(b, p))
            })
          }
          return M
        }

        function Gq(M, f, b) {
          if (f in M) Object.defineProperty(M, f, {
            value: b,
            enumerable: !0,
            configurable: !0,
            writable: !0
          });
          else M[f] = b;
          return M
        }

        function sI(M) {
          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") sI = function f(b) {
            return typeof b
          };
          else sI = function f(b) {
            return b && typeof Symbol === "function" && b.constructor === Symbol && b !== Symbol.prototype ? "symbol" : typeof b
          };
          return sI(M)
        }

        function BY(M) {
          return TA(M) || p1(M) || A1(M) || o()
        }

        function o() {
          throw new TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
        }

        function A1(M, f) {
          if (!M) return;
          if (typeof M === "string") return vA(M, f);
          var b = Object.prototype.toString.call(M).slice(8, -1);
          if (b === "Object" && M.constructor) b = M.constructor.name;
          if (b === "Map" || b === "Set") return Array.from(M);
          if (b === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(b)) return vA(M, f)
        }

        function p1(M) {
          if (typeof Symbol !== "undefined" && Symbol.iterator in Object(M)) return Array.from(M)
        }

        function TA(M) {
          if (Array.isArray(M)) return vA(M)
        }

        function vA(M, f) {
          if (f == null || f > M.length) f = M.length;
          for (var b = 0, p = new Array(f); b < f; b++) p[b] = M[b];
          return p
        }
        var v0 = Object.prototype.hasOwnProperty,
          o2 = new WeakMap,
          t9 = new(W3())({
            max: 1000
          });

        function _6(M, f) {
          if (M.toString() > f.toString()) return 1;
          else if (f.toString() > M.toString()) return -1;
          else return 0
        }

        function y8(M) {
          var f = new Set,
            b = M,
            p = function c() {
              var q1 = [].concat(BY(Object.keys(b)), BY(Object.getOwnPropertySymbols(b))),
                m1 = Object.getOwnPropertyDescriptors(b);
              q1.forEach(function(l1) {
                if (m1[l1].enumerable) f.add(l1)
              }), b = Object.getPrototypeOf(b)
            };
          while (b != null) p();
          return f
        }

        function k3(M, f, b, p) {
          var c = M === null || M === void 0 ? void 0 : M.displayName;
          return c || "".concat(b, "(").concat(F5(f, p), ")")
        }

        function F5(M) {
          var f = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "Anonymous",
            b = o2.get(M);
          if (b != null) return b;
          var p = f;
          if (typeof M.displayName === "string") p = M.displayName;
          else if (typeof M.name === "string" && M.name !== "") p = M.name;
          return o2.set(M, p), p
        }
        var rI = 0;

        function FQ() {
          return ++rI
        }

        function oI(M, f, b) {
          var p = "";
          for (var c = f; c <= b; c++) p += String.fromCodePoint(M[c]);
          return p
        }

        function R7(M, f) {
          return ((M & 1023) << 10) + (f & 1023) + 65536
        }

        function VF(M) {
          var f = t9.get(M);
          if (f !== void 0) return f;
          var b = [],
            p = 0,
            c;
          while (p < M.length) {
            if (c = M.charCodeAt(p), (c & 63488) === 55296) b.push(R7(c, M.charCodeAt(++p)));
            else b.push(c);
            ++p
          }
          return t9.set(M, b), b
        }

        function LT(M) {
          var f = M[0],
            b = M[1],
            p = ["operations for renderer:".concat(f, " and root:").concat(b)],
            c = 2,
            q1 = [null],
            m1 = M[c++],
            l1 = c + m1;
          while (c < l1) {
            var $1 = M[c++],
              s1 = oI(M, c, c + $1 - 1);
            q1.push(s1), c += $1
          }
          while (c < M.length) {
            var XA = M[c];
            switch (XA) {
              case N: {
                var jA = M[c + 1],
                  wA = M[c + 2];
                if (c += 3, wA === P6) p.push("Add new root node ".concat(jA)), c++, c++, c++, c++;
                else {
                  var pA = M[c];
                  c++, c++;
                  var W0 = M[c],
                    E2 = q1[W0];
                  c++, c++, p.push("Add node ".concat(jA, " (").concat(E2 || "null", ") as child of ").concat(pA))
                }
                break
              }
              case q: {
                var N0 = M[c + 1];
                c += 2;
                for (var m2 = 0; m2 < N0; m2++) {
                  var K4 = M[c];
                  c += 1, p.push("Remove node ".concat(K4))
                }
                break
              }
              case L: {
                c += 1, p.push("Remove root ".concat(b));
                break
              }
              case _: {
                var E6 = M[c + 1],
                  D2 = M[c + 1];
                c += 3, p.push("Mode ".concat(D2, " set for subtree with root ").concat(E6));
                break
              }
              case O: {
                var m4 = M[c + 1],
                  U6 = M[c + 2];
                c += 3;
                var H4 = M.slice(c, c + U6);
                c += U6, p.push("Re-order node ".concat(m4, " children ").concat(H4.join(",")));
                break
              }
              case R:
                c += 3;
                break;
              case T:
                var a6 = M[c + 1],
                  f5 = M[c + 2],
                  E8 = M[c + 3];
                c += 4, p.push("Node ".concat(a6, " has ").concat(f5, " errors and ").concat(E8, " warnings"));
                break;
              default:
                throw Error('Unsupported Bridge operation "'.concat(XA, '"'))
            }
          }
          console.log(p.join(`
  `))
        }

        function Zq() {
          return [{
            type: kB,
            value: t4,
            isEnabled: !0
          }]
        }

        function xW() {
          try {
            var M = localStorageGetItem(LOCAL_STORAGE_COMPONENT_FILTER_PREFERENCES_KEY);
            if (M != null) {
              var f = JSON.parse(M);
              return QY(f)
            }
          } catch (b) {}
          return Zq()
        }

        function TV(M) {
          localStorageSetItem(LOCAL_STORAGE_COMPONENT_FILTER_PREFERENCES_KEY, JSON.stringify(QY(M)))
        }

        function QY(M) {
          if (!Array.isArray(M)) return M;
          return M.filter(function(f) {
            return f.type !== S6
          })
        }

        function kE(M) {
          if (M === "true") return !0;
          if (M === "false") return !1
        }

        function iQ(M) {
          if (M === !0 || M === !1) return M
        }

        function YD(M) {
          if (M === "light" || M === "dark" || M === "auto") return M
        }

        function Dq() {
          var M, f = localStorageGetItem(LOCAL_STORAGE_SHOULD_APPEND_COMPONENT_STACK_KEY);
          return (M = kE(f)) !== null && M !== void 0 ? M : !0
        }

        function CF() {
          var M, f = localStorageGetItem(LOCAL_STORAGE_SHOULD_BREAK_ON_CONSOLE_ERRORS);
          return (M = kE(f)) !== null && M !== void 0 ? M : !1
        }

        function IH() {
          var M, f = localStorageGetItem(LOCAL_STORAGE_HIDE_CONSOLE_LOGS_IN_STRICT_MODE);
          return (M = kE(f)) !== null && M !== void 0 ? M : !1
        }

        function jp() {
          var M, f = localStorageGetItem(LOCAL_STORAGE_SHOW_INLINE_WARNINGS_AND_ERRORS_KEY);
          return (M = kE(f)) !== null && M !== void 0 ? M : !0
        }

        function xE() {
          return typeof BH.env.EDITOR_URL === "string" ? BH.env.EDITOR_URL : ""
        }

        function WD() {
          try {
            var M = localStorageGetItem(LOCAL_STORAGE_OPEN_IN_EDITOR_URL);
            if (M != null) return JSON.parse(M)
          } catch (f) {}
          return xE()
        }

        function JD(M, f) {
          if (M === null) return {
            formattedDisplayName: null,
            hocDisplayNames: null,
            compiledWithForget: !1
          };
          if (M.startsWith("Forget(")) {
            var b = M.slice(7, M.length - 1),
              p = JD(b, f),
              c = p.formattedDisplayName,
              q1 = p.hocDisplayNames;
            return {
              formattedDisplayName: c,
              hocDisplayNames: q1,
              compiledWithForget: !0
            }
          }
          var m1 = null;
          switch (f) {
            case ElementTypeClass:
            case ElementTypeForwardRef:
            case ElementTypeFunction:
            case ElementTypeMemo:
              if (M.indexOf("(") >= 0) {
                var l1 = M.match(/[^()]+/g);
                if (l1 != null) M = l1.pop(), m1 = l1
              }
              break;
            default:
              break
          }
          return {
            formattedDisplayName: M,
            hocDisplayNames: m1,
            compiledWithForget: !1
          }
        }

        function O7(M, f) {
          for (var b in M)
            if (!(b in f)) return !0;
          for (var p in f)
            if (M[p] !== f[p]) return !0;
          return !1
        }

        function xB(M, f) {
          return f.reduce(function(b, p) {
            if (b) {
              if (v0.call(b, p)) return b[p];
              if (typeof b[Symbol.iterator] === "function") return Array.from(b)[p]
            }
            return null
          }, M)
        }

        function GH(M, f) {
          var b = f.length,
            p = f[b - 1];
          if (M != null) {
            var c = xB(M, f.slice(0, b - 1));
            if (c)
              if (K3(c)) c.splice(p, 1);
              else delete c[p]
          }
        }

        function fW(M, f, b) {
          var p = f.length;
          if (M != null) {
            var c = xB(M, f.slice(0, p - 1));
            if (c) {
              var q1 = f[p - 1],
                m1 = b[p - 1];
              if (c[m1] = c[q1], K3(c)) c.splice(q1, 1);
              else delete c[q1]
            }
          }
        }

        function fE(M, f, b) {
          var p = f.length,
            c = f[p - 1];
          if (M != null) {
            var q1 = xB(M, f.slice(0, p - 1));
            if (q1) q1[c] = b
          }
        }

        function Yq(M) {
          if (M === null) return "null";
          else if (M === void 0) return "undefined";
          if (Z6.kK(M)) return "react_element";
          if (typeof HTMLElement !== "undefined" && M instanceof HTMLElement) return "html_element";
          var f = sI(M);
          switch (f) {
            case "bigint":
              return "bigint";
            case "boolean":
              return "boolean";
            case "function":
              return "function";
            case "number":
              if (Number.isNaN(M)) return "nan";
              else if (!Number.isFinite(M)) return "infinity";
              else return "number";
            case "object":
              if (K3(M)) return "array";
              else if (ArrayBuffer.isView(M)) return v0.call(M.constructor, "BYTES_PER_ELEMENT") ? "typed_array" : "data_view";
              else if (M.constructor && M.constructor.name === "ArrayBuffer") return "array_buffer";
              else if (typeof M[Symbol.iterator] === "function") {
                var b = M[Symbol.iterator]();
                if (!b);
                else return b === M ? "opaque_iterator" : "iterator"
              } else if (M.constructor && M.constructor.name === "RegExp") return "regexp";
              else {
                var p = Object.prototype.toString.call(M);
                if (p === "[object Date]") return "date";
                else if (p === "[object HTMLAllCollection]") return "html_all_collection"
              }
              if (!w2(M)) return "class_instance";
              return "object";
            case "string":
              return "string";
            case "symbol":
              return "symbol";
            case "undefined":
              if (Object.prototype.toString.call(M) === "[object HTMLAllCollection]") return "html_all_collection";
              return "undefined";
            default:
              return "unknown"
          }
        }

        function k8(M) {
          if (sI(M) === "object" && M !== null) {
            var f = M.$$typeof;
            switch (f) {
              case GD:
                var b = M.type;
                switch (b) {
                  case eK:
                  case AH:
                  case wB:
                  case R4:
                  case MV:
                    return b;
                  default:
                    var p = b && b.$$typeof;
                    switch (p) {
                      case MT:
                      case i6:
                      case jB:
                      case Bq:
                        return p;
                      case jE:
                        if (xA) return p;
                      case Aq:
                        if (!xA) return p;
                      default:
                        return f
                    }
                }
              case e$:
                return f
            }
          }
          return
        }

        function AZ(M) {
          var f = Z6.kM(M) || k8(M);
          switch (f) {
            case Z6.AI:
              return "ContextConsumer";
            case Z6.HQ:
              return "ContextProvider";
            case Z6.A4:
              return "ForwardRef";
            case Z6.HY:
              return "Fragment";
            case Z6.oM:
              return "Lazy";
            case Z6._Y:
              return "Memo";
            case Z6.h_:
              return "Portal";
            case Z6.Q1:
              return "Profiler";
            case Z6.nF:
              return "StrictMode";
            case Z6.n4:
              return "Suspense";
            case MV:
              return "SuspenseList";
            case Iq:
              return "TracingMarker";
            default:
              var b = M.type;
              if (typeof b === "string") return b;
              else if (typeof b === "function") return F5(b, "Anonymous");
              else if (b != null) return "NotImplementedInDevtools";
              else return "Element"
          }
        }
        var JA = 50;

        function gA(M) {
          var f = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : JA;
          if (M.length > f) return M.slice(0, f) + "…";
          else return M
        }

        function $A(M, f) {
          if (M != null && v0.call(M, Y6.type)) return f ? M[Y6.preview_long] : M[Y6.preview_short];
          var b = Yq(M);
          switch (b) {
            case "html_element":
              return "<".concat(gA(M.tagName.toLowerCase()), " />");
            case "function":
              return gA("ƒ ".concat(typeof M.name === "function" ? "" : M.name, "() {}"));
            case "string":
              return '"'.concat(M, '"');
            case "bigint":
              return gA(M.toString() + "n");
            case "regexp":
              return gA(M.toString());
            case "symbol":
              return gA(M.toString());
            case "react_element":
              return "<".concat(gA(AZ(M) || "Unknown"), " />");
            case "array_buffer":
              return "ArrayBuffer(".concat(M.byteLength, ")");
            case "data_view":
              return "DataView(".concat(M.buffer.byteLength, ")");
            case "array":
              if (f) {
                var p = "";
                for (var c = 0; c < M.length; c++) {
                  if (c > 0) p += ", ";
                  if (p += $A(M[c], !1), p.length > JA) break
                }
                return "[".concat(gA(p), "]")
              } else {
                var q1 = v0.call(M, Y6.size) ? M[Y6.size] : M.length;
                return "Array(".concat(q1, ")")
              }
            case "typed_array":
              var m1 = "".concat(M.constructor.name, "(").concat(M.length, ")");
              if (f) {
                var l1 = "";
                for (var $1 = 0; $1 < M.length; $1++) {
                  if ($1 > 0) l1 += ", ";
                  if (l1 += M[$1], l1.length > JA) break
                }
                return "".concat(m1, " [").concat(gA(l1), "]")
              } else return m1;
            case "iterator":
              var s1 = M.constructor.name;
              if (f) {
                var XA = Array.from(M),
                  jA = "";
                for (var wA = 0; wA < XA.length; wA++) {
                  var pA = XA[wA];
                  if (wA > 0) jA += ", ";
                  if (K3(pA)) {
                    var W0 = $A(pA[0], !0),
                      E2 = $A(pA[1], !1);
                    jA += "".concat(W0, " => ").concat(E2)
                  } else jA += $A(pA, !1);
                  if (jA.length > JA) break
                }
                return "".concat(s1, "(").concat(M.size, ") {").concat(gA(jA), "}")
              } else return "".concat(s1, "(").concat(M.size, ")");
            case "opaque_iterator":
              return M[Symbol.toStringTag];
            case "date":
              return M.toString();
            case "class_instance":
              return M.constructor.name;
            case "object":
              if (f) {
                var N0 = Array.from(y8(M)).sort(_6),
                  m2 = "";
                for (var K4 = 0; K4 < N0.length; K4++) {
                  var E6 = N0[K4];
                  if (K4 > 0) m2 += ", ";
                  if (m2 += "".concat(E6.toString(), ": ").concat($A(M[E6], !1)), m2.length > JA) break
                }
                return "{".concat(gA(m2), "}")
              } else return "{…}";
            case "boolean":
            case "number":
            case "infinity":
            case "nan":
            case "null":
            case "undefined":
              return M;
            default:
              try {
                return gA(String(M))
              } catch (D2) {
                return "unserializable"
              }
          }
        }
        var w2 = function M(f) {
          var b = Object.getPrototypeOf(f);
          if (!b) return !0;
          var p = Object.getPrototypeOf(b);
          return !p
        };

        function f9(M) {
          var f = JD(M.displayName, M.type),
            b = f.formattedDisplayName,
            p = f.hocDisplayNames,
            c = f.compiledWithForget;
          return QH(QH({}, M), {}, {
            displayName: b,
            hocDisplayNames: p,
            compiledWithForget: c
          })
        }

        function E9(M) {
          return M.replace("/./", "/")
        }

        function b4(M, f) {
          var b = Object.keys(M);
          if (Object.getOwnPropertySymbols) {
            var p = Object.getOwnPropertySymbols(M);
            if (f) p = p.filter(function(c) {
              return Object.getOwnPropertyDescriptor(M, c).enumerable
            });
            b.push.apply(b, p)
          }
          return b
        }

        function D4(M) {
          for (var f = 1; f < arguments.length; f++) {
            var b = arguments[f] != null ? arguments[f] : {};
            if (f % 2) b4(Object(b), !0).forEach(function(p) {
              II(M, p, b[p])
            });
            else if (Object.getOwnPropertyDescriptors) Object.defineProperties(M, Object.getOwnPropertyDescriptors(b));
            else b4(Object(b)).forEach(function(p) {
              Object.defineProperty(M, p, Object.getOwnPropertyDescriptor(b, p))
            })
          }
          return M
        }

        function II(M, f, b) {
          if (f in M) Object.defineProperty(M, f, {
            value: b,
            enumerable: !0,
            configurable: !0,
            writable: !0
          });
          else M[f] = b;
          return M
        }
        var Y6 = {
            inspectable: Symbol("inspectable"),
            inspected: Symbol("inspected"),
            name: Symbol("name"),
            preview_long: Symbol("preview_long"),
            preview_short: Symbol("preview_short"),
            readonly: Symbol("readonly"),
            size: Symbol("size"),
            type: Symbol("type"),
            unserializable: Symbol("unserializable")
          },
          H3 = 2;

        function PV(M, f, b, p, c) {
          p.push(c);
          var q1 = {
            inspectable: f,
            type: M,
            preview_long: $A(b, !0),
            preview_short: $A(b, !1),
            name: typeof b.constructor !== "function" || typeof b.constructor.name !== "string" || b.constructor.name === "Object" ? "" : b.constructor.name
          };
          if (M === "array" || M === "typed_array") q1.size = b.length;
          else if (M === "object") q1.size = Object.keys(b).length;
          if (M === "iterator" || M === "typed_array") q1.readonly = !0;
          return q1
        }

        function fB(M, f, b, p, c) {
          var q1 = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : 0,
            m1 = Yq(M),
            l1;
          switch (m1) {
            case "html_element":
              return f.push(p), {
                inspectable: !1,
                preview_short: $A(M, !1),
                preview_long: $A(M, !0),
                name: M.tagName,
                type: m1
              };
            case "function":
              return f.push(p), {
                inspectable: !1,
                preview_short: $A(M, !1),
                preview_long: $A(M, !0),
                name: typeof M.name === "function" || !M.name ? "function" : M.name,
                type: m1
              };
            case "string":
              if (l1 = c(p), l1) return M;
              else return M.length <= 500 ? M : M.slice(0, 500) + "...";
            case "bigint":
              return f.push(p), {
                inspectable: !1,
                preview_short: $A(M, !1),
                preview_long: $A(M, !0),
                name: M.toString(),
                type: m1
              };
            case "symbol":
              return f.push(p), {
                inspectable: !1,
                preview_short: $A(M, !1),
                preview_long: $A(M, !0),
                name: M.toString(),
                type: m1
              };
            case "react_element":
              return f.push(p), {
                inspectable: !1,
                preview_short: $A(M, !1),
                preview_long: $A(M, !0),
                name: AZ(M) || "Unknown",
                type: m1
              };
            case "array_buffer":
            case "data_view":
              return f.push(p), {
                inspectable: !1,
                preview_short: $A(M, !1),
                preview_long: $A(M, !0),
                name: m1 === "data_view" ? "DataView" : "ArrayBuffer",
                size: M.byteLength,
                type: m1
              };
            case "array":
              if (l1 = c(p), q1 >= H3 && !l1) return PV(m1, !0, M, f, p);
              return M.map(function(jA, wA) {
                return fB(jA, f, b, p.concat([wA]), c, l1 ? 1 : q1 + 1)
              });
            case "html_all_collection":
            case "typed_array":
            case "iterator":
              if (l1 = c(p), q1 >= H3 && !l1) return PV(m1, !0, M, f, p);
              else {
                var $1 = {
                  unserializable: !0,
                  type: m1,
                  readonly: !0,
                  size: m1 === "typed_array" ? M.length : void 0,
                  preview_short: $A(M, !1),
                  preview_long: $A(M, !0),
                  name: typeof M.constructor !== "function" || typeof M.constructor.name !== "string" || M.constructor.name === "Object" ? "" : M.constructor.name
                };
                return Array.from(M).forEach(function(jA, wA) {
                  return $1[wA] = fB(jA, f, b, p.concat([wA]), c, l1 ? 1 : q1 + 1)
                }), b.push(p), $1
              }
            case "opaque_iterator":
              return f.push(p), {
                inspectable: !1,
                preview_short: $A(M, !1),
                preview_long: $A(M, !0),
                name: M[Symbol.toStringTag],
                type: m1
              };
            case "date":
              return f.push(p), {
                inspectable: !1,
                preview_short: $A(M, !1),
                preview_long: $A(M, !0),
                name: M.toString(),
                type: m1
              };
            case "regexp":
              return f.push(p), {
                inspectable: !1,
                preview_short: $A(M, !1),
                preview_long: $A(M, !0),
                name: M.toString(),
                type: m1
              };
            case "object":
              if (l1 = c(p), q1 >= H3 && !l1) return PV(m1, !0, M, f, p);
              else {
                var s1 = {};
                return y8(M).forEach(function(jA) {
                  var wA = jA.toString();
                  s1[wA] = fB(M[jA], f, b, p.concat([wA]), c, l1 ? 1 : q1 + 1)
                }), s1
              }
            case "class_instance":
              if (l1 = c(p), q1 >= H3 && !l1) return PV(m1, !0, M, f, p);
              var XA = {
                unserializable: !0,
                type: m1,
                readonly: !0,
                preview_short: $A(M, !1),
                preview_long: $A(M, !0),
                name: typeof M.constructor !== "function" || typeof M.constructor.name !== "string" ? "" : M.constructor.name
              };
              return y8(M).forEach(function(jA) {
                var wA = jA.toString();
                XA[wA] = fB(M[jA], f, b, p.concat([wA]), c, l1 ? 1 : q1 + 1)
              }), b.push(p), XA;
            case "infinity":
            case "nan":
            case "undefined":
              return f.push(p), {
                type: m1
              };
            default:
              return M
          }
        }

        function SV(M, f, b, p) {
          var c = getInObject(M, b);
          if (c != null) {
            if (!c[Y6.unserializable]) delete c[Y6.inspectable], delete c[Y6.inspected], delete c[Y6.name], delete c[Y6.preview_long], delete c[Y6.preview_short], delete c[Y6.readonly], delete c[Y6.size], delete c[Y6.type]
          }
          if (p !== null && f.unserializable.length > 0) {
            var q1 = f.unserializable[0],
              m1 = q1.length === b.length;
            for (var l1 = 0; l1 < b.length; l1++)
              if (b[l1] !== q1[l1]) {
                m1 = !1;
                break
              } if (m1) _V(p, p)
          }
          setInObject(M, b, p)
        }

        function vE(M, f, b) {
          return f.forEach(function(p) {
            var c = p.length,
              q1 = p[c - 1],
              m1 = getInObject(M, p.slice(0, c - 1));
            if (!m1 || !m1.hasOwnProperty(q1)) return;
            var l1 = m1[q1];
            if (!l1) return;
            else if (l1.type === "infinity") m1[q1] = 1 / 0;
            else if (l1.type === "nan") m1[q1] = NaN;
            else if (l1.type === "undefined") m1[q1] = void 0;
            else {
              var $1 = {};
              $1[Y6.inspectable] = !!l1.inspectable, $1[Y6.inspected] = !1, $1[Y6.name] = l1.name, $1[Y6.preview_long] = l1.preview_long, $1[Y6.preview_short] = l1.preview_short, $1[Y6.size] = l1.size, $1[Y6.readonly] = !!l1.readonly, $1[Y6.type] = l1.type, m1[q1] = $1
            }
          }), b.forEach(function(p) {
            var c = p.length,
              q1 = p[c - 1],
              m1 = getInObject(M, p.slice(0, c - 1));
            if (!m1 || !m1.hasOwnProperty(q1)) return;
            var l1 = m1[q1],
              $1 = D4({}, l1);
            _V($1, l1), m1[q1] = $1
          }), M
        }

        function _V(M, f) {
          var b;
          Object.defineProperties(M, (b = {}, II(b, Y6.inspected, {
            configurable: !0,
            enumerable: !1,
            value: !!f.inspected
          }), II(b, Y6.name, {
            configurable: !0,
            enumerable: !1,
            value: f.name
          }), II(b, Y6.preview_long, {
            configurable: !0,
            enumerable: !1,
            value: f.preview_long
          }), II(b, Y6.preview_short, {
            configurable: !0,
            enumerable: !1,
            value: f.preview_short
          }), II(b, Y6.size, {
            configurable: !0,
            enumerable: !1,
            value: f.size
          }), II(b, Y6.readonly, {
            configurable: !0,
            enumerable: !1,
            value: !!f.readonly
          }), II(b, Y6.type, {
            configurable: !0,
            enumerable: !1,
            value: f.type
          }), II(b, Y6.unserializable, {
            configurable: !0,
            enumerable: !1,
            value: !!f.unserializable
          }), b)), delete M.inspected, delete M.name, delete M.preview_long, delete M.preview_short, delete M.size, delete M.readonly, delete M.type, delete M.unserializable
        }
        var g4 = Array.isArray;

        function BZ(M) {
          return g4(M)
        }
        let tI = BZ;

        function jV(M, f) {
          var b;
          if (typeof Symbol === "undefined" || M[Symbol.iterator] == null) {
            if (Array.isArray(M) || (b = hE(M)) || f && M && typeof M.length === "number") {
              if (b) M = b;
              var p = 0,
                c = function $1() {};
              return {
                s: c,
                n: function $1() {
                  if (p >= M.length) return {
                    done: !0
                  };
                  return {
                    done: !1,
                    value: M[p++]
                  }
                },
                e: function $1(s1) {
                  throw s1
                },
                f: c
              }
            }
            throw new TypeError(`Invalid attempt to iterate non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
          }
          var q1 = !0,
            m1 = !1,
            l1;
          return {
            s: function $1() {
              b = M[Symbol.iterator]()
            },
            n: function $1() {
              var s1 = b.next();
              return q1 = s1.done, s1
            },
            e: function $1(s1) {
              m1 = !0, l1 = s1
            },
            f: function $1() {
              try {
                if (!q1 && b.return != null) b.return()
              } finally {
                if (m1) throw l1
              }
            }
          }
        }

        function ZH(M, f) {
          return bE(M) || uy(M, f) || hE(M, f) || dy()
        }

        function dy() {
          throw new TypeError(`Invalid attempt to destructure non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
        }

        function uy(M, f) {
          if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(M))) return;
          var b = [],
            p = !0,
            c = !1,
            q1 = void 0;
          try {
            for (var m1 = M[Symbol.iterator](), l1; !(p = (l1 = m1.next()).done); p = !0)
              if (b.push(l1.value), f && b.length === f) break
          } catch ($1) {
            c = !0, q1 = $1
          } finally {
            try {
              if (!p && m1.return != null) m1.return()
            } finally {
              if (c) throw q1
            }
          }
          return b
        }

        function bE(M) {
          if (Array.isArray(M)) return M
        }

        function FD(M) {
          return RT(M) || mE(M) || hE(M) || gE()
        }

        function gE() {
          throw new TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
        }

        function hE(M, f) {
          if (!M) return;
          if (typeof M === "string") return KF(M, f);
          var b = Object.prototype.toString.call(M).slice(8, -1);
          if (b === "Object" && M.constructor) b = M.constructor.name;
          if (b === "Map" || b === "Set") return Array.from(M);
          if (b === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(b)) return KF(M, f)
        }

        function mE(M) {
          if (typeof Symbol !== "undefined" && Symbol.iterator in Object(M)) return Array.from(M)
        }

        function RT(M) {
          if (Array.isArray(M)) return KF(M)
        }

        function KF(M, f) {
          if (f == null || f > M.length) f = M.length;
          for (var b = 0, p = new Array(f); b < f; b++) p[b] = M[b];
          return p
        }

        function vW(M) {
          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") vW = function f(b) {
            return typeof b
          };
          else vW = function f(b) {
            return b && typeof Symbol === "function" && b.constructor === Symbol && b !== Symbol.prototype ? "symbol" : typeof b
          };
          return vW(M)
        }

        function DH(M, f) {
          var b = Object.keys(M);
          if (Object.getOwnPropertySymbols) {
            var p = Object.getOwnPropertySymbols(M);
            if (f) p = p.filter(function(c) {
              return Object.getOwnPropertyDescriptor(M, c).enumerable
            });
            b.push.apply(b, p)
          }
          return b
        }

        function IY(M) {
          for (var f = 1; f < arguments.length; f++) {
            var b = arguments[f] != null ? arguments[f] : {};
            if (f % 2) DH(Object(b), !0).forEach(function(p) {
              HF(M, p, b[p])
            });
            else if (Object.getOwnPropertyDescriptors) Object.defineProperties(M, Object.getOwnPropertyDescriptors(b));
            else DH(Object(b)).forEach(function(p) {
              Object.defineProperty(M, p, Object.getOwnPropertyDescriptor(b, p))
            })
          }
          return M
        }

        function HF(M, f, b) {
          if (f in M) Object.defineProperty(M, f, {
            value: b,
            enumerable: !0,
            configurable: !0,
            writable: !0
          });
          else M[f] = b;
          return M
        }
        var YH = "999.9.9";

        function py(M) {
          if (M == null || M === "") return !1;
          return wF(M, YH)
        }

        function bW(M, f) {
          var b = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
          if (M !== null) {
            var p = [],
              c = [],
              q1 = fB(M, p, c, b, f);
            return {
              data: q1,
              cleaned: p,
              unserializable: c
            }
          } else return null
        }

        function Wq(M, f) {
          var b = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0,
            p = f[b],
            c = tI(M) ? M.slice() : IY({}, M);
          if (b + 1 === f.length)
            if (tI(c)) c.splice(p, 1);
            else delete c[p];
          else c[p] = Wq(M[p], f, b + 1);
          return c
        }

        function yV(M, f, b) {
          var p = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0,
            c = f[p],
            q1 = tI(M) ? M.slice() : IY({}, M);
          if (p + 1 === f.length) {
            var m1 = b[p];
            if (q1[m1] = q1[c], tI(q1)) q1.splice(c, 1);
            else delete q1[c]
          } else q1[c] = yV(M[c], f, b, p + 1);
          return q1
        }

        function zF(M, f, b) {
          var p = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
          if (p >= f.length) return b;
          var c = f[p],
            q1 = tI(M) ? M.slice() : IY({}, M);
          return q1[c] = zF(M[c], f, b, p + 1), q1
        }

        function Jq(M) {
          var f = null,
            b = null,
            p = M.current;
          if (p != null) {
            var c = p.stateNode;
            if (c != null) f = c.effectDuration != null ? c.effectDuration : null, b = c.passiveEffectDuration != null ? c.passiveEffectDuration : null
          }
          return {
            effectDuration: f,
            passiveEffectDuration: b
          }
        }

        function OT(M) {
          if (M === void 0) return "undefined";
          if (typeof M === "function") return M.toString();
          var f = new Set;
          return JSON.stringify(M, function(b, p) {
            if (vW(p) === "object" && p !== null) {
              if (f.has(p)) return;
              f.add(p)
            }
            if (typeof p === "bigint") return p.toString() + "n";
            return p
          }, 2)
        }

        function cy(M, f) {
          if (M === void 0 || M === null || M.length === 0 || typeof M[0] === "string" && M[0].match(/([^%]|^)(%c)/g) || f === void 0) return M;
          var b = /([^%]|^)((%%)*)(%([oOdisf]))/g;
          if (typeof M[0] === "string" && M[0].match(b)) return ["%c".concat(M[0]), f].concat(FD(M.slice(1)));
          else {
            var p = M.reduce(function(c, q1, m1) {
              if (m1 > 0) c += " ";
              switch (vW(q1)) {
                case "string":
                case "boolean":
                case "symbol":
                  return c += "%s";
                case "number":
                  var l1 = Number.isInteger(q1) ? "%i" : "%f";
                  return c += l1;
                default:
                  return c += "%o"
              }
            }, "%c");
            return [p, f].concat(FD(M))
          }
        }

        function yp(M) {
          for (var f = arguments.length, b = new Array(f > 1 ? f - 1 : 0), p = 1; p < f; p++) b[p - 1] = arguments[p];
          if (b.length === 0 || typeof M !== "string") return [M].concat(b);
          var c = b.slice(),
            q1 = "",
            m1 = 0;
          for (var l1 = 0; l1 < M.length; ++l1) {
            var $1 = M[l1];
            if ($1 !== "%") {
              q1 += $1;
              continue
            }
            var s1 = M[l1 + 1];
            switch (++l1, s1) {
              case "c":
              case "O":
              case "o": {
                ++m1, q1 += "%".concat(s1);
                break
              }
              case "d":
              case "i": {
                var XA = c.splice(m1, 1),
                  jA = ZH(XA, 1),
                  wA = jA[0];
                q1 += parseInt(wA, 10).toString();
                break
              }
              case "f": {
                var pA = c.splice(m1, 1),
                  W0 = ZH(pA, 1),
                  E2 = W0[0];
                q1 += parseFloat(E2).toString();
                break
              }
              case "s": {
                var N0 = c.splice(m1, 1),
                  m2 = ZH(N0, 1),
                  K4 = m2[0];
                q1 += K4.toString();
                break
              }
              default:
                q1 += "%".concat(s1)
            }
          }
          return [q1].concat(FD(c))
        }

        function ly(M) {
          for (var f = arguments.length, b = new Array(f > 1 ? f - 1 : 0), p = 1; p < f; p++) b[p - 1] = arguments[p];
          var c = b.slice(),
            q1 = String(M);
          if (typeof M === "string") {
            if (c.length) {
              var m1 = /(%?)(%([jds]))/g;
              q1 = q1.replace(m1, function($1, s1, XA, jA) {
                var wA = c.shift();
                switch (jA) {
                  case "s":
                    wA += "";
                    break;
                  case "d":
                  case "i":
                    wA = parseInt(wA, 10).toString();
                    break;
                  case "f":
                    wA = parseFloat(wA).toString();
                    break
                }
                if (!s1) return wA;
                return c.unshift(wA), $1
              })
            }
          }
          if (c.length)
            for (var l1 = 0; l1 < c.length; l1++) q1 += " " + String(c[l1]);
          return q1 = q1.replace(/%{2,2}/g, "%"), String(q1)
        }

        function z3() {
          return !!(window.document && window.document.featurePolicy && window.document.featurePolicy.allowsFeature("sync-xhr"))
        }

        function XQ() {
          var M = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "",
            f = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
          return H0(M, f) === 1
        }

        function wF() {
          var M = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "",
            f = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
          return H0(M, f) > -1
        }
        var dE = function M() {
          return window.document == null
        };

        function Fq(M) {
          if (M.indexOf(":") === -1) return null;
          var f = M.replace(/^\(+/, "").replace(/\)+$/, ""),
            b = /(at )?(.+?)(?::(\d+))?(?::(\d+))?$/.exec(f);
          if (b == null) return null;
          var p = ZH(b, 5),
            c = p[2],
            q1 = p[3],
            m1 = p[4];
          return {
            sourceURL: c,
            line: q1,
            column: m1
          }
        }
        var Xq = /^\s*at .*(\S+:\d+|\(native\))/m;

        function TT(M) {
          var f = M.split(`
`),
            b = jV(f),
            p;
          try {
            for (b.s(); !(p = b.n()).done;) {
              var c = p.value,
                q1 = c.trim(),
                m1 = q1.match(/ (\(.+\)$)/),
                l1 = m1 ? m1[1] : q1,
                $1 = Fq(l1);
              if ($1 == null) continue;
              var {
                sourceURL: s1,
                line: XA
              } = $1, jA = XA === void 0 ? "1" : XA, wA = $1.column, pA = wA === void 0 ? "1" : wA;
              return {
                sourceURL: s1,
                line: parseInt(jA, 10),
                column: parseInt(pA, 10)
              }
            }
          } catch (W0) {
            b.e(W0)
          } finally {
            b.f()
          }
          return null
        }

        function uE(M) {
          var f = M.split(`
`),
            b = jV(f),
            p;
          try {
            for (b.s(); !(p = b.n()).done;) {
              var c = p.value,
                q1 = c.trim(),
                m1 = q1.replace(/((.*".+"[^@]*)?[^@]*)(?:@)/, ""),
                l1 = Fq(m1);
              if (l1 == null) continue;
              var {
                sourceURL: $1,
                line: s1
              } = l1, XA = s1 === void 0 ? "1" : s1, jA = l1.column, wA = jA === void 0 ? "1" : jA;
              return {
                sourceURL: $1,
                line: parseInt(XA, 10),
                column: parseInt(wA, 10)
              }
            }
          } catch (pA) {
            b.e(pA)
          } finally {
            b.f()
          }
          return null
        }

        function PT(M) {
          if (M.match(Xq)) return TT(M);
          return uE(M)
        }

        function VQ(M) {
          if (!M.ownerDocument) return null;
          return M.ownerDocument.defaultView
        }

        function EF(M) {
          var f = VQ(M);
          if (f) return f.frameElement;
          return null
        }

        function UF(M) {
          var f = ST(M);
          return WH([M.getBoundingClientRect(), {
            top: f.borderTop,
            left: f.borderLeft,
            bottom: f.borderBottom,
            right: f.borderRight,
            width: 0,
            height: 0
          }])
        }

        function WH(M) {
          return M.reduce(function(f, b) {
            if (f == null) return b;
            return {
              top: f.top + b.top,
              left: f.left + b.left,
              width: f.width,
              height: f.height,
              bottom: f.bottom + b.bottom,
              right: f.right + b.right
            }
          })
        }

        function gW(M, f) {
          var b = EF(M);
          if (b && b !== f) {
            var p = [M.getBoundingClientRect()],
              c = b,
              q1 = !1;
            while (c) {
              var m1 = UF(c);
              if (p.push(m1), c = EF(c), q1) break;
              if (c && VQ(c) === f) q1 = !0
            }
            return WH(p)
          } else return M.getBoundingClientRect()
        }

        function ST(M) {
          var f = window.getComputedStyle(M);
          return {
            borderLeft: parseInt(f.borderLeftWidth, 10),
            borderRight: parseInt(f.borderRightWidth, 10),
            borderTop: parseInt(f.borderTopWidth, 10),
            borderBottom: parseInt(f.borderBottomWidth, 10),
            marginLeft: parseInt(f.marginLeft, 10),
            marginRight: parseInt(f.marginRight, 10),
            marginTop: parseInt(f.marginTop, 10),
            marginBottom: parseInt(f.marginBottom, 10),
            paddingLeft: parseInt(f.paddingLeft, 10),
            paddingRight: parseInt(f.paddingRight, 10),
            paddingTop: parseInt(f.paddingTop, 10),
            paddingBottom: parseInt(f.paddingBottom, 10)
          }
        }

        function pE(M, f) {
          if (!(M instanceof f)) throw new TypeError("Cannot call a class as a function")
        }

        function kV(M, f) {
          for (var b = 0; b < f.length; b++) {
            var p = f[b];
            if (p.enumerable = p.enumerable || !1, p.configurable = !0, "value" in p) p.writable = !0;
            Object.defineProperty(M, p.key, p)
          }
        }

        function cE(M, f, b) {
          if (f) kV(M.prototype, f);
          if (b) kV(M, b);
          return M
        }
        var GY = Object.assign,
          Vq = function() {
            function M(f, b) {
              pE(this, M), this.node = f.createElement("div"), this.border = f.createElement("div"), this.padding = f.createElement("div"), this.content = f.createElement("div"), this.border.style.borderColor = NF.border, this.padding.style.borderColor = NF.padding, this.content.style.backgroundColor = NF.background, GY(this.node.style, {
                borderColor: NF.margin,
                pointerEvents: "none",
                position: "fixed"
              }), this.node.style.zIndex = "10000000", this.node.appendChild(this.border), this.border.appendChild(this.padding), this.padding.appendChild(this.content), b.appendChild(this.node)
            }
            return cE(M, [{
              key: "remove",
              value: function f() {
                if (this.node.parentNode) this.node.parentNode.removeChild(this.node)
              }
            }, {
              key: "update",
              value: function f(b, p) {
                hW(p, "margin", this.node), hW(p, "border", this.border), hW(p, "padding", this.padding), GY(this.content.style, {
                  height: b.height - p.borderTop - p.borderBottom - p.paddingTop - p.paddingBottom + "px",
                  width: b.width - p.borderLeft - p.borderRight - p.paddingLeft - p.paddingRight + "px"
                }), GY(this.node.style, {
                  top: b.top - p.marginTop + "px",
                  left: b.left - p.marginLeft + "px"
                })
              }
            }]), M
          }(),
          JH = function() {
            function M(f, b) {
              pE(this, M), this.tip = f.createElement("div"), GY(this.tip.style, {
                display: "flex",
                flexFlow: "row nowrap",
                backgroundColor: "#333740",
                borderRadius: "2px",
                fontFamily: '"SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace',
                fontWeight: "bold",
                padding: "3px 5px",
                pointerEvents: "none",
                position: "fixed",
                fontSize: "12px",
                whiteSpace: "nowrap"
              }), this.nameSpan = f.createElement("span"), this.tip.appendChild(this.nameSpan), GY(this.nameSpan.style, {
                color: "#ee78e6",
                borderRight: "1px solid #aaaaaa",
                paddingRight: "0.5rem",
                marginRight: "0.5rem"
              }), this.dimSpan = f.createElement("span"), this.tip.appendChild(this.dimSpan), GY(this.dimSpan.style, {
                color: "#d7d7d7"
              }), this.tip.style.zIndex = "10000000", b.appendChild(this.tip)
            }
            return cE(M, [{
              key: "remove",
              value: function f() {
                if (this.tip.parentNode) this.tip.parentNode.removeChild(this.tip)
              }
            }, {
              key: "updateText",
              value: function f(b, p, c) {
                this.nameSpan.textContent = b, this.dimSpan.textContent = Math.round(p) + "px × " + Math.round(c) + "px"
              }
            }, {
              key: "updatePosition",
              value: function f(b, p) {
                var c = this.tip.getBoundingClientRect(),
                  q1 = z1(b, p, {
                    width: c.width,
                    height: c.height
                  });
                GY(this.tip.style, q1.style)
              }
            }]), M
          }(),
          _T = function() {
            function M(f) {
              pE(this, M);
              var b = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
              this.window = b;
              var p = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
              this.tipBoundsWindow = p;
              var c = b.document;
              this.container = c.createElement("div"), this.container.style.zIndex = "10000000", this.tip = new JH(c, this.container), this.rects = [], this.agent = f, c.body.appendChild(this.container)
            }
            return cE(M, [{
              key: "remove",
              value: function f() {
                if (this.tip.remove(), this.rects.forEach(function(b) {
                    b.remove()
                  }), this.rects.length = 0, this.container.parentNode) this.container.parentNode.removeChild(this.container)
              }
            }, {
              key: "inspect",
              value: function f(b, p) {
                var c = this,
                  q1 = b.filter(function(pA) {
                    return pA.nodeType === Node.ELEMENT_NODE
                  });
                while (this.rects.length > q1.length) {
                  var m1 = this.rects.pop();
                  m1.remove()
                }
                if (q1.length === 0) return;
                while (this.rects.length < q1.length) this.rects.push(new Vq(this.window.document, this.container));
                var l1 = {
                  top: Number.POSITIVE_INFINITY,
                  right: Number.NEGATIVE_INFINITY,
                  bottom: Number.NEGATIVE_INFINITY,
                  left: Number.POSITIVE_INFINITY
                };
                if (q1.forEach(function(pA, W0) {
                    var E2 = gW(pA, c.window),
                      N0 = ST(pA);
                    l1.top = Math.min(l1.top, E2.top - N0.marginTop), l1.right = Math.max(l1.right, E2.left + E2.width + N0.marginRight), l1.bottom = Math.max(l1.bottom, E2.top + E2.height + N0.marginBottom), l1.left = Math.min(l1.left, E2.left - N0.marginLeft);
                    var m2 = c.rects[W0];
                    m2.update(E2, N0)
                  }), !p) {
                  p = q1[0].nodeName.toLowerCase();
                  var $1 = q1[0],
                    s1 = this.agent.getBestMatchingRendererInterface($1);
                  if (s1) {
                    var XA = s1.getFiberIDForNative($1, !0);
                    if (XA) {
                      var jA = s1.getDisplayNameForFiberID(XA, !0);
                      if (jA) p += " (in " + jA + ")"
                    }
                  }
                }
                this.tip.updateText(p, l1.right - l1.left, l1.bottom - l1.top);
                var wA = gW(this.tipBoundsWindow.document.documentElement, this.window);
                this.tip.updatePosition({
                  top: l1.top,
                  left: l1.left,
                  height: l1.bottom - l1.top,
                  width: l1.right - l1.left
                }, {
                  top: wA.top + this.tipBoundsWindow.scrollY,
                  left: wA.left + this.tipBoundsWindow.scrollX,
                  height: this.tipBoundsWindow.innerHeight,
                  width: this.tipBoundsWindow.innerWidth
                })
              }
            }]), M
          }();

        function z1(M, f, b) {
          var p = Math.max(b.height, 20),
            c = Math.max(b.width, 60),
            q1 = 5,
            m1;
          if (M.top + M.height + p <= f.top + f.height)
            if (M.top + M.height < f.top + 0) m1 = f.top + q1;
            else m1 = M.top + M.height + q1;
          else if (M.top - p <= f.top + f.height)
            if (M.top - p - q1 < f.top + q1) m1 = f.top + q1;
            else m1 = M.top - p - q1;
          else m1 = f.top + f.height - p - q1;
          var l1 = M.left + q1;
          if (M.left < f.left) l1 = f.left + q1;
          if (M.left + c > f.left + f.width) l1 = f.left + f.width - c - q1;
          return m1 += "px", l1 += "px", {
            style: {
              top: m1,
              left: l1
            }
          }
        }

        function hW(M, f, b) {
          GY(b.style, {
            borderTopWidth: M[f + "Top"] + "px",
            borderLeftWidth: M[f + "Left"] + "px",
            borderRightWidth: M[f + "Right"] + "px",
            borderBottomWidth: M[f + "Bottom"] + "px",
            borderStyle: "solid"
          })
        }
        var NF = {
            background: "rgba(120, 170, 210, 0.7)",
            padding: "rgba(77, 200, 0, 0.3)",
            margin: "rgba(255, 155, 0, 0.3)",
            border: "rgba(255, 200, 50, 0.3)"
          },
          QZ = 2000,
          U9 = null,
          vB = null;

        function iy(M) {
          M.emit("hideNativeHighlight")
        }

        function ny() {
          if (U9 = null, vB !== null) vB.remove(), vB = null
        }

        function eI(M) {
          return dE() ? iy(M) : ny()
        }

        function ay(M, f) {
          f.emit("showNativeHighlight", M)
        }

        function sy(M, f, b, p) {
          if (U9 !== null) clearTimeout(U9);
          if (vB === null) vB = new _T(b);
          if (vB.inspect(M, f), p) U9 = setTimeout(function() {
            return eI(b)
          }, QZ)
        }

        function Cq(M, f, b, p) {
          return dE() ? ay(M, b) : sy(M, f, b, p)
        }
        var lE = new Set;

        function jT(M, f) {
          M.addListener("clearNativeElementHighlight", m1), M.addListener("highlightNativeElement", l1), M.addListener("shutdown", c), M.addListener("startInspectingNative", b), M.addListener("stopInspectingNative", c);

          function b() {
            p(window)
          }

          function p(N0) {
            if (N0 && typeof N0.addEventListener === "function") N0.addEventListener("click", $1, !0), N0.addEventListener("mousedown", s1, !0), N0.addEventListener("mouseover", s1, !0), N0.addEventListener("mouseup", s1, !0), N0.addEventListener("pointerdown", XA, !0), N0.addEventListener("pointermove", wA, !0), N0.addEventListener("pointerup", pA, !0);
            else f.emit("startInspectingNative")
          }

          function c() {
            eI(f), q1(window), lE.forEach(function(N0) {
              try {
                q1(N0.contentWindow)
              } catch (m2) {}
            }), lE = new Set
          }

          function q1(N0) {
            if (N0 && typeof N0.removeEventListener === "function") N0.removeEventListener("click", $1, !0), N0.removeEventListener("mousedown", s1, !0), N0.removeEventListener("mouseover", s1, !0), N0.removeEventListener("mouseup", s1, !0), N0.removeEventListener("pointerdown", XA, !0), N0.removeEventListener("pointermove", wA, !0), N0.removeEventListener("pointerup", pA, !0);
            else f.emit("stopInspectingNative")
          }

          function m1() {
            eI(f)
          }

          function l1(N0) {
            var {
              displayName: m2,
              hideAfterTimeout: K4,
              id: E6,
              openNativeElementsPanel: D2,
              rendererID: m4,
              scrollIntoView: U6
            } = N0, H4 = f.rendererInterfaces[m4];
            if (H4 == null) {
              console.warn('Invalid renderer id "'.concat(m4, '" for element "').concat(E6, '"')), eI(f);
              return
            }
            if (!H4.hasFiberWithId(E6)) {
              eI(f);
              return
            }
            var a6 = H4.findNativeNodesForFiberID(E6);
            if (a6 != null && a6[0] != null) {
              var f5 = a6[0];
              if (U6 && typeof f5.scrollIntoView === "function") f5.scrollIntoView({
                block: "nearest",
                inline: "nearest"
              });
              if (Cq(a6, m2, f, K4), D2) window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0 = f5, M.send("syncSelectionToNativeElementsPanel")
            } else eI(f)
          }

          function $1(N0) {
            N0.preventDefault(), N0.stopPropagation(), c(), M.send("stopInspectingNative", !0)
          }

          function s1(N0) {
            N0.preventDefault(), N0.stopPropagation()
          }

          function XA(N0) {
            N0.preventDefault(), N0.stopPropagation(), W0(E2(N0))
          }
          var jA = null;

          function wA(N0) {
            N0.preventDefault(), N0.stopPropagation();
            var m2 = E2(N0);
            if (jA === m2) return;
            if (jA = m2, m2.tagName === "IFRAME") {
              var K4 = m2;
              try {
                if (!lE.has(K4)) {
                  var E6 = K4.contentWindow;
                  p(E6), lE.add(K4)
                }
              } catch (D2) {}
            }
            Cq([m2], null, f, !1), W0(m2)
          }

          function pA(N0) {
            N0.preventDefault(), N0.stopPropagation()
          }
          var W0 = F()(y1(function(N0) {
            var m2 = f.getIDForNode(N0);
            if (m2 !== null) M.send("selectFiber", m2)
          }), 200, {
            leading: !1
          });

          function E2(N0) {
            if (N0.composed) return N0.composedPath()[0];
            return N0.target
          }
        }
        var XD = "#f0f0f0",
          yT = ["#37afa9", "#63b19e", "#80b393", "#97b488", "#abb67d", "#beb771", "#cfb965", "#dfba57", "#efbb49", "#febc38"],
          IZ = null;

        function kT(M, f) {
          var b = [];
          AG(M, function(p, c, q1) {
            b.push({
              node: q1,
              color: c
            })
          }), f.emit("drawTraceUpdates", b)
        }

        function ry(M) {
          if (IZ === null) Kq();
          var f = IZ;
          f.width = window.innerWidth, f.height = window.innerHeight;
          var b = f.getContext("2d");
          b.clearRect(0, 0, f.width, f.height), AG(M, function(p, c) {
            if (p !== null) kp(b, p, c)
          })
        }

        function xT(M, f) {
          return dE() ? kT(M, f) : ry(M)
        }

        function AG(M, f) {
          M.forEach(function(b, p) {
            var {
              count: c,
              rect: q1
            } = b, m1 = Math.min(yT.length - 1, c - 1), l1 = yT[m1];
            f(q1, l1, p)
          })
        }

        function kp(M, f, b) {
          var {
            height: p,
            left: c,
            top: q1,
            width: m1
          } = f;
          M.lineWidth = 1, M.strokeStyle = XD, M.strokeRect(c - 1, q1 - 1, m1 + 2, p + 2), M.lineWidth = 1, M.strokeStyle = XD, M.strokeRect(c + 1, q1 + 1, m1 - 1, p - 1), M.strokeStyle = b, M.setLineDash([0]), M.lineWidth = 1, M.strokeRect(c, q1, m1 - 1, p - 1), M.setLineDash([0])
        }

        function oy(M) {
          M.emit("disableTraceUpdates")
        }

        function fT() {
          if (IZ !== null) {
            if (IZ.parentNode != null) IZ.parentNode.removeChild(IZ);
            IZ = null
          }
        }

        function ty(M) {
          return dE() ? oy(M) : fT()
        }

        function Kq() {
          IZ = window.document.createElement("canvas"), IZ.style.cssText = `
    xx-background-color: red;
    xx-opacity: 0.5;
    bottom: 0;
    left: 0;
    pointer-events: none;
    position: fixed;
    right: 0;
    top: 0;
    z-index: 1000000000;
  `;
          var M = window.document.documentElement;
          M.insertBefore(IZ, M.firstChild)
        }

        function x3(M) {
          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") x3 = function f(b) {
            return typeof b
          };
          else x3 = function f(b) {
            return b && typeof Symbol === "function" && b.constructor === Symbol && b !== Symbol.prototype ? "symbol" : typeof b
          };
          return x3(M)
        }
        var ey = 250,
          ZY = 3000,
          GZ = 250,
          FH = (typeof performance === "undefined" ? "undefined" : x3(performance)) === "object" && typeof performance.now === "function" ? function() {
            return performance.now()
          } : function() {
            return Date.now()
          },
          DY = new Map,
          xV = null,
          mW = null,
          Hq = !1,
          BG = null;

        function CQ(M) {
          xV = M, xV.addListener("traceUpdates", fp)
        }

        function xp(M) {
          if (Hq = M, !Hq) {
            if (DY.clear(), mW !== null) cancelAnimationFrame(mW), mW = null;
            if (BG !== null) clearTimeout(BG), BG = null;
            ty(xV)
          }
        }

        function fp(M) {
          if (!Hq) return;
          if (M.forEach(function(f) {
              var b = DY.get(f),
                p = FH(),
                c = b != null ? b.lastMeasuredAt : 0,
                q1 = b != null ? b.rect : null;
              if (q1 === null || c + GZ < p) c = p, q1 = bB(f);
              DY.set(f, {
                count: b != null ? b.count + 1 : 1,
                expirationTime: b != null ? Math.min(p + ZY, b.expirationTime + ey) : p + ey,
                lastMeasuredAt: c,
                rect: q1
              })
            }), BG !== null) clearTimeout(BG), BG = null;
          if (mW === null) mW = requestAnimationFrame(fV)
        }

        function fV() {
          mW = null, BG = null;
          var M = FH(),
            f = Number.MAX_VALUE;
          if (DY.forEach(function(b, p) {
              if (b.expirationTime < M) DY.delete(p);
              else f = Math.min(f, b.expirationTime)
            }), xT(DY, xV), f !== Number.MAX_VALUE) BG = setTimeout(fV, f - M)
        }

        function bB(M) {
          if (!M || typeof M.getBoundingClientRect !== "function") return null;
          var f = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
          return gW(M, f)
        }
        var zq = Q(987),
          $2 = 60111,
          dW = "Symbol(react.concurrent_mode)",
          iE = 60110,
          QG = "Symbol(react.context)",
          vT = "Symbol(react.server_context)",
          IG = "Symbol(react.async_mode)",
          GI = "Symbol(react.transitional.element)",
          Ak = 60103,
          Bk = "Symbol(react.element)",
          Qk = 60129,
          nE = "Symbol(react.debug_trace_mode)",
          YY = 60112,
          wq = "Symbol(react.forward_ref)",
          nQ = 60107,
          GG = "Symbol(react.fragment)",
          uW = 60116,
          bT = "Symbol(react.lazy)",
          f3 = 60115,
          ZG = "Symbol(react.memo)",
          Ik = 60106,
          v3 = "Symbol(react.portal)",
          Eq = 60114,
          XH = "Symbol(react.profiler)",
          WY = 60109,
          aE = "Symbol(react.provider)",
          KQ = "Symbol(react.consumer)",
          VH = 60119,
          Uq = "Symbol(react.scope)",
          CH = 60108,
          KH = "Symbol(react.strict_mode)",
          sE = 60113,
          Nq = "Symbol(react.suspense)",
          HH = 60120,
          gT = "Symbol(react.suspense_list)",
          Gk = "Symbol(react.server_context.defaultValue)",
          Zk = Symbol.for("react.memo_cache_sentinel"),
          zH = !1,
          vp = !1,
          hT = !1;

        function rE(M, f) {
          return M === f && (M !== 0 || 1 / M === 1 / f) || M !== M && f !== f
        }
        var s8 = typeof Object.is === "function" ? Object.is : rE;
        let h4 = s8;
        var b3 = Object.prototype.hasOwnProperty;
        let gB = b3;
        var hB = new Map;

        function T7(M) {
          var f = new Set,
            b = {};
          return $F(M, f, b), {
            sources: Array.from(f).sort(),
            resolvedStyles: b
          }
        }

        function $F(M, f, b) {
          if (M == null) return;
          if (K3(M)) M.forEach(function(p) {
            if (p == null) return;
            if (K3(p)) $F(p, f, b);
            else r8(p, f, b)
          });
          else r8(M, f, b);
          b = Object.fromEntries(Object.entries(b).sort())
        }

        function r8(M, f, b) {
          var p = Object.keys(M);
          p.forEach(function(c) {
            var q1 = M[c];
            if (typeof q1 === "string")
              if (c === q1) f.add(c);
              else {
                var m1 = wH(q1);
                if (m1 != null) b[c] = m1
              }
            else {
              var l1 = {};
              b[c] = l1, $F([q1], f, l1)
            }
          })
        }

        function wH(M) {
          if (hB.has(M)) return hB.get(M);
          for (var f = 0; f < document.styleSheets.length; f++) {
            var b = document.styleSheets[f],
              p = null;
            try {
              p = b.cssRules
            } catch (wA) {
              continue
            }
            for (var c = 0; c < p.length; c++) {
              if (!(p[c] instanceof CSSStyleRule)) continue;
              var q1 = p[c],
                m1 = q1.cssText,
                l1 = q1.selectorText,
                $1 = q1.style;
              if (l1 != null) {
                if (l1.startsWith(".".concat(M))) {
                  var s1 = m1.match(/{ *([a-z\-]+):/);
                  if (s1 !== null) {
                    var XA = s1[1],
                      jA = $1.getPropertyValue(XA);
                    return hB.set(M, jA), jA
                  } else return null
                }
              }
            }
          }
          return null
        }
        var vV = "https://github.com/facebook/react/blob/main/packages/react-devtools/CHANGELOG.md",
          $q = "https://reactjs.org/blog/2019/08/15/new-react-devtools.html#how-do-i-get-the-old-version-back",
          oE = "https://fburl.com/react-devtools-workplace-group",
          EH = {
            light: {
              "--color-attribute-name": "#ef6632",
              "--color-attribute-name-not-editable": "#23272f",
              "--color-attribute-name-inverted": "rgba(255, 255, 255, 0.7)",
              "--color-attribute-value": "#1a1aa6",
              "--color-attribute-value-inverted": "#ffffff",
              "--color-attribute-editable-value": "#1a1aa6",
              "--color-background": "#ffffff",
              "--color-background-hover": "rgba(0, 136, 250, 0.1)",
              "--color-background-inactive": "#e5e5e5",
              "--color-background-invalid": "#fff0f0",
              "--color-background-selected": "#0088fa",
              "--color-button-background": "#ffffff",
              "--color-button-background-focus": "#ededed",
              "--color-button": "#5f6673",
              "--color-button-disabled": "#cfd1d5",
              "--color-button-active": "#0088fa",
              "--color-button-focus": "#23272f",
              "--color-button-hover": "#23272f",
              "--color-border": "#eeeeee",
              "--color-commit-did-not-render-fill": "#cfd1d5",
              "--color-commit-did-not-render-fill-text": "#000000",
              "--color-commit-did-not-render-pattern": "#cfd1d5",
              "--color-commit-did-not-render-pattern-text": "#333333",
              "--color-commit-gradient-0": "#37afa9",
              "--color-commit-gradient-1": "#63b19e",
              "--color-commit-gradient-2": "#80b393",
              "--color-commit-gradient-3": "#97b488",
              "--color-commit-gradient-4": "#abb67d",
              "--color-commit-gradient-5": "#beb771",
              "--color-commit-gradient-6": "#cfb965",
              "--color-commit-gradient-7": "#dfba57",
              "--color-commit-gradient-8": "#efbb49",
              "--color-commit-gradient-9": "#febc38",
              "--color-commit-gradient-text": "#000000",
              "--color-component-name": "#6a51b2",
              "--color-component-name-inverted": "#ffffff",
              "--color-component-badge-background": "#e6e6e6",
              "--color-component-badge-background-inverted": "rgba(255, 255, 255, 0.25)",
              "--color-component-badge-count": "#777d88",
              "--color-component-badge-count-inverted": "rgba(255, 255, 255, 0.7)",
              "--color-console-error-badge-text": "#ffffff",
              "--color-console-error-background": "#fff0f0",
              "--color-console-error-border": "#ffd6d6",
              "--color-console-error-icon": "#eb3941",
              "--color-console-error-text": "#fe2e31",
              "--color-console-warning-badge-text": "#000000",
              "--color-console-warning-background": "#fffbe5",
              "--color-console-warning-border": "#fff5c1",
              "--color-console-warning-icon": "#f4bd00",
              "--color-console-warning-text": "#64460c",
              "--color-context-background": "rgba(0,0,0,.9)",
              "--color-context-background-hover": "rgba(255, 255, 255, 0.1)",
              "--color-context-background-selected": "#178fb9",
              "--color-context-border": "#3d424a",
              "--color-context-text": "#ffffff",
              "--color-context-text-selected": "#ffffff",
              "--color-dim": "#777d88",
              "--color-dimmer": "#cfd1d5",
              "--color-dimmest": "#eff0f1",
              "--color-error-background": "hsl(0, 100%, 97%)",
              "--color-error-border": "hsl(0, 100%, 92%)",
              "--color-error-text": "#ff0000",
              "--color-expand-collapse-toggle": "#777d88",
              "--color-forget-badge-background": "#2683e2",
              "--color-forget-badge-background-inverted": "#1a6bbc",
              "--color-forget-text": "#fff",
              "--color-link": "#0000ff",
              "--color-modal-background": "rgba(255, 255, 255, 0.75)",
              "--color-bridge-version-npm-background": "#eff0f1",
              "--color-bridge-version-npm-text": "#000000",
              "--color-bridge-version-number": "#0088fa",
              "--color-primitive-hook-badge-background": "#e5e5e5",
              "--color-primitive-hook-badge-text": "#5f6673",
              "--color-record-active": "#fc3a4b",
              "--color-record-hover": "#3578e5",
              "--color-record-inactive": "#0088fa",
              "--color-resize-bar": "#eeeeee",
              "--color-resize-bar-active": "#dcdcdc",
              "--color-resize-bar-border": "#d1d1d1",
              "--color-resize-bar-dot": "#333333",
              "--color-timeline-internal-module": "#d1d1d1",
              "--color-timeline-internal-module-hover": "#c9c9c9",
              "--color-timeline-internal-module-text": "#444",
              "--color-timeline-native-event": "#ccc",
              "--color-timeline-native-event-hover": "#aaa",
              "--color-timeline-network-primary": "#fcf3dc",
              "--color-timeline-network-primary-hover": "#f0e7d1",
              "--color-timeline-network-secondary": "#efc457",
              "--color-timeline-network-secondary-hover": "#e3ba52",
              "--color-timeline-priority-background": "#f6f6f6",
              "--color-timeline-priority-border": "#eeeeee",
              "--color-timeline-user-timing": "#c9cacd",
              "--color-timeline-user-timing-hover": "#93959a",
              "--color-timeline-react-idle": "#d3e5f6",
              "--color-timeline-react-idle-hover": "#c3d9ef",
              "--color-timeline-react-render": "#9fc3f3",
              "--color-timeline-react-render-hover": "#83afe9",
              "--color-timeline-react-render-text": "#11365e",
              "--color-timeline-react-commit": "#c88ff0",
              "--color-timeline-react-commit-hover": "#b281d6",
              "--color-timeline-react-commit-text": "#3e2c4a",
              "--color-timeline-react-layout-effects": "#b281d6",
              "--color-timeline-react-layout-effects-hover": "#9d71bd",
              "--color-timeline-react-layout-effects-text": "#3e2c4a",
              "--color-timeline-react-passive-effects": "#b281d6",
              "--color-timeline-react-passive-effects-hover": "#9d71bd",
              "--color-timeline-react-passive-effects-text": "#3e2c4a",
              "--color-timeline-react-schedule": "#9fc3f3",
              "--color-timeline-react-schedule-hover": "#2683E2",
              "--color-timeline-react-suspense-rejected": "#f1cc14",
              "--color-timeline-react-suspense-rejected-hover": "#ffdf37",
              "--color-timeline-react-suspense-resolved": "#a6e59f",
              "--color-timeline-react-suspense-resolved-hover": "#89d281",
              "--color-timeline-react-suspense-unresolved": "#c9cacd",
              "--color-timeline-react-suspense-unresolved-hover": "#93959a",
              "--color-timeline-thrown-error": "#ee1638",
              "--color-timeline-thrown-error-hover": "#da1030",
              "--color-timeline-text-color": "#000000",
              "--color-timeline-text-dim-color": "#ccc",
              "--color-timeline-react-work-border": "#eeeeee",
              "--color-search-match": "yellow",
              "--color-search-match-current": "#f7923b",
              "--color-selected-tree-highlight-active": "rgba(0, 136, 250, 0.1)",
              "--color-selected-tree-highlight-inactive": "rgba(0, 0, 0, 0.05)",
              "--color-scroll-caret": "rgba(150, 150, 150, 0.5)",
              "--color-tab-selected-border": "#0088fa",
              "--color-text": "#000000",
              "--color-text-invalid": "#ff0000",
              "--color-text-selected": "#ffffff",
              "--color-toggle-background-invalid": "#fc3a4b",
              "--color-toggle-background-on": "#0088fa",
              "--color-toggle-background-off": "#cfd1d5",
              "--color-toggle-text": "#ffffff",
              "--color-warning-background": "#fb3655",
              "--color-warning-background-hover": "#f82042",
              "--color-warning-text-color": "#ffffff",
              "--color-warning-text-color-inverted": "#fd4d69",
              "--color-scroll-thumb": "#c2c2c2",
              "--color-scroll-track": "#fafafa",
              "--color-tooltip-background": "rgba(0, 0, 0, 0.9)",
              "--color-tooltip-text": "#ffffff"
            },
            dark: {
              "--color-attribute-name": "#9d87d2",
              "--color-attribute-name-not-editable": "#ededed",
              "--color-attribute-name-inverted": "#282828",
              "--color-attribute-value": "#cedae0",
              "--color-attribute-value-inverted": "#ffffff",
              "--color-attribute-editable-value": "yellow",
              "--color-background": "#282c34",
              "--color-background-hover": "rgba(255, 255, 255, 0.1)",
              "--color-background-inactive": "#3d424a",
              "--color-background-invalid": "#5c0000",
              "--color-background-selected": "#178fb9",
              "--color-button-background": "#282c34",
              "--color-button-background-focus": "#3d424a",
              "--color-button": "#afb3b9",
              "--color-button-active": "#61dafb",
              "--color-button-disabled": "#4f5766",
              "--color-button-focus": "#a2e9fc",
              "--color-button-hover": "#ededed",
              "--color-border": "#3d424a",
              "--color-commit-did-not-render-fill": "#777d88",
              "--color-commit-did-not-render-fill-text": "#000000",
              "--color-commit-did-not-render-pattern": "#666c77",
              "--color-commit-did-not-render-pattern-text": "#ffffff",
              "--color-commit-gradient-0": "#37afa9",
              "--color-commit-gradient-1": "#63b19e",
              "--color-commit-gradient-2": "#80b393",
              "--color-commit-gradient-3": "#97b488",
              "--color-commit-gradient-4": "#abb67d",
              "--color-commit-gradient-5": "#beb771",
              "--color-commit-gradient-6": "#cfb965",
              "--color-commit-gradient-7": "#dfba57",
              "--color-commit-gradient-8": "#efbb49",
              "--color-commit-gradient-9": "#febc38",
              "--color-commit-gradient-text": "#000000",
              "--color-component-name": "#61dafb",
              "--color-component-name-inverted": "#282828",
              "--color-component-badge-background": "#5e6167",
              "--color-component-badge-background-inverted": "#46494e",
              "--color-component-badge-count": "#8f949d",
              "--color-component-badge-count-inverted": "rgba(255, 255, 255, 0.85)",
              "--color-console-error-badge-text": "#000000",
              "--color-console-error-background": "#290000",
              "--color-console-error-border": "#5c0000",
              "--color-console-error-icon": "#eb3941",
              "--color-console-error-text": "#fc7f7f",
              "--color-console-warning-badge-text": "#000000",
              "--color-console-warning-background": "#332b00",
              "--color-console-warning-border": "#665500",
              "--color-console-warning-icon": "#f4bd00",
              "--color-console-warning-text": "#f5f2ed",
              "--color-context-background": "rgba(255,255,255,.95)",
              "--color-context-background-hover": "rgba(0, 136, 250, 0.1)",
              "--color-context-background-selected": "#0088fa",
              "--color-context-border": "#eeeeee",
              "--color-context-text": "#000000",
              "--color-context-text-selected": "#ffffff",
              "--color-dim": "#8f949d",
              "--color-dimmer": "#777d88",
              "--color-dimmest": "#4f5766",
              "--color-error-background": "#200",
              "--color-error-border": "#900",
              "--color-error-text": "#f55",
              "--color-expand-collapse-toggle": "#8f949d",
              "--color-forget-badge-background": "#2683e2",
              "--color-forget-badge-background-inverted": "#1a6bbc",
              "--color-forget-text": "#fff",
              "--color-link": "#61dafb",
              "--color-modal-background": "rgba(0, 0, 0, 0.75)",
              "--color-bridge-version-npm-background": "rgba(0, 0, 0, 0.25)",
              "--color-bridge-version-npm-text": "#ffffff",
              "--color-bridge-version-number": "yellow",
              "--color-primitive-hook-badge-background": "rgba(0, 0, 0, 0.25)",
              "--color-primitive-hook-badge-text": "rgba(255, 255, 255, 0.7)",
              "--color-record-active": "#fc3a4b",
              "--color-record-hover": "#a2e9fc",
              "--color-record-inactive": "#61dafb",
              "--color-resize-bar": "#282c34",
              "--color-resize-bar-active": "#31363f",
              "--color-resize-bar-border": "#3d424a",
              "--color-resize-bar-dot": "#cfd1d5",
              "--color-timeline-internal-module": "#303542",
              "--color-timeline-internal-module-hover": "#363b4a",
              "--color-timeline-internal-module-text": "#7f8899",
              "--color-timeline-native-event": "#b2b2b2",
              "--color-timeline-native-event-hover": "#949494",
              "--color-timeline-network-primary": "#fcf3dc",
              "--color-timeline-network-primary-hover": "#e3dbc5",
              "--color-timeline-network-secondary": "#efc457",
              "--color-timeline-network-secondary-hover": "#d6af4d",
              "--color-timeline-priority-background": "#1d2129",
              "--color-timeline-priority-border": "#282c34",
              "--color-timeline-user-timing": "#c9cacd",
              "--color-timeline-user-timing-hover": "#93959a",
              "--color-timeline-react-idle": "#3d485b",
              "--color-timeline-react-idle-hover": "#465269",
              "--color-timeline-react-render": "#2683E2",
              "--color-timeline-react-render-hover": "#1a76d4",
              "--color-timeline-react-render-text": "#11365e",
              "--color-timeline-react-commit": "#731fad",
              "--color-timeline-react-commit-hover": "#611b94",
              "--color-timeline-react-commit-text": "#e5c1ff",
              "--color-timeline-react-layout-effects": "#611b94",
              "--color-timeline-react-layout-effects-hover": "#51167a",
              "--color-timeline-react-layout-effects-text": "#e5c1ff",
              "--color-timeline-react-passive-effects": "#611b94",
              "--color-timeline-react-passive-effects-hover": "#51167a",
              "--color-timeline-react-passive-effects-text": "#e5c1ff",
              "--color-timeline-react-schedule": "#2683E2",
              "--color-timeline-react-schedule-hover": "#1a76d4",
              "--color-timeline-react-suspense-rejected": "#f1cc14",
              "--color-timeline-react-suspense-rejected-hover": "#e4c00f",
              "--color-timeline-react-suspense-resolved": "#a6e59f",
              "--color-timeline-react-suspense-resolved-hover": "#89d281",
              "--color-timeline-react-suspense-unresolved": "#c9cacd",
              "--color-timeline-react-suspense-unresolved-hover": "#93959a",
              "--color-timeline-thrown-error": "#fb3655",
              "--color-timeline-thrown-error-hover": "#f82042",
              "--color-timeline-text-color": "#282c34",
              "--color-timeline-text-dim-color": "#555b66",
              "--color-timeline-react-work-border": "#3d424a",
              "--color-search-match": "yellow",
              "--color-search-match-current": "#f7923b",
              "--color-selected-tree-highlight-active": "rgba(23, 143, 185, 0.15)",
              "--color-selected-tree-highlight-inactive": "rgba(255, 255, 255, 0.05)",
              "--color-scroll-caret": "#4f5766",
              "--color-shadow": "rgba(0, 0, 0, 0.5)",
              "--color-tab-selected-border": "#178fb9",
              "--color-text": "#ffffff",
              "--color-text-invalid": "#ff8080",
              "--color-text-selected": "#ffffff",
              "--color-toggle-background-invalid": "#fc3a4b",
              "--color-toggle-background-on": "#178fb9",
              "--color-toggle-background-off": "#777d88",
              "--color-toggle-text": "#ffffff",
              "--color-warning-background": "#ee1638",
              "--color-warning-background-hover": "#da1030",
              "--color-warning-text-color": "#ffffff",
              "--color-warning-text-color-inverted": "#ee1638",
              "--color-scroll-thumb": "#afb3b9",
              "--color-scroll-track": "#313640",
              "--color-tooltip-background": "rgba(255, 255, 255, 0.95)",
              "--color-tooltip-text": "#000000"
            },
            compact: {
              "--font-size-monospace-small": "9px",
              "--font-size-monospace-normal": "11px",
              "--font-size-monospace-large": "15px",
              "--font-size-sans-small": "10px",
              "--font-size-sans-normal": "12px",
              "--font-size-sans-large": "14px",
              "--line-height-data": "18px"
            },
            comfortable: {
              "--font-size-monospace-small": "10px",
              "--font-size-monospace-normal": "13px",
              "--font-size-monospace-large": "17px",
              "--font-size-sans-small": "12px",
              "--font-size-sans-normal": "14px",
              "--font-size-sans-large": "16px",
              "--line-height-data": "22px"
            }
          },
          ZI = parseInt(EH.comfortable["--line-height-data"], 10),
          mT = parseInt(EH.compact["--line-height-data"], 10),
          qq = 31,
          JY = 1,
          tE = 60;

        function bV(M, f) {
          var b = Object.keys(M);
          if (Object.getOwnPropertySymbols) {
            var p = Object.getOwnPropertySymbols(M);
            if (f) p = p.filter(function(c) {
              return Object.getOwnPropertyDescriptor(M, c).enumerable
            });
            b.push.apply(b, p)
          }
          return b
        }

        function HQ(M) {
          for (var f = 1; f < arguments.length; f++) {
            var b = arguments[f] != null ? arguments[f] : {};
            if (f % 2) bV(Object(b), !0).forEach(function(p) {
              FY(M, p, b[p])
            });
            else if (Object.getOwnPropertyDescriptors) Object.defineProperties(M, Object.getOwnPropertyDescriptors(b));
            else bV(Object(b)).forEach(function(p) {
              Object.defineProperty(M, p, Object.getOwnPropertyDescriptor(b, p))
            })
          }
          return M
        }

        function FY(M, f, b) {
          if (f in M) Object.defineProperty(M, f, {
            value: b,
            enumerable: !0,
            configurable: !0,
            writable: !0
          });
          else M[f] = b;
          return M
        }
        var qF = 0,
          VD, V4, UH, Mq, pW, NH, zQ;

        function cW() {}
        cW.__reactDisabledLog = !0;

        function x8() {
          if (qF === 0) {
            VD = console.log, V4 = console.info, UH = console.warn, Mq = console.error, pW = console.group, NH = console.groupCollapsed, zQ = console.groupEnd;
            var M = {
              configurable: !0,
              enumerable: !0,
              value: cW,
              writable: !0
            };
            Object.defineProperties(console, {
              info: M,
              log: M,
              warn: M,
              error: M,
              group: M,
              groupCollapsed: M,
              groupEnd: M
            })
          }
          qF++
        }

        function DI() {
          if (qF--, qF === 0) {
            var M = {
              configurable: !0,
              enumerable: !0,
              writable: !0
            };
            Object.defineProperties(console, {
              log: HQ(HQ({}, M), {}, {
                value: VD
              }),
              info: HQ(HQ({}, M), {}, {
                value: V4
              }),
              warn: HQ(HQ({}, M), {}, {
                value: UH
              }),
              error: HQ(HQ({}, M), {}, {
                value: Mq
              }),
              group: HQ(HQ({}, M), {}, {
                value: pW
              }),
              groupCollapsed: HQ(HQ({}, M), {}, {
                value: NH
              }),
              groupEnd: HQ(HQ({}, M), {}, {
                value: zQ
              })
            })
          }
          if (qF < 0) console.error("disabledDepth fell below zero. This is a bug in React. Please file an issue.")
        }

        function eE(M, f) {
          return lW(M) || mB(M, f) || Lq(M, f) || AU()
        }

        function AU() {
          throw new TypeError(`Invalid attempt to destructure non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
        }

        function Lq(M, f) {
          if (!M) return;
          if (typeof M === "string") return dT(M, f);
          var b = Object.prototype.toString.call(M).slice(8, -1);
          if (b === "Object" && M.constructor) b = M.constructor.name;
          if (b === "Map" || b === "Set") return Array.from(M);
          if (b === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(b)) return dT(M, f)
        }

        function dT(M, f) {
          if (f == null || f > M.length) f = M.length;
          for (var b = 0, p = new Array(f); b < f; b++) p[b] = M[b];
          return p
        }

        function mB(M, f) {
          if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(M))) return;
          var b = [],
            p = !0,
            c = !1,
            q1 = void 0;
          try {
            for (var m1 = M[Symbol.iterator](), l1; !(p = (l1 = m1.next()).done); p = !0)
              if (b.push(l1.value), f && b.length === f) break
          } catch ($1) {
            c = !0, q1 = $1
          } finally {
            try {
              if (!p && m1.return != null) m1.return()
            } finally {
              if (c) throw q1
            }
          }
          return b
        }

        function lW(M) {
          if (Array.isArray(M)) return M
        }

        function gV(M) {
          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") gV = function f(b) {
            return typeof b
          };
          else gV = function f(b) {
            return b && typeof Symbol === "function" && b.constructor === Symbol && b !== Symbol.prototype ? "symbol" : typeof b
          };
          return gV(M)
        }
        var $H;

        function P7(M) {
          if ($H === void 0) try {
            throw Error()
          } catch (p) {
            var f = p.stack.trim().match(/\n( *(at )?)/);
            $H = f && f[1] || ""
          }
          var b = "";
          return b = " (<anonymous>)", `
` + $H + M + b
        }

        function uT(M, f) {
          return P7(M + (f ? " [" + f + "]" : ""))
        }
        var qH = !1,
          pT;
        if (!1) var BU;

        function Rq(M, f, b) {
          if (!M || qH) return "";
          if (!1) var p;
          var c = Error.prepareStackTrace;
          Error.prepareStackTrace = void 0, qH = !0;
          var q1 = b.H;
          b.H = null, x8();
          var m1 = {
            DetermineComponentFrameRoot: function E6() {
              var D2;
              try {
                if (f) {
                  var m4 = function H4() {
                    throw Error()
                  };
                  if (Object.defineProperty(m4.prototype, "props", {
                      set: function H4() {
                        throw Error()
                      }
                    }), (typeof Reflect === "undefined" ? "undefined" : gV(Reflect)) === "object" && Reflect.construct) {
                    try {
                      Reflect.construct(m4, [])
                    } catch (H4) {
                      D2 = H4
                    }
                    Reflect.construct(M, [], m4)
                  } else {
                    try {
                      m4.call()
                    } catch (H4) {
                      D2 = H4
                    }
                    M.call(m4.prototype)
                  }
                } else {
                  try {
                    throw Error()
                  } catch (H4) {
                    D2 = H4
                  }
                  var U6 = M();
                  if (U6 && typeof U6.catch === "function") U6.catch(function() {})
                }
              } catch (H4) {
                if (H4 && D2 && typeof H4.stack === "string") return [H4.stack, D2.stack]
              }
              return [null, null]
            }
          };
          m1.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot";
          var l1 = Object.getOwnPropertyDescriptor(m1.DetermineComponentFrameRoot, "name");
          if (l1 && l1.configurable) Object.defineProperty(m1.DetermineComponentFrameRoot, "name", {
            value: "DetermineComponentFrameRoot"
          });
          try {
            var $1 = m1.DetermineComponentFrameRoot(),
              s1 = eE($1, 2),
              XA = s1[0],
              jA = s1[1];
            if (XA && jA) {
              var wA = XA.split(`
`),
                pA = jA.split(`
`),
                W0 = 0,
                E2 = 0;
              while (W0 < wA.length && !wA[W0].includes("DetermineComponentFrameRoot")) W0++;
              while (E2 < pA.length && !pA[E2].includes("DetermineComponentFrameRoot")) E2++;
              if (W0 === wA.length || E2 === pA.length) {
                W0 = wA.length - 1, E2 = pA.length - 1;
                while (W0 >= 1 && E2 >= 0 && wA[W0] !== pA[E2]) E2--
              }
              for (; W0 >= 1 && E2 >= 0; W0--, E2--)
                if (wA[W0] !== pA[E2]) {
                  if (W0 !== 1 || E2 !== 1)
                    do
                      if (W0--, E2--, E2 < 0 || wA[W0] !== pA[E2]) {
                        var N0 = `
` + wA[W0].replace(" at new ", " at ");
                        if (M.displayName && N0.includes("<anonymous>")) N0 = N0.replace("<anonymous>", M.displayName);
                        return N0
                      } while (W0 >= 1 && E2 >= 0);
                  break
                }
            }
          } finally {
            qH = !1, Error.prepareStackTrace = c, b.H = q1, DI()
          }
          var m2 = M ? M.displayName || M.name : "",
            K4 = m2 ? P7(m2) : "";
          return K4
        }

        function MF(M, f) {
          return Rq(M, !0, f)
        }

        function cT(M, f) {
          return Rq(M, !1, f)
        }

        function XY(M, f, b) {
          var {
            HostHoistable: p,
            HostSingleton: c,
            HostComponent: q1,
            LazyComponent: m1,
            SuspenseComponent: l1,
            SuspenseListComponent: $1,
            FunctionComponent: s1,
            IndeterminateComponent: XA,
            SimpleMemoComponent: jA,
            ForwardRef: wA,
            ClassComponent: pA
          } = M;
          switch (f.tag) {
            case p:
            case c:
            case q1:
              return P7(f.type);
            case m1:
              return P7("Lazy");
            case l1:
              return P7("Suspense");
            case $1:
              return P7("SuspenseList");
            case s1:
            case XA:
            case jA:
              return cT(f.type, b);
            case wA:
              return cT(f.type.render, b);
            case pA:
              return MF(f.type, b);
            default:
              return ""
          }
        }

        function iW(M, f, b) {
          try {
            var p = "",
              c = f;
            do {
              p += XY(M, c, b);
              var q1 = c._debugInfo;
              if (q1)
                for (var m1 = q1.length - 1; m1 >= 0; m1--) {
                  var l1 = q1[m1];
                  if (typeof l1.name === "string") p += uT(l1.name, l1.env)
                }
              c = c.return
            } while (c);
            return p
          } catch ($1) {
            return `
Error generating stack: ` + $1.message + `
` + $1.stack
          }
        }

        function Dk(M) {
          return !!M._debugTask
        }

        function VY(M, f) {
          return Jk(M) || lT(M, f) || w8(M, f) || Yk()
        }

        function Yk() {
          throw new TypeError(`Invalid attempt to destructure non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
        }

        function w8(M, f) {
          if (!M) return;
          if (typeof M === "string") return Wk(M, f);
          var b = Object.prototype.toString.call(M).slice(8, -1);
          if (b === "Object" && M.constructor) b = M.constructor.name;
          if (b === "Map" || b === "Set") return Array.from(M);
          if (b === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(b)) return Wk(M, f)
        }

        function Wk(M, f) {
          if (f == null || f > M.length) f = M.length;
          for (var b = 0, p = new Array(f); b < f; b++) p[b] = M[b];
          return p
        }

        function lT(M, f) {
          if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(M))) return;
          var b = [],
            p = !0,
            c = !1,
            q1 = void 0;
          try {
            for (var m1 = M[Symbol.iterator](), l1; !(p = (l1 = m1.next()).done); p = !0)
              if (b.push(l1.value), f && b.length === f) break
          } catch ($1) {
            c = !0, q1 = $1
          } finally {
            try {
              if (!p && m1.return != null) m1.return()
            } finally {
              if (c) throw q1
            }
          }
          return b
        }

        function Jk(M) {
          if (Array.isArray(M)) return M
        }

        function QU(M) {
          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") QU = function f(b) {
            return typeof b
          };
          else QU = function f(b) {
            return b && typeof Symbol === "function" && b.constructor === Symbol && b !== Symbol.prototype ? "symbol" : typeof b
          };
          return QU(M)
        }
        var iT = 10,
          MH = null,
          S7 = typeof performance !== "undefined" && typeof performance.mark === "function" && typeof performance.clearMarks === "function",
          c2 = !1;
        if (S7) {
          var Oq = "__v3",
            Fk = {};
          Object.defineProperty(Fk, "startTime", {
            get: function M() {
              return c2 = !0, 0
            },
            set: function M() {}
          });
          try {
            performance.mark(Oq, Fk)
          } catch (M) {} finally {
            performance.clearMarks(Oq)
          }
        }
        if (c2) MH = performance;
        var CD = (typeof performance === "undefined" ? "undefined" : QU(performance)) === "object" && typeof performance.now === "function" ? function() {
          return performance.now()
        } : function() {
          return Date.now()
        };

        function LF(M) {
          MH = M, S7 = M !== null, c2 = M !== null
        }

        function RF(M) {
          var {
            getDisplayNameForFiber: f,
            getIsProfiling: b,
            getLaneLabelMap: p,
            workTagMap: c,
            currentDispatcherRef: q1,
            reactVersion: m1
          } = M, l1 = 0, $1 = null, s1 = [], XA = null, jA = new Map, wA = !1, pA = !1;

          function W0() {
            var a0 = CD();
            if (XA) {
              if (XA.startTime === 0) XA.startTime = a0 - iT;
              return a0 - XA.startTime
            }
            return 0
          }

          function E2() {
            if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.getInternalModuleRanges === "function") {
              var a0 = __REACT_DEVTOOLS_GLOBAL_HOOK__.getInternalModuleRanges();
              if (tI(a0)) return a0
            }
            return null
          }

          function N0() {
            return XA
          }

          function m2(a0) {
            var D9 = [],
              l4 = 1;
            for (var o6 = 0; o6 < qq; o6++) {
              if (l4 & a0) D9.push(l4);
              l4 *= 2
            }
            return D9
          }
          var K4 = typeof p === "function" ? p() : null;

          function E6() {
            D2("--react-version-".concat(m1)), D2("--profiler-version-".concat(JY));
            var a0 = E2();
            if (a0)
              for (var D9 = 0; D9 < a0.length; D9++) {
                var l4 = a0[D9];
                if (tI(l4) && l4.length === 2) {
                  var o6 = VY(a0[D9], 2),
                    uB = o6[0],
                    t6 = o6[1];
                  D2("--react-internal-module-start-".concat(uB)), D2("--react-internal-module-stop-".concat(t6))
                }
              }
            if (K4 != null) {
              var _7 = Array.from(K4.values()).join(",");
              D2("--react-lane-labels-".concat(_7))
            }
          }

          function D2(a0) {
            MH.mark(a0), MH.clearMarks(a0)
          }

          function m4(a0, D9) {
            var l4 = 0;
            if (s1.length > 0) {
              var o6 = s1[s1.length - 1];
              l4 = o6.type === "render-idle" ? o6.depth : o6.depth + 1
            }
            var uB = m2(D9),
              t6 = {
                type: a0,
                batchUID: l1,
                depth: l4,
                lanes: uB,
                timestamp: W0(),
                duration: 0
              };
            if (s1.push(t6), XA) {
              var _7 = XA,
                ZZ = _7.batchUIDToMeasuresMap,
                o8 = _7.laneToReactMeasureMap,
                j7 = ZZ.get(l1);
              if (j7 != null) j7.push(t6);
              else ZZ.set(l1, [t6]);
              uB.forEach(function(TH) {
                if (j7 = o8.get(TH), j7) j7.push(t6)
              })
            }
          }

          function U6(a0) {
            var D9 = W0();
            if (s1.length === 0) {
              console.error('Unexpected type "%s" completed at %sms while currentReactMeasuresStack is empty.', a0, D9);
              return
            }
            var l4 = s1.pop();
            if (l4.type !== a0) console.error('Unexpected type "%s" completed at %sms before "%s" completed.', a0, D9, l4.type);
            if (l4.duration = D9 - l4.timestamp, XA) XA.duration = W0() + iT
          }

          function H4(a0) {
            if (wA) m4("commit", a0), pA = !0;
            if (c2) D2("--commit-start-".concat(a0)), E6()
          }

          function a6() {
            if (wA) U6("commit"), U6("render-idle");
            if (c2) D2("--commit-stop")
          }

          function f5(a0) {
            if (wA || c2) {
              var D9 = f(a0) || "Unknown";
              if (wA) {
                if (wA) $1 = {
                  componentName: D9,
                  duration: 0,
                  timestamp: W0(),
                  type: "render",
                  warning: null
                }
              }
              if (c2) D2("--component-render-start-".concat(D9))
            }
          }

          function E8() {
            if (wA) {
              if ($1) {
                if (XA) XA.componentMeasures.push($1);
                $1.duration = W0() - $1.timestamp, $1 = null
              }
            }
            if (c2) D2("--component-render-stop")
          }

          function O4(a0) {
            if (wA || c2) {
              var D9 = f(a0) || "Unknown";
              if (wA) {
                if (wA) $1 = {
                  componentName: D9,
                  duration: 0,
                  timestamp: W0(),
                  type: "layout-effect-mount",
                  warning: null
                }
              }
              if (c2) D2("--component-layout-effect-mount-start-".concat(D9))
            }
          }

          function U5() {
            if (wA) {
              if ($1) {
                if (XA) XA.componentMeasures.push($1);
                $1.duration = W0() - $1.timestamp, $1 = null
              }
            }
            if (c2) D2("--component-layout-effect-mount-stop")
          }

          function aQ(a0) {
            if (wA || c2) {
              var D9 = f(a0) || "Unknown";
              if (wA) {
                if (wA) $1 = {
                  componentName: D9,
                  duration: 0,
                  timestamp: W0(),
                  type: "layout-effect-unmount",
                  warning: null
                }
              }
              if (c2) D2("--component-layout-effect-unmount-start-".concat(D9))
            }
          }

          function dB() {
            if (wA) {
              if ($1) {
                if (XA) XA.componentMeasures.push($1);
                $1.duration = W0() - $1.timestamp, $1 = null
              }
            }
            if (c2) D2("--component-layout-effect-unmount-stop")
          }

          function i5(a0) {
            if (wA || c2) {
              var D9 = f(a0) || "Unknown";
              if (wA) {
                if (wA) $1 = {
                  componentName: D9,
                  duration: 0,
                  timestamp: W0(),
                  type: "passive-effect-mount",
                  warning: null
                }
              }
              if (c2) D2("--component-passive-effect-mount-start-".concat(D9))
            }
          }

          function s6() {
            if (wA) {
              if ($1) {
                if (XA) XA.componentMeasures.push($1);
                $1.duration = W0() - $1.timestamp, $1 = null
              }
            }
            if (c2) D2("--component-passive-effect-mount-stop")
          }

          function T4(a0) {
            if (wA || c2) {
              var D9 = f(a0) || "Unknown";
              if (wA) {
                if (wA) $1 = {
                  componentName: D9,
                  duration: 0,
                  timestamp: W0(),
                  type: "passive-effect-unmount",
                  warning: null
                }
              }
              if (c2) D2("--component-passive-effect-unmount-start-".concat(D9))
            }
          }

          function sQ() {
            if (wA) {
              if ($1) {
                if (XA) XA.componentMeasures.push($1);
                $1.duration = W0() - $1.timestamp, $1 = null
              }
            }
            if (c2) D2("--component-passive-effect-unmount-stop")
          }

          function rQ(a0, D9, l4) {
            if (wA || c2) {
              var o6 = f(a0) || "Unknown",
                uB = a0.alternate === null ? "mount" : "update",
                t6 = "";
              if (D9 !== null && QU(D9) === "object" && typeof D9.message === "string") t6 = D9.message;
              else if (typeof D9 === "string") t6 = D9;
              if (wA) {
                if (XA) XA.thrownErrors.push({
                  componentName: o6,
                  message: t6,
                  phase: uB,
                  timestamp: W0(),
                  type: "thrown-error"
                })
              }
              if (c2) D2("--error-".concat(o6, "-").concat(uB, "-").concat(t6))
            }
          }
          var b0 = typeof WeakMap === "function" ? WeakMap : Map,
            O2 = new b0,
            n2 = 0;

          function e4(a0) {
            if (!O2.has(a0)) O2.set(a0, n2++);
            return O2.get(a0)
          }

          function g6(a0, D9, l4) {
            if (wA || c2) {
              var o6 = O2.has(D9) ? "resuspend" : "suspend",
                uB = e4(D9),
                t6 = f(a0) || "Unknown",
                _7 = a0.alternate === null ? "mount" : "update",
                ZZ = D9.displayName || "",
                o8 = null;
              if (wA) {
                if (o8 = {
                    componentName: t6,
                    depth: 0,
                    duration: 0,
                    id: "".concat(uB),
                    phase: _7,
                    promiseName: ZZ,
                    resolution: "unresolved",
                    timestamp: W0(),
                    type: "suspense",
                    warning: null
                  }, XA) XA.suspenseEvents.push(o8)
              }
              if (c2) D2("--suspense-".concat(o6, "-").concat(uB, "-").concat(t6, "-").concat(_7, "-").concat(l4, "-").concat(ZZ));
              D9.then(function() {
                if (o8) o8.duration = W0() - o8.timestamp, o8.resolution = "resolved";
                if (c2) D2("--suspense-resolved-".concat(uB, "-").concat(t6))
              }, function() {
                if (o8) o8.duration = W0() - o8.timestamp, o8.resolution = "rejected";
                if (c2) D2("--suspense-rejected-".concat(uB, "-").concat(t6))
              })
            }
          }

          function X5(a0) {
            if (wA) m4("layout-effects", a0);
            if (c2) D2("--layout-effects-start-".concat(a0))
          }

          function r6() {
            if (wA) U6("layout-effects");
            if (c2) D2("--layout-effects-stop")
          }

          function I8(a0) {
            if (wA) m4("passive-effects", a0);
            if (c2) D2("--passive-effects-start-".concat(a0))
          }

          function EQ() {
            if (wA) U6("passive-effects");
            if (c2) D2("--passive-effects-stop")
          }

          function oQ(a0) {
            if (wA) {
              if (pA) pA = !1, l1++;
              if (s1.length === 0 || s1[s1.length - 1].type !== "render-idle") m4("render-idle", a0);
              m4("render", a0)
            }
            if (c2) D2("--render-start-".concat(a0))
          }

          function _F() {
            if (wA) U6("render");
            if (c2) D2("--render-yield")
          }

          function jF() {
            if (wA) U6("render");
            if (c2) D2("--render-stop")
          }

          function yF(a0) {
            if (wA) {
              if (XA) XA.schedulingEvents.push({
                lanes: m2(a0),
                timestamp: W0(),
                type: "schedule-render",
                warning: null
              })
            }
            if (c2) D2("--schedule-render-".concat(a0))
          }

          function OH(a0, D9) {
            if (wA || c2) {
              var l4 = f(a0) || "Unknown";
              if (wA) {
                if (XA) XA.schedulingEvents.push({
                  componentName: l4,
                  lanes: m2(D9),
                  timestamp: W0(),
                  type: "schedule-force-update",
                  warning: null
                })
              }
              if (c2) D2("--schedule-forced-update-".concat(D9, "-").concat(l4))
            }
          }

          function HD(a0) {
            var D9 = [],
              l4 = a0;
            while (l4 !== null) D9.push(l4), l4 = l4.return;
            return D9
          }

          function kF(a0, D9) {
            if (wA || c2) {
              var l4 = f(a0) || "Unknown";
              if (wA) {
                if (XA) {
                  var o6 = {
                    componentName: l4,
                    lanes: m2(D9),
                    timestamp: W0(),
                    type: "schedule-state-update",
                    warning: null
                  };
                  jA.set(o6, HD(a0)), XA.schedulingEvents.push(o6)
                }
              }
              if (c2) D2("--schedule-state-update-".concat(D9, "-").concat(l4))
            }
          }

          function JG(a0) {
            if (wA !== a0)
              if (wA = a0, wA) {
                var D9 = new Map;
                if (c2) {
                  var l4 = E2();
                  if (l4)
                    for (var o6 = 0; o6 < l4.length; o6++) {
                      var uB = l4[o6];
                      if (tI(uB) && uB.length === 2) {
                        var t6 = VY(l4[o6], 2),
                          _7 = t6[0],
                          ZZ = t6[1];
                        D2("--react-internal-module-start-".concat(_7)), D2("--react-internal-module-stop-".concat(ZZ))
                      }
                    }
                }
                var o8 = new Map,
                  j7 = 1;
                for (var TH = 0; TH < qq; TH++) o8.set(j7, []), j7 *= 2;
                l1 = 0, $1 = null, s1 = [], jA = new Map, XA = {
                  internalModuleSourceToRanges: D9,
                  laneToLabelMap: K4 || new Map,
                  reactVersion: m1,
                  componentMeasures: [],
                  schedulingEvents: [],
                  suspenseEvents: [],
                  thrownErrors: [],
                  batchUIDToMeasuresMap: new Map,
                  duration: 0,
                  laneToReactMeasureMap: o8,
                  startTime: 0,
                  flamechart: [],
                  nativeEvents: [],
                  networkMeasures: [],
                  otherUserTimingMarks: [],
                  snapshots: [],
                  snapshotHeight: 0
                }, pA = !0
              } else {
                if (XA !== null) XA.schedulingEvents.forEach(function(PH) {
                  if (PH.type === "schedule-state-update") {
                    var I0 = jA.get(PH);
                    if (I0 && q1 != null) PH.componentStack = I0.reduce(function(G0, K0) {
                      return G0 + XY(c, K0, q1)
                    }, "")
                  }
                });
                jA.clear()
              }
          }
          return {
            getTimelineData: N0,
            profilingHooks: {
              markCommitStarted: H4,
              markCommitStopped: a6,
              markComponentRenderStarted: f5,
              markComponentRenderStopped: E8,
              markComponentPassiveEffectMountStarted: i5,
              markComponentPassiveEffectMountStopped: s6,
              markComponentPassiveEffectUnmountStarted: T4,
              markComponentPassiveEffectUnmountStopped: sQ,
              markComponentLayoutEffectMountStarted: O4,
              markComponentLayoutEffectMountStopped: U5,
              markComponentLayoutEffectUnmountStarted: aQ,
              markComponentLayoutEffectUnmountStopped: dB,
              markComponentErrored: rQ,
              markComponentSuspended: g6,
              markLayoutEffectsStarted: X5,
              markLayoutEffectsStopped: r6,
              markPassiveEffectsStarted: I8,
              markPassiveEffectsStopped: EQ,
              markRenderStarted: oQ,
              markRenderYielded: _F,
              markRenderStopped: jF,
              markRenderScheduled: yF,
              markForceUpdateScheduled: OH,
              markStateUpdateScheduled: kF
            },
            toggleProfilingStatus: JG
          }
        }

        function IU(M, f) {
          if (M == null) return {};
          var b = nT(M, f),
            p, c;
          if (Object.getOwnPropertySymbols) {
            var q1 = Object.getOwnPropertySymbols(M);
            for (c = 0; c < q1.length; c++) {
              if (p = q1[c], f.indexOf(p) >= 0) continue;
              if (!Object.prototype.propertyIsEnumerable.call(M, p)) continue;
              b[p] = M[p]
            }
          }
          return b
        }

        function nT(M, f) {
          if (M == null) return {};
          var b = {},
            p = Object.keys(M),
            c, q1;
          for (q1 = 0; q1 < p.length; q1++) {
            if (c = p[q1], f.indexOf(c) >= 0) continue;
            b[c] = M[c]
          }
          return b
        }

        function GU(M, f) {
          var b = Object.keys(M);
          if (Object.getOwnPropertySymbols) {
            var p = Object.getOwnPropertySymbols(M);
            if (f) p = p.filter(function(c) {
              return Object.getOwnPropertyDescriptor(M, c).enumerable
            });
            b.push.apply(b, p)
          }
          return b
        }

        function OF(M) {
          for (var f = 1; f < arguments.length; f++) {
            var b = arguments[f] != null ? arguments[f] : {};
            if (f % 2) GU(Object(b), !0).forEach(function(p) {
              LH(M, p, b[p])
            });
            else if (Object.getOwnPropertyDescriptors) Object.defineProperties(M, Object.getOwnPropertyDescriptors(b));
            else GU(Object(b)).forEach(function(p) {
              Object.defineProperty(M, p, Object.getOwnPropertyDescriptor(b, p))
            })
          }
          return M
        }

        function LH(M, f, b) {
          if (f in M) Object.defineProperty(M, f, {
            value: b,
            enumerable: !0,
            configurable: !0,
            writable: !0
          });
          else M[f] = b;
          return M
        }

        function aT(M, f) {
          return hV(M) || rT(M, f) || g(M, f) || sT()
        }

        function sT() {
          throw new TypeError(`Invalid attempt to destructure non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
        }

        function rT(M, f) {
          if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(M))) return;
          var b = [],
            p = !0,
            c = !1,
            q1 = void 0;
          try {
            for (var m1 = M[Symbol.iterator](), l1; !(p = (l1 = m1.next()).done); p = !0)
              if (b.push(l1.value), f && b.length === f) break
          } catch ($1) {
            c = !0, q1 = $1
          } finally {
            try {
              if (!p && m1.return != null) m1.return()
            } finally {
              if (c) throw q1
            }
          }
          return b
        }

        function hV(M) {
          if (Array.isArray(M)) return M
        }

        function Tq(M) {
          return U(M) || w(M) || g(M) || Pq()
        }

        function Pq() {
          throw new TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
        }

        function w(M) {
          if (typeof Symbol !== "undefined" && Symbol.iterator in Object(M)) return Array.from(M)
        }

        function U(M) {
          if (Array.isArray(M)) return m(M)
        }

        function S(M, f) {
          var b;
          if (typeof Symbol === "undefined" || M[Symbol.iterator] == null) {
            if (Array.isArray(M) || (b = g(M)) || f && M && typeof M.length === "number") {
              if (b) M = b;
              var p = 0,
                c = function $1() {};
              return {
                s: c,
                n: function $1() {
                  if (p >= M.length) return {
                    done: !0
                  };
                  return {
                    done: !1,
                    value: M[p++]
                  }
                },
                e: function $1(s1) {
                  throw s1
                },
                f: c
              }
            }
            throw new TypeError(`Invalid attempt to iterate non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
          }
          var q1 = !0,
            m1 = !1,
            l1;
          return {
            s: function $1() {
              b = M[Symbol.iterator]()
            },
            n: function $1() {
              var s1 = b.next();
              return q1 = s1.done, s1
            },
            e: function $1(s1) {
              m1 = !0, l1 = s1
            },
            f: function $1() {
              try {
                if (!q1 && b.return != null) b.return()
              } finally {
                if (m1) throw l1
              }
            }
          }
        }

        function g(M, f) {
          if (!M) return;
          if (typeof M === "string") return m(M, f);
          var b = Object.prototype.toString.call(M).slice(8, -1);
          if (b === "Object" && M.constructor) b = M.constructor.name;
          if (b === "Map" || b === "Set") return Array.from(M);
          if (b === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(b)) return m(M, f)
        }

        function m(M, f) {
          if (f == null || f > M.length) f = M.length;
          for (var b = 0, p = new Array(f); b < f; b++) p[b] = M[b];
          return p
        }

        function r(M) {
          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") r = function f(b) {
            return typeof b
          };
          else r = function f(b) {
            return b && typeof Symbol === "function" && b.constructor === Symbol && b !== Symbol.prototype ? "symbol" : typeof b
          };
          return r(M)
        }

        function j1(M) {
          if (M.currentDispatcherRef === void 0) return;
          var f = M.currentDispatcherRef;
          if (typeof f.H === "undefined" && typeof f.current !== "undefined") return {
            get H() {
              return f.current
            },
            set H(b) {
              f.current = b
            }
          };
          return f
        }

        function CA(M) {
          return M.flags !== void 0 ? M.flags : M.effectTag
        }
        var kA = (typeof performance === "undefined" ? "undefined" : r(performance)) === "object" && typeof performance.now === "function" ? function() {
          return performance.now()
        } : function() {
          return Date.now()
        };

        function F0(M) {
          var f = {
            ImmediatePriority: 99,
            UserBlockingPriority: 98,
            NormalPriority: 97,
            LowPriority: 96,
            IdlePriority: 95,
            NoPriority: 90
          };
          if (XQ(M, "17.0.2")) f = {
            ImmediatePriority: 1,
            UserBlockingPriority: 2,
            NormalPriority: 3,
            LowPriority: 4,
            IdlePriority: 5,
            NoPriority: 0
          };
          var b = 0;
          if (wF(M, "18.0.0-alpha")) b = 24;
          else if (wF(M, "16.9.0")) b = 1;
          else if (wF(M, "16.3.0")) b = 2;
          var p = null;
          if (XQ(M, "17.0.1")) p = {
            CacheComponent: 24,
            ClassComponent: 1,
            ContextConsumer: 9,
            ContextProvider: 10,
            CoroutineComponent: -1,
            CoroutineHandlerPhase: -1,
            DehydratedSuspenseComponent: 18,
            ForwardRef: 11,
            Fragment: 7,
            FunctionComponent: 0,
            HostComponent: 5,
            HostPortal: 4,
            HostRoot: 3,
            HostHoistable: 26,
            HostSingleton: 27,
            HostText: 6,
            IncompleteClassComponent: 17,
            IncompleteFunctionComponent: 28,
            IndeterminateComponent: 2,
            LazyComponent: 16,
            LegacyHiddenComponent: 23,
            MemoComponent: 14,
            Mode: 8,
            OffscreenComponent: 22,
            Profiler: 12,
            ScopeComponent: 21,
            SimpleMemoComponent: 15,
            SuspenseComponent: 13,
            SuspenseListComponent: 19,
            TracingMarkerComponent: 25,
            YieldComponent: -1,
            Throw: 29
          };
          else if (wF(M, "17.0.0-alpha")) p = {
            CacheComponent: -1,
            ClassComponent: 1,
            ContextConsumer: 9,
            ContextProvider: 10,
            CoroutineComponent: -1,
            CoroutineHandlerPhase: -1,
            DehydratedSuspenseComponent: 18,
            ForwardRef: 11,
            Fragment: 7,
            FunctionComponent: 0,
            HostComponent: 5,
            HostPortal: 4,
            HostRoot: 3,
            HostHoistable: -1,
            HostSingleton: -1,
            HostText: 6,
            IncompleteClassComponent: 17,
            IncompleteFunctionComponent: -1,
            IndeterminateComponent: 2,
            LazyComponent: 16,
            LegacyHiddenComponent: 24,
            MemoComponent: 14,
            Mode: 8,
            OffscreenComponent: 23,
            Profiler: 12,
            ScopeComponent: 21,
            SimpleMemoComponent: 15,
            SuspenseComponent: 13,
            SuspenseListComponent: 19,
            TracingMarkerComponent: -1,
            YieldComponent: -1,
            Throw: -1
          };
          else if (wF(M, "16.6.0-beta.0")) p = {
            CacheComponent: -1,
            ClassComponent: 1,
            ContextConsumer: 9,
            ContextProvider: 10,
            CoroutineComponent: -1,
            CoroutineHandlerPhase: -1,
            DehydratedSuspenseComponent: 18,
            ForwardRef: 11,
            Fragment: 7,
            FunctionComponent: 0,
            HostComponent: 5,
            HostPortal: 4,
            HostRoot: 3,
            HostHoistable: -1,
            HostSingleton: -1,
            HostText: 6,
            IncompleteClassComponent: 17,
            IncompleteFunctionComponent: -1,
            IndeterminateComponent: 2,
            LazyComponent: 16,
            LegacyHiddenComponent: -1,
            MemoComponent: 14,
            Mode: 8,
            OffscreenComponent: -1,
            Profiler: 12,
            ScopeComponent: -1,
            SimpleMemoComponent: 15,
            SuspenseComponent: 13,
            SuspenseListComponent: 19,
            TracingMarkerComponent: -1,
            YieldComponent: -1,
            Throw: -1
          };
          else if (wF(M, "16.4.3-alpha")) p = {
            CacheComponent: -1,
            ClassComponent: 2,
            ContextConsumer: 11,
            ContextProvider: 12,
            CoroutineComponent: -1,
            CoroutineHandlerPhase: -1,
            DehydratedSuspenseComponent: -1,
            ForwardRef: 13,
            Fragment: 9,
            FunctionComponent: 0,
            HostComponent: 7,
            HostPortal: 6,
            HostRoot: 5,
            HostHoistable: -1,
            HostSingleton: -1,
            HostText: 8,
            IncompleteClassComponent: -1,
            IncompleteFunctionComponent: -1,
            IndeterminateComponent: 4,
            LazyComponent: -1,
            LegacyHiddenComponent: -1,
            MemoComponent: -1,
            Mode: 10,
            OffscreenComponent: -1,
            Profiler: 15,
            ScopeComponent: -1,
            SimpleMemoComponent: -1,
            SuspenseComponent: 16,
            SuspenseListComponent: -1,
            TracingMarkerComponent: -1,
            YieldComponent: -1,
            Throw: -1
          };
          else p = {
            CacheComponent: -1,
            ClassComponent: 2,
            ContextConsumer: 12,
            ContextProvider: 13,
            CoroutineComponent: 7,
            CoroutineHandlerPhase: 8,
            DehydratedSuspenseComponent: -1,
            ForwardRef: 14,
            Fragment: 10,
            FunctionComponent: 1,
            HostComponent: 5,
            HostPortal: 4,
            HostRoot: 3,
            HostHoistable: -1,
            HostSingleton: -1,
            HostText: 6,
            IncompleteClassComponent: -1,
            IncompleteFunctionComponent: -1,
            IndeterminateComponent: 0,
            LazyComponent: -1,
            LegacyHiddenComponent: -1,
            MemoComponent: -1,
            Mode: 11,
            OffscreenComponent: -1,
            Profiler: 15,
            ScopeComponent: -1,
            SimpleMemoComponent: -1,
            SuspenseComponent: 16,
            SuspenseListComponent: -1,
            TracingMarkerComponent: -1,
            YieldComponent: 9,
            Throw: -1
          };

          function c(T4) {
            var sQ = r(T4) === "object" && T4 !== null ? T4.$$typeof : T4;
            return r(sQ) === "symbol" ? sQ.toString() : sQ
          }
          var q1 = p,
            m1 = q1.CacheComponent,
            l1 = q1.ClassComponent,
            $1 = q1.IncompleteClassComponent,
            s1 = q1.IncompleteFunctionComponent,
            XA = q1.FunctionComponent,
            jA = q1.IndeterminateComponent,
            wA = q1.ForwardRef,
            pA = q1.HostRoot,
            W0 = q1.HostHoistable,
            E2 = q1.HostSingleton,
            N0 = q1.HostComponent,
            m2 = q1.HostPortal,
            K4 = q1.HostText,
            E6 = q1.Fragment,
            D2 = q1.LazyComponent,
            m4 = q1.LegacyHiddenComponent,
            U6 = q1.MemoComponent,
            H4 = q1.OffscreenComponent,
            a6 = q1.Profiler,
            f5 = q1.ScopeComponent,
            E8 = q1.SimpleMemoComponent,
            O4 = q1.SuspenseComponent,
            U5 = q1.SuspenseListComponent,
            aQ = q1.TracingMarkerComponent,
            dB = q1.Throw;

          function i5(T4) {
            var sQ = c(T4);
            switch (sQ) {
              case f3:
              case ZG:
                return i5(T4.type);
              case YY:
              case wq:
                return T4.render;
              default:
                return T4
            }
          }

          function s6(T4) {
            var sQ, rQ, b0, O2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1,
              n2 = T4.elementType,
              e4 = T4.type,
              g6 = T4.tag,
              X5 = e4;
            if (r(e4) === "object" && e4 !== null) X5 = i5(e4);
            var r6 = null;
            if (!O2 && (((sQ = T4.updateQueue) === null || sQ === void 0 ? void 0 : sQ.memoCache) != null || ((rQ = T4.memoizedState) === null || rQ === void 0 ? void 0 : (b0 = rQ.memoizedState) === null || b0 === void 0 ? void 0 : b0[Zk]))) {
              var I8 = s6(T4, !0);
              if (I8 == null) return null;
              return "Forget(".concat(I8, ")")
            }
            switch (g6) {
              case m1:
                return "Cache";
              case l1:
              case $1:
              case s1:
              case XA:
              case jA:
                return F5(X5);
              case wA:
                return k3(n2, X5, "ForwardRef", "Anonymous");
              case pA:
                var EQ = T4.stateNode;
                if (EQ != null && EQ._debugRootType !== null) return EQ._debugRootType;
                return null;
              case N0:
              case E2:
              case W0:
                return e4;
              case m2:
              case K4:
                return null;
              case E6:
                return "Fragment";
              case D2:
                return "Lazy";
              case U6:
              case E8:
                return k3(n2, X5, "Memo", "Anonymous");
              case O4:
                return "Suspense";
              case m4:
                return "LegacyHidden";
              case H4:
                return "Offscreen";
              case f5:
                return "Scope";
              case U5:
                return "SuspenseList";
              case a6:
                return "Profiler";
              case aQ:
                return "TracingMarker";
              case dB:
                return "Error";
              default:
                var oQ = c(e4);
                switch (oQ) {
                  case $2:
                  case dW:
                  case IG:
                    return null;
                  case WY:
                  case aE:
                    return r6 = T4.type._context || T4.type.context, "".concat(r6.displayName || "Context", ".Provider");
                  case iE:
                  case QG:
                  case vT:
                    if (T4.type._context === void 0 && T4.type.Provider === T4.type) return r6 = T4.type, "".concat(r6.displayName || "Context", ".Provider");
                    return r6 = T4.type._context || T4.type, "".concat(r6.displayName || "Context", ".Consumer");
                  case KQ:
                    return r6 = T4.type._context, "".concat(r6.displayName || "Context", ".Consumer");
                  case CH:
                  case KH:
                    return null;
                  case Eq:
                  case XH:
                    return "Profiler(".concat(T4.memoizedProps.id, ")");
                  case VH:
                  case Uq:
                    return "Scope";
                  default:
                    return null
                }
            }
          }
          return {
            getDisplayNameForFiber: s6,
            getTypeSymbol: c,
            ReactPriorityLevels: f,
            ReactTypeOfWork: p,
            StrictModeBits: b
          }
        }
        var h0 = new Map,
          i2 = new Map,
          n0 = new WeakMap;

        function l5(M, f, b, p) {
          var c = b.reconcilerVersion || b.version,
            q1 = F0(c),
            m1 = q1.getDisplayNameForFiber,
            l1 = q1.getTypeSymbol,
            $1 = q1.ReactPriorityLevels,
            s1 = q1.ReactTypeOfWork,
            XA = q1.StrictModeBits,
            jA = s1.CacheComponent,
            wA = s1.ClassComponent,
            pA = s1.ContextConsumer,
            W0 = s1.DehydratedSuspenseComponent,
            E2 = s1.ForwardRef,
            N0 = s1.Fragment,
            m2 = s1.FunctionComponent,
            K4 = s1.HostRoot,
            E6 = s1.HostHoistable,
            D2 = s1.HostSingleton,
            m4 = s1.HostPortal,
            U6 = s1.HostComponent,
            H4 = s1.HostText,
            a6 = s1.IncompleteClassComponent,
            f5 = s1.IncompleteFunctionComponent,
            E8 = s1.IndeterminateComponent,
            O4 = s1.LegacyHiddenComponent,
            U5 = s1.MemoComponent,
            aQ = s1.OffscreenComponent,
            dB = s1.SimpleMemoComponent,
            i5 = s1.SuspenseComponent,
            s6 = s1.SuspenseListComponent,
            T4 = s1.TracingMarkerComponent,
            sQ = s1.Throw,
            rQ = $1.ImmediatePriority,
            b0 = $1.UserBlockingPriority,
            O2 = $1.NormalPriority,
            n2 = $1.LowPriority,
            e4 = $1.IdlePriority,
            g6 = $1.NoPriority,
            X5 = b.getLaneLabelMap,
            r6 = b.injectProfilingHooks,
            I8 = b.overrideHookState,
            EQ = b.overrideHookStateDeletePath,
            oQ = b.overrideHookStateRenamePath,
            _F = b.overrideProps,
            jF = b.overridePropsDeletePath,
            yF = b.overridePropsRenamePath,
            OH = b.scheduleRefresh,
            HD = b.setErrorHandler,
            kF = b.setSuspenseHandler,
            JG = b.scheduleUpdate,
            a0 = typeof HD === "function" && typeof JG === "function",
            D9 = typeof kF === "function" && typeof JG === "function";
          if (typeof OH === "function") b.scheduleRefresh = function() {
            try {
              M.emit("fastRefreshScheduled")
            } finally {
              return OH.apply(void 0, arguments)
            }
          };
          var l4 = null,
            o6 = null;
          if (typeof r6 === "function") {
            var uB = RF({
              getDisplayNameForFiber: m1,
              getIsProfiling: function C1() {
                return wY
              },
              getLaneLabelMap: X5,
              currentDispatcherRef: j1(b),
              workTagMap: s1,
              reactVersion: c
            });
            r6(uB.profilingHooks), l4 = uB.getTimelineData, o6 = uB.toggleProfilingStatus
          }
          var t6 = new Set,
            _7 = new Map,
            ZZ = new Map,
            o8 = new Map,
            j7 = new Map;

          function TH() {
            var C1 = S(o8.keys()),
              H1;
            try {
              for (C1.s(); !(H1 = C1.n()).done;) {
                var i1 = H1.value,
                  a1 = i2.get(i1);
                if (a1 != null) t6.add(a1), K0(i1)
              }
            } catch (x2) {
              C1.e(x2)
            } finally {
              C1.f()
            }
            var RA = S(j7.keys()),
              iA;
            try {
              for (RA.s(); !(iA = RA.n()).done;) {
                var z0 = iA.value,
                  X9 = i2.get(z0);
                if (X9 != null) t6.add(X9), K0(z0)
              }
            } catch (x2) {
              RA.e(x2)
            } finally {
              RA.f()
            }
            o8.clear(), j7.clear(), jH()
          }

          function PH(C1, H1, i1) {
            var a1 = i2.get(C1);
            if (a1 != null)
              if (_7.delete(a1), i1.has(C1)) i1.delete(C1), t6.add(a1), jH(), K0(C1);
              else t6.delete(a1)
          }

          function I0(C1) {
            PH(C1, _7, o8)
          }

          function G0(C1) {
            PH(C1, ZZ, j7)
          }

          function K0(C1) {
            if (FG !== null && FG.id === C1) xq = !0
          }

          function O0(C1, H1, i1) {
            if (H1 === "error") {
              var a1 = DZ(C1);
              if (a1 != null && nW.get(a1) === !0) return
            }
            var RA = ly.apply(void 0, Tq(i1));
            if (K) M2("onErrorOrWarning", C1, null, "".concat(H1, ': "').concat(RA, '"'));
            t6.add(C1);
            var iA = H1 === "error" ? _7 : ZZ,
              z0 = iA.get(C1);
            if (z0 != null) {
              var X9 = z0.get(RA) || 0;
              z0.set(RA, X9 + 1)
            } else iA.set(C1, new Map([
              [RA, 1]
            ]));
            cV()
          }
          K01(b, O0), H01();
          var M2 = function C1(H1, i1, a1) {
              var RA = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : "";
              if (K) {
                var iA = i1.tag + ":" + (m1(i1) || "null"),
                  z0 = DZ(i1) || "<no id>",
                  X9 = a1 ? a1.tag + ":" + (m1(a1) || "null") : "",
                  x2 = a1 ? DZ(a1) || "<no-id>" : "";
                console.groupCollapsed("[renderer] %c".concat(H1, " %c").concat(iA, " (").concat(z0, ") %c").concat(a1 ? "".concat(X9, " (").concat(x2, ")") : "", " %c").concat(RA), "color: red; font-weight: bold;", "color: blue;", "color: purple;", "color: black;"), console.log(new Error().stack.split(`
`).slice(1).join(`
`)), console.groupEnd()
              }
            },
            H9 = new Set,
            N6 = new Set,
            v5 = new Set,
            b5 = !1,
            b2 = new Set;

          function xF(C1) {
            v5.clear(), H9.clear(), N6.clear(), C1.forEach(function(H1) {
              if (!H1.isEnabled) return;
              switch (H1.type) {
                case eG:
                  if (H1.isValid && H1.value !== "") H9.add(new RegExp(H1.value, "i"));
                  break;
                case kB:
                  v5.add(H1.value);
                  break;
                case S6:
                  if (H1.isValid && H1.value !== "") N6.add(new RegExp(H1.value, "i"));
                  break;
                case JQ:
                  H9.add(new RegExp("\\("));
                  break;
                default:
                  console.warn('Invalid component filter type "'.concat(H1.type, '"'));
                  break
              }
            })
          }
          if (window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ != null) {
            var v8 = QY(window.__REACT_DEVTOOLS_COMPONENT_FILTERS__);
            xF(v8)
          } else xF(Zq());

          function b8(C1) {
            if (wY) throw Error("Cannot modify filter preferences while profiling");
            M.getFiberRoots(f).forEach(function(H1) {
              tQ = SH(H1.current), g5(L), jH(H1), tQ = -1
            }), xF(C1), hq.clear(), M.getFiberRoots(f).forEach(function(H1) {
              tQ = SH(H1.current), mq(tQ, H1.current), zY(H1.current, null, !1, !1), jH(H1), tQ = -1
            }), f4(), jH()
          }

          function uV(C1) {
            var {
              tag: H1,
              type: i1,
              key: a1
            } = C1;
            switch (H1) {
              case W0:
                return !0;
              case m4:
              case H4:
              case O4:
              case aQ:
              case sQ:
                return !0;
              case K4:
                return !1;
              case N0:
                return a1 === null;
              default:
                var RA = l1(i1);
                switch (RA) {
                  case $2:
                  case dW:
                  case IG:
                  case CH:
                  case KH:
                    return !0;
                  default:
                    break
                }
            }
            var iA = UQ(C1);
            if (v5.has(iA)) return !0;
            if (H9.size > 0) {
              var z0 = m1(C1);
              if (z0 != null) {
                var X9 = S(H9),
                  x2;
                try {
                  for (X9.s(); !(x2 = X9.n()).done;) {
                    var N9 = x2.value;
                    if (N9.test(z0)) return !0
                  }
                } catch (i9) {
                  X9.e(i9)
                } finally {
                  X9.f()
                }
              }
            }
            return !1
          }

          function UQ(C1) {
            var {
              type: H1,
              tag: i1
            } = C1;
            switch (i1) {
              case wA:
              case a6:
                return n6;
              case f5:
              case m2:
              case E8:
                return EB;
              case E2:
                return yB;
              case K4:
                return P6;
              case U6:
              case E6:
              case D2:
                return t4;
              case m4:
              case H4:
              case N0:
                return J5;
              case U5:
              case dB:
                return ZD;
              case i5:
                return Q8;
              case s6:
                return k5;
              case T4:
                return lQ;
              default:
                var a1 = l1(H1);
                switch (a1) {
                  case $2:
                  case dW:
                  case IG:
                    return J5;
                  case WY:
                  case aE:
                    return tG;
                  case iE:
                  case QG:
                    return tG;
                  case CH:
                  case KH:
                    return J5;
                  case Eq:
                  case XH:
                    return Z9;
                  default:
                    return J5
                }
            }
          }
          var ap = new Map,
            sp = new Map,
            tQ = -1;

          function SH(C1) {
            var H1 = null;
            if (h0.has(C1)) H1 = h0.get(C1);
            else {
              var i1 = C1.alternate;
              if (i1 !== null && h0.has(i1)) H1 = h0.get(i1)
            }
            var a1 = !1;
            if (H1 === null) a1 = !0, H1 = FQ();
            var RA = H1;
            if (!h0.has(C1)) h0.set(C1, RA), i2.set(RA, C1);
            var iA = C1.alternate;
            if (iA !== null) {
              if (!h0.has(iA)) h0.set(iA, RA)
            }
            if (K) {
              if (a1) M2("getOrGenerateFiberID()", C1, C1.return, "Generated a new UID")
            }
            return RA
          }

          function HY(C1) {
            var H1 = DZ(C1);
            if (H1 !== null) return H1;
            throw Error('Could not find ID for Fiber "'.concat(m1(C1) || "", '"'))
          }

          function DZ(C1) {
            if (h0.has(C1)) return h0.get(C1);
            else {
              var H1 = C1.alternate;
              if (H1 !== null && h0.has(H1)) return h0.get(H1)
            }
            return null
          }

          function kE1(C1) {
            if (K) M2("untrackFiberID()", C1, C1.return, "schedule after delay");
            zD.add(C1);
            var H1 = C1.alternate;
            if (H1 !== null) zD.add(H1);
            if (jq === null) jq = setTimeout(DP, 1000)
          }
          var zD = new Set,
            jq = null;

          function DP() {
            if (jq !== null) clearTimeout(jq), jq = null;
            zD.forEach(function(C1) {
              var H1 = DZ(C1);
              if (H1 !== null) i2.delete(H1), I0(H1), G0(H1);
              h0.delete(C1), n0.delete(C1);
              var i1 = C1.alternate;
              if (i1 !== null) h0.delete(i1), n0.delete(i1);
              if (nW.has(H1)) {
                if (nW.delete(H1), nW.size === 0 && HD != null) HD(e01)
              }
            }), zD.clear()
          }

          function UB(C1, H1) {
            switch (UQ(H1)) {
              case n6:
              case EB:
              case ZD:
              case yB:
                if (C1 === null) return {
                  context: null,
                  didHooksChange: !1,
                  isFirstMount: !0,
                  props: null,
                  state: null
                };
                else {
                  var i1 = {
                      context: xE1(H1),
                      didHooksChange: !1,
                      isFirstMount: !1,
                      props: Nk(C1.memoizedProps, H1.memoizedProps),
                      state: Nk(C1.memoizedState, H1.memoizedState)
                    },
                    a1 = bE1(C1.memoizedState, H1.memoizedState);
                  return i1.hooks = a1, i1.didHooksChange = a1 !== null && a1.length > 0, i1
                }
              default:
                return null
            }
          }

          function NB(C1) {
            switch (UQ(C1)) {
              case n6:
              case yB:
              case EB:
              case ZD:
                if (XU !== null) {
                  var H1 = HY(C1),
                    i1 = g01(C1);
                  if (i1 !== null) XU.set(H1, i1)
                }
                break;
              default:
                break
            }
          }
          var WU = {};

          function g01(C1) {
            var H1 = WU,
              i1 = WU;
            switch (UQ(C1)) {
              case n6:
                var a1 = C1.stateNode;
                if (a1 != null) {
                  if (a1.constructor && a1.constructor.contextType != null) i1 = a1.context;
                  else if (H1 = a1.context, H1 && Object.keys(H1).length === 0) H1 = WU
                }
                return [H1, i1];
              case yB:
              case EB:
              case ZD:
                var RA = C1.dependencies;
                if (RA && RA.firstContext) i1 = RA.firstContext;
                return [H1, i1];
              default:
                return null
            }
          }

          function h01(C1) {
            var H1 = DZ(C1);
            if (H1 !== null) {
              NB(C1);
              var i1 = C1.child;
              while (i1 !== null) h01(i1), i1 = i1.sibling
            }
          }

          function xE1(C1) {
            if (XU !== null) {
              var H1 = HY(C1),
                i1 = XU.has(H1) ? XU.get(H1) : null,
                a1 = g01(C1);
              if (i1 == null || a1 == null) return null;
              var RA = aT(i1, 2),
                iA = RA[0],
                z0 = RA[1],
                X9 = aT(a1, 2),
                x2 = X9[0],
                N9 = X9[1];
              switch (UQ(C1)) {
                case n6:
                  if (i1 && a1) {
                    if (x2 !== WU) return Nk(iA, x2);
                    else if (N9 !== WU) return z0 !== N9
                  }
                  break;
                case yB:
                case EB:
                case ZD:
                  if (N9 !== WU) {
                    var i9 = z0,
                      A6 = N9;
                    while (i9 && A6) {
                      if (!h4(i9.memoizedValue, A6.memoizedValue)) return !0;
                      i9 = i9.next, A6 = A6.next
                    }
                    return !1
                  }
                  break;
                default:
                  break
              }
            }
            return null
          }

          function fE1(C1) {
            var H1 = C1.queue;
            if (!H1) return !1;
            var i1 = gB.bind(H1);
            if (i1("pending")) return !0;
            return i1("value") && i1("getSnapshot") && typeof H1.getSnapshot === "function"
          }

          function vE1(C1, H1) {
            var i1 = C1.memoizedState,
              a1 = H1.memoizedState;
            if (fE1(C1)) return i1 !== a1;
            return !1
          }

          function bE1(C1, H1) {
            if (C1 == null || H1 == null) return null;
            var i1 = [],
              a1 = 0;
            if (H1.hasOwnProperty("baseState") && H1.hasOwnProperty("memoizedState") && H1.hasOwnProperty("next") && H1.hasOwnProperty("queue"))
              while (H1 !== null) {
                if (vE1(C1, H1)) i1.push(a1);
                H1 = H1.next, C1 = C1.next, a1++
              }
            return i1
          }

          function Nk(C1, H1) {
            if (C1 == null || H1 == null) return null;
            if (H1.hasOwnProperty("baseState") && H1.hasOwnProperty("memoizedState") && H1.hasOwnProperty("next") && H1.hasOwnProperty("queue")) return null;
            var i1 = new Set([].concat(Tq(Object.keys(C1)), Tq(Object.keys(H1)))),
              a1 = [],
              RA = S(i1),
              iA;
            try {
              for (RA.s(); !(iA = RA.n()).done;) {
                var z0 = iA.value;
                if (C1[z0] !== H1[z0]) a1.push(z0)
              }
            } catch (X9) {
              RA.e(X9)
            } finally {
              RA.f()
            }
            return a1
          }

          function JU(C1, H1) {
            switch (H1.tag) {
              case wA:
              case m2:
              case pA:
              case U5:
              case dB:
              case E2:
                var i1 = 1;
                return (CA(H1) & i1) === i1;
              default:
                return C1.memoizedProps !== H1.memoizedProps || C1.memoizedState !== H1.memoizedState || C1.ref !== H1.ref
            }
          }
          var YZ = [],
            yq = [],
            _H = [],
            FU = [],
            y7 = new Map,
            pV = 0,
            kq = null;

          function g5(C1) {
            YZ.push(C1)
          }

          function $k() {
            if (wY) {
              if (fF != null && fF.durations.length > 0) return !1
            }
            return YZ.length === 0 && yq.length === 0 && _H.length === 0 && kq === null
          }

          function m01(C1) {
            if ($k()) return;
            if (FU !== null) FU.push(C1);
            else M.emit("operations", C1)
          }
          var YP = null;

          function rp() {
            if (YP !== null) clearTimeout(YP), YP = null
          }

          function cV() {
            rp(), YP = setTimeout(function() {
              if (YP = null, YZ.length > 0) return;
              if (WZ(), $k()) return;
              var C1 = new Array(3 + YZ.length);
              C1[0] = f, C1[1] = tQ, C1[2] = 0;
              for (var H1 = 0; H1 < YZ.length; H1++) C1[3 + H1] = YZ[H1];
              m01(C1), YZ.length = 0
            }, 1000)
          }

          function f4() {
            t6.clear(), o8.forEach(function(C1, H1) {
              var i1 = i2.get(H1);
              if (i1 != null) t6.add(i1)
            }), j7.forEach(function(C1, H1) {
              var i1 = i2.get(H1);
              if (i1 != null) t6.add(i1)
            }), WZ()
          }

          function op(C1, H1, i1, a1) {
            var RA = 0,
              iA = a1.get(H1),
              z0 = i1.get(C1);
            if (z0 != null)
              if (iA == null) iA = z0, a1.set(H1, z0);
              else {
                var X9 = iA;
                z0.forEach(function(x2, N9) {
                  var i9 = X9.get(N9) || 0;
                  X9.set(N9, i9 + x2)
                })
              } if (!uV(C1)) {
              if (iA != null) iA.forEach(function(x2) {
                RA += x2
              })
            }
            return i1.delete(C1), RA
          }

          function WZ() {
            rp(), t6.forEach(function(C1) {
              var H1 = DZ(C1);
              if (H1 === null);
              else {
                var i1 = op(C1, H1, _7, o8),
                  a1 = op(C1, H1, ZZ, j7);
                g5(T), g5(H1), g5(i1), g5(a1)
              }
              _7.delete(C1), ZZ.delete(C1)
            }), t6.clear()
          }

          function jH(C1) {
            if (WZ(), $k()) return;
            var H1 = yq.length + _H.length + (kq === null ? 0 : 1),
              i1 = new Array(3 + pV + (H1 > 0 ? 2 + H1 : 0) + YZ.length),
              a1 = 0;
            if (i1[a1++] = f, i1[a1++] = tQ, i1[a1++] = pV, y7.forEach(function(X9, x2) {
                var N9 = X9.encodedString,
                  i9 = N9.length;
                i1[a1++] = i9;
                for (var A6 = 0; A6 < i9; A6++) i1[a1 + A6] = N9[A6];
                a1 += i9
              }), H1 > 0) {
              i1[a1++] = q, i1[a1++] = H1;
              for (var RA = yq.length - 1; RA >= 0; RA--) i1[a1++] = yq[RA];
              for (var iA = 0; iA < _H.length; iA++) i1[a1 + iA] = _H[iA];
              if (a1 += _H.length, kq !== null) i1[a1] = kq, a1++
            }
            for (var z0 = 0; z0 < YZ.length; z0++) i1[a1 + z0] = YZ[z0];
            a1 += YZ.length, m01(i1), YZ.length = 0, yq.length = 0, _H.length = 0, kq = null, y7.clear(), pV = 0
          }

          function d01(C1) {
            if (C1 === null) return 0;
            var H1 = y7.get(C1);
            if (H1 !== void 0) return H1.id;
            var i1 = y7.size + 1,
              a1 = VF(C1);
            return y7.set(C1, {
              encodedString: a1,
              id: i1
            }), pV += a1.length + 1, i1
          }

          function N5(C1, H1) {
            var i1 = C1.tag === K4,
              a1 = SH(C1);
            if (K) M2("recordMount()", C1, H1);
            var RA = C1.hasOwnProperty("_debugOwner"),
              iA = C1.hasOwnProperty("treeBaseDuration"),
              z0 = 0;
            if (iA) {
              if (z0 = k, typeof r6 === "function") z0 |= i
            }
            if (i1) {
              var X9 = b.bundleType === 0;
              if (g5(N), g5(a1), g5(P6), g5((C1.mode & XA) !== 0 ? 1 : 0), g5(z0), g5(!X9 && XA !== 0 ? 1 : 0), g5(RA ? 1 : 0), wY) {
                if (bq !== null) bq.set(a1, Ok(C1))
              }
            } else {
              var x2 = C1.key,
                N9 = m1(C1),
                i9 = UQ(C1),
                A6 = C1._debugOwner,
                k7;
              if (A6 != null)
                if (typeof A6.tag === "number") k7 = SH(A6);
                else k7 = 0;
              else k7 = 0;
              var t8 = H1 ? HY(H1) : 0,
                VG = d01(N9),
                x7 = x2 === null ? null : String(x2),
                wD = d01(x7);
              if (g5(N), g5(a1), g5(i9), g5(t8), g5(k7), g5(VG), g5(wD), (C1.mode & XA) !== 0 && (H1.mode & XA) === 0) g5(_), g5(a1), g5(L7)
            }
            if (iA) sp.set(a1, tQ), u01(C1)
          }

          function tp(C1, H1) {
            if (K) M2("recordUnmount()", C1, null, H1 ? "unmount is simulated" : "");
            if (iV !== null) {
              if (C1 === iV || C1 === iV.alternate) A21(null)
            }
            var i1 = DZ(C1);
            if (i1 === null) return;
            var a1 = i1,
              RA = C1.tag === K4;
            if (RA) kq = a1;
            else if (!uV(C1))
              if (H1) _H.push(a1);
              else yq.push(a1);
            if (!C1._debugNeedsRemount) {
              kE1(C1);
              var iA = C1.hasOwnProperty("treeBaseDuration");
              if (iA) sp.delete(a1), ap.delete(a1)
            }
          }

          function zY(C1, H1, i1, a1) {
            var RA = C1;
            while (RA !== null) {
              if (SH(RA), K) M2("mountFiberRecursively()", RA, H1);
              var iA = WU1(RA),
                z0 = !uV(RA);
              if (z0) N5(RA, H1);
              if (b5) {
                if (a1) {
                  var X9 = UQ(RA);
                  if (X9 === t4) b2.add(RA.stateNode), a1 = !1
                }
              }
              var x2 = RA.tag === s1.SuspenseComponent;
              if (x2) {
                var N9 = RA.memoizedState !== null;
                if (N9) {
                  var i9 = RA.child,
                    A6 = i9 ? i9.sibling : null,
                    k7 = A6 ? A6.child : null;
                  if (k7 !== null) zY(k7, z0 ? RA : H1, !0, a1)
                } else {
                  var t8 = null,
                    VG = aQ === -1;
                  if (VG) t8 = RA.child;
                  else if (RA.child !== null) t8 = RA.child.child;
                  if (t8 !== null) zY(t8, z0 ? RA : H1, !0, a1)
                }
              } else if (RA.child !== null) zY(RA.child, z0 ? RA : H1, !0, a1);
              JU1(iA), RA = i1 ? RA.sibling : null
            }
          }

          function WP(C1) {
            if (K) M2("unmountFiberChildrenRecursively()", C1);
            var H1 = C1.tag === s1.SuspenseComponent && C1.memoizedState !== null,
              i1 = C1.child;
            if (H1) {
              var a1 = C1.child,
                RA = a1 ? a1.sibling : null;
              i1 = RA ? RA.child : null
            }
            while (i1 !== null) {
              if (i1.return !== null) WP(i1), tp(i1, !0);
              i1 = i1.sibling
            }
          }

          function u01(C1) {
            var H1 = HY(C1),
              i1 = C1.actualDuration,
              a1 = C1.treeBaseDuration;
            if (ap.set(H1, a1 || 0), wY) {
              var RA = C1.alternate;
              if (RA == null || a1 !== RA.treeBaseDuration) {
                var iA = Math.floor((a1 || 0) * 1000);
                g5(R), g5(H1), g5(iA)
              }
              if (RA == null || JU(RA, C1)) {
                if (i1 != null) {
                  var z0 = i1,
                    X9 = C1.child;
                  while (X9 !== null) z0 -= X9.actualDuration || 0, X9 = X9.sibling;
                  var x2 = fF;
                  if (x2.durations.push(H1, i1, z0), x2.maxActualDuration = Math.max(x2.maxActualDuration, i1), FP) {
                    var N9 = UB(RA, C1);
                    if (N9 !== null) {
                      if (x2.changeDescriptions !== null) x2.changeDescriptions.set(H1, N9)
                    }
                    NB(C1)
                  }
                }
              }
            }
          }

          function gE1(C1, H1) {
            if (K) M2("recordResetChildren()", H1, C1);
            var i1 = [],
              a1 = H1;
            while (a1 !== null) p01(a1, i1), a1 = a1.sibling;
            var RA = i1.length;
            if (RA < 2) return;
            g5(O), g5(HY(C1)), g5(RA);
            for (var iA = 0; iA < i1.length; iA++) g5(i1[iA])
          }

          function p01(C1, H1) {
            if (!uV(C1)) H1.push(HY(C1));
            else {
              var i1 = C1.child,
                a1 = C1.tag === i5 && C1.memoizedState !== null;
              if (a1) {
                var RA = C1.child,
                  iA = RA ? RA.sibling : null,
                  z0 = iA ? iA.child : null;
                if (z0 !== null) i1 = z0
              }
              while (i1 !== null) p01(i1, H1), i1 = i1.sibling
            }
          }

          function ep(C1, H1, i1, a1) {
            var RA = SH(C1);
            if (K) M2("updateFiberRecursively()", C1, i1);
            if (b5) {
              var iA = UQ(C1);
              if (a1) {
                if (iA === t4) b2.add(C1.stateNode), a1 = !1
              } else if (iA === EB || iA === n6 || iA === tG || iA === ZD || iA === yB) a1 = JU(H1, C1)
            }
            if (FG !== null && FG.id === RA && JU(H1, C1)) xq = !0;
            var z0 = !uV(C1),
              X9 = C1.tag === i5,
              x2 = !1,
              N9 = X9 && H1.memoizedState !== null,
              i9 = X9 && C1.memoizedState !== null;
            if (N9 && i9) {
              var A6 = C1.child,
                k7 = A6 ? A6.sibling : null,
                t8 = H1.child,
                VG = t8 ? t8.sibling : null;
              if (VG == null && k7 != null) zY(k7, z0 ? C1 : i1, !0, a1), x2 = !0;
              if (k7 != null && VG != null && ep(k7, VG, C1, a1)) x2 = !0
            } else if (N9 && !i9) {
              var x7 = C1.child;
              if (x7 !== null) zY(x7, z0 ? C1 : i1, !0, a1);
              x2 = !0
            } else if (!N9 && i9) {
              WP(H1);
              var wD = C1.child,
                nV = wD ? wD.sibling : null;
              if (nV != null) zY(nV, z0 ? C1 : i1, !0, a1), x2 = !0
            } else if (C1.child !== H1.child) {
              var CG = C1.child,
                aW = H1.child;
              while (CG) {
                if (CG.alternate) {
                  var VU = CG.alternate;
                  if (ep(CG, VU, z0 ? C1 : i1, a1)) x2 = !0;
                  if (VU !== aW) x2 = !0
                } else zY(CG, z0 ? C1 : i1, !1, a1), x2 = !0;
                if (CG = CG.sibling, !x2 && aW !== null) aW = aW.sibling
              }
              if (aW !== null) x2 = !0
            } else if (b5) {
              if (a1) {
                var CP = l01(HY(C1));
                CP.forEach(function(aV) {
                  b2.add(aV.stateNode)
                })
              }
            }
            if (z0) {
              var dq = C1.hasOwnProperty("treeBaseDuration");
              if (dq) u01(C1)
            }
            if (x2)
              if (z0) {
                var EY = C1.child;
                if (i9) {
                  var xH = C1.child;
                  EY = xH ? xH.sibling : null
                }
                if (EY != null) gE1(C1, EY);
                return !1
              } else return !0;
            else return !1
          }

          function hE1() {}

          function Ac(C1) {
            if (C1.memoizedInteractions != null) return !0;
            else if (C1.current != null && C1.current.hasOwnProperty("treeBaseDuration")) return !0;
            else return !1
          }

          function mE1() {
            var C1 = FU;
            if (FU = null, C1 !== null && C1.length > 0) C1.forEach(function(H1) {
              M.emit("operations", H1)
            });
            else {
              if (yH !== null) kH = !0;
              M.getFiberRoots(f).forEach(function(H1) {
                if (tQ = SH(H1.current), mq(tQ, H1.current), wY && Ac(H1)) fF = {
                  changeDescriptions: FP ? new Map : null,
                  durations: [],
                  commitTime: kA() - Zc,
                  maxActualDuration: 0,
                  priorityLevel: null,
                  updaters: c01(H1),
                  effectDuration: null,
                  passiveEffectDuration: null
                };
                zY(H1.current, null, !1, !1), jH(H1), tQ = -1
              })
            }
          }

          function c01(C1) {
            return C1.memoizedUpdaters != null ? Array.from(C1.memoizedUpdaters).filter(function(H1) {
              return DZ(H1) !== null
            }).map(qk) : null
          }

          function dE1(C1) {
            if (!zD.has(C1)) tp(C1, !1)
          }

          function uE1(C1) {
            if (wY && Ac(C1)) {
              if (fF !== null) {
                var H1 = Jq(C1),
                  i1 = H1.effectDuration,
                  a1 = H1.passiveEffectDuration;
                fF.effectDuration = i1, fF.passiveEffectDuration = a1
              }
            }
          }

          function pE1(C1, H1) {
            var i1 = C1.current,
              a1 = i1.alternate;
            if (DP(), tQ = SH(i1), yH !== null) kH = !0;
            if (b5) b2.clear();
            var RA = Ac(C1);
            if (wY && RA) fF = {
              changeDescriptions: FP ? new Map : null,
              durations: [],
              commitTime: kA() - Zc,
              maxActualDuration: 0,
              priorityLevel: H1 == null ? null : Dc(H1),
              updaters: c01(C1),
              effectDuration: null,
              passiveEffectDuration: null
            };
            if (a1) {
              var iA = a1.memoizedState != null && a1.memoizedState.element != null && a1.memoizedState.isDehydrated !== !0,
                z0 = i1.memoizedState != null && i1.memoizedState.element != null && i1.memoizedState.isDehydrated !== !0;
              if (!iA && z0) mq(tQ, i1), zY(i1, null, !1, !1);
              else if (iA && z0) ep(i1, a1, null, !1);
              else if (iA && !z0) B21(tQ), tp(i1, !1)
            } else mq(tQ, i1), zY(i1, null, !1, !1);
            if (wY && RA) {
              if (!$k()) {
                var X9 = XP.get(tQ);
                if (X9 != null) X9.push(fF);
                else XP.set(tQ, [fF])
              }
            }
            if (jH(C1), b5) M.emit("traceUpdates", b2);
            tQ = -1
          }

          function l01(C1) {
            var H1 = [],
              i1 = lV(C1);
            if (!i1) return H1;
            var a1 = i1;
            while (!0) {
              if (a1.tag === U6 || a1.tag === H4) H1.push(a1);
              else if (a1.child) {
                a1.child.return = a1, a1 = a1.child;
                continue
              }
              if (a1 === i1) return H1;
              while (!a1.sibling) {
                if (!a1.return || a1.return === i1) return H1;
                a1 = a1.return
              }
              a1.sibling.return = a1.return, a1 = a1.sibling
            }
            return H1
          }

          function i01(C1) {
            try {
              var H1 = lV(C1);
              if (H1 === null) return null;
              var i1 = l01(C1);
              return i1.map(function(a1) {
                return a1.stateNode
              }).filter(Boolean)
            } catch (a1) {
              return null
            }
          }

          function Bc(C1) {
            var H1 = i2.get(C1);
            return H1 != null ? m1(H1) : null
          }

          function cE1(C1) {
            return b.findFiberByHostInstance(C1)
          }

          function Qc(C1) {
            var H1 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1,
              i1 = b.findFiberByHostInstance(C1);
            if (i1 != null) {
              if (H1)
                while (i1 !== null && uV(i1)) i1 = i1.return;
              return HY(i1)
            }
            return null
          }

          function n01(C1) {
            if (a01(C1) !== C1) throw new Error("Unable to find node on an unmounted component.")
          }

          function a01(C1) {
            var H1 = C1,
              i1 = C1;
            if (!C1.alternate) {
              var a1 = H1;
              do {
                H1 = a1;
                var RA = 2,
                  iA = 4096;
                if ((H1.flags & (RA | iA)) !== 0) i1 = H1.return;
                a1 = H1.return
              } while (a1)
            } else
              while (H1.return) H1 = H1.return;
            if (H1.tag === K4) return i1;
            return null
          }

          function lV(C1) {
            var H1 = i2.get(C1);
            if (H1 == null) return console.warn('Could not find Fiber with id "'.concat(C1, '"')), null;
            var i1 = H1.alternate;
            if (!i1) {
              var a1 = a01(H1);
              if (a1 === null) throw new Error("Unable to find node on an unmounted component.");
              if (a1 !== H1) return null;
              return H1
            }
            var RA = H1,
              iA = i1;
            while (!0) {
              var z0 = RA.return;
              if (z0 === null) break;
              var X9 = z0.alternate;
              if (X9 === null) {
                var x2 = z0.return;
                if (x2 !== null) {
                  RA = iA = x2;
                  continue
                }
                break
              }
              if (z0.child === X9.child) {
                var N9 = z0.child;
                while (N9) {
                  if (N9 === RA) return n01(z0), H1;
                  if (N9 === iA) return n01(z0), i1;
                  N9 = N9.sibling
                }
                throw new Error("Unable to find node on an unmounted component.")
              }
              if (RA.return !== iA.return) RA = z0, iA = X9;
              else {
                var i9 = !1,
                  A6 = z0.child;
                while (A6) {
                  if (A6 === RA) {
                    i9 = !0, RA = z0, iA = X9;
                    break
                  }
                  if (A6 === iA) {
                    i9 = !0, iA = z0, RA = X9;
                    break
                  }
                  A6 = A6.sibling
                }
                if (!i9) {
                  A6 = X9.child;
                  while (A6) {
                    if (A6 === RA) {
                      i9 = !0, RA = X9, iA = z0;
                      break
                    }
                    if (A6 === iA) {
                      i9 = !0, iA = X9, RA = z0;
                      break
                    }
                    A6 = A6.sibling
                  }
                  if (!i9) throw new Error("Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.")
                }
              }
              if (RA.alternate !== iA) throw new Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.")
            }
            if (RA.tag !== K4) throw new Error("Unable to find node on an unmounted component.");
            if (RA.stateNode.current === RA) return H1;
            return i1
          }

          function eQ(C1, H1) {
            if (JP(C1)) window.$attribute = xB(FG, H1)
          }

          function JZ(C1) {
            var H1 = i2.get(C1);
            if (H1 == null) {
              console.warn('Could not find Fiber with id "'.concat(C1, '"'));
              return
            }
            var {
              elementType: i1,
              tag: a1,
              type: RA
            } = H1;
            switch (a1) {
              case wA:
              case a6:
              case f5:
              case E8:
              case m2:
                p.$type = RA;
                break;
              case E2:
                p.$type = RA.render;
                break;
              case U5:
              case dB:
                p.$type = i1 != null && i1.type != null ? i1.type : RA;
                break;
              default:
                p.$type = null;
                break
            }
          }

          function qk(C1) {
            return {
              displayName: m1(C1) || "Anonymous",
              id: HY(C1),
              key: C1.key,
              type: UQ(C1)
            }
          }

          function lE1(C1) {
            var H1 = lV(C1);
            if (H1 == null) return null;
            var i1 = [qk(H1)],
              a1 = H1._debugOwner;
            while (a1 != null)
              if (typeof a1.tag === "number") {
                var RA = a1;
                i1.unshift(qk(RA)), a1 = RA._debugOwner
              } else break;
            return i1
          }

          function iE1(C1) {
            var H1 = null,
              i1 = null,
              a1 = lV(C1);
            if (a1 !== null) {
              if (H1 = a1.stateNode, a1.memoizedProps !== null) i1 = a1.memoizedProps.style
            }
            return {
              instance: H1,
              style: i1
            }
          }

          function Ic(C1) {
            var {
              tag: H1,
              type: i1
            } = C1;
            switch (H1) {
              case wA:
              case a6:
                var a1 = C1.stateNode;
                return typeof i1.getDerivedStateFromError === "function" || a1 !== null && typeof a1.componentDidCatch === "function";
              default:
                return !1
            }
          }

          function s01(C1) {
            var H1 = C1.return;
            while (H1 !== null) {
              if (Ic(H1)) return DZ(H1);
              H1 = H1.return
            }
            return null
          }

          function r01(C1) {
            var H1 = lV(C1);
            if (H1 == null) return null;
            var {
              _debugOwner: i1,
              stateNode: a1,
              key: RA,
              memoizedProps: iA,
              memoizedState: z0,
              dependencies: X9,
              tag: x2,
              type: N9
            } = H1, i9 = UQ(H1), A6 = (x2 === m2 || x2 === dB || x2 === E2) && (!!z0 || !!X9), k7 = !A6 && x2 !== jA, t8 = l1(N9), VG = !1, x7 = null;
            if (x2 === wA || x2 === m2 || x2 === a6 || x2 === f5 || x2 === E8 || x2 === U5 || x2 === E2 || x2 === dB) {
              if (VG = !0, a1 && a1.context != null) {
                var wD = i9 === n6 && !(N9.contextTypes || N9.contextType);
                if (!wD) x7 = a1.context
              }
            } else if ((t8 === iE || t8 === QG) && !(N9._context === void 0 && N9.Provider === N9)) {
              var nV = N9._context || N9;
              x7 = nV._currentValue || null;
              var CG = H1.return;
              while (CG !== null) {
                var aW = CG.type,
                  VU = l1(aW);
                if (VU === WY || VU === aE) {
                  var CP = aW._context || aW.context;
                  if (CP === nV) {
                    x7 = CG.memoizedProps.value;
                    break
                  }
                }
                CG = CG.return
              }
            } else if (t8 === KQ) {
              var dq = N9._context;
              x7 = dq._currentValue || null;
              var EY = H1.return;
              while (EY !== null) {
                var xH = EY.type,
                  aV = l1(xH);
                if (aV === QG) {
                  var Tk = xH;
                  if (Tk === dq) {
                    x7 = EY.memoizedProps.value;
                    break
                  }
                }
                EY = EY.return
              }
            }
            var G21 = !1;
            if (x7 !== null) G21 = !!N9.contextTypes, x7 = {
              value: x7
            };
            var Pk = null,
              Sk = i1;
            while (Sk != null)
              if (typeof Sk.tag === "number") {
                var Z21 = Sk;
                if (Pk === null) Pk = [];
                Pk.push(qk(Z21)), Sk = Z21._debugOwner
              } else break;
            var KU1 = x2 === i5 && z0 !== null,
              D21 = null;
            if (A6) {
              var Yc = {};
              for (var Wc in console) try {
                Yc[Wc] = console[Wc], console[Wc] = function() {}
              } catch (GA) {}
              try {
                D21 = zq.inspectHooksOfFiber(H1, j1(b))
              } finally {
                for (var Y21 in Yc) try {
                  console[Y21] = Yc[Y21]
                } catch (GA) {}
              }
            }
            var W21 = null,
              _k = H1;
            while (_k.return !== null) _k = _k.return;
            var Jc = _k.stateNode;
            if (Jc != null && Jc._debugRootType !== null) W21 = Jc._debugRootType;
            var H = o8.get(C1) || new Map,
              $ = j7.get(C1) || new Map,
              y = !1,
              l;
            if (Ic(H1)) {
              var Y1 = 128;
              y = (H1.flags & Y1) !== 0 || nW.get(C1) === !0, l = y ? C1 : s01(H1)
            } else l = s01(H1);
            var R1 = {
              stylex: null
            };
            if (vp) {
              if (iA != null && iA.hasOwnProperty("xstyle")) R1.stylex = T7(iA.xstyle)
            }
            var n1 = null;
            if (VG) n1 = XG(H1);
            return {
              id: C1,
              canEditHooks: typeof I8 === "function",
              canEditFunctionProps: typeof _F === "function",
              canEditHooksAndDeletePaths: typeof EQ === "function",
              canEditHooksAndRenamePaths: typeof oQ === "function",
              canEditFunctionPropsDeletePaths: typeof jF === "function",
              canEditFunctionPropsRenamePaths: typeof yF === "function",
              canToggleError: a0 && l != null,
              isErrored: y,
              targetErrorBoundaryID: l,
              canToggleSuspense: D9 && (!KU1 || gq.has(C1)),
              canViewSource: VG,
              source: n1,
              hasLegacyContext: G21,
              key: RA != null ? RA : null,
              displayName: m1(H1),
              type: i9,
              context: x7,
              hooks: D21,
              props: iA,
              state: k7 ? z0 : null,
              errors: Array.from(H.entries()),
              warnings: Array.from($.entries()),
              owners: Pk,
              rootType: W21,
              rendererPackageName: b.rendererPackageName,
              rendererVersion: b.version,
              plugins: R1
            }
          }
          var FG = null,
            xq = !1,
            Mk = {};

          function JP(C1) {
            return FG !== null && FG.id === C1
          }

          function nE1(C1) {
            return JP(C1) && !xq
          }

          function o01(C1) {
            var H1 = Mk;
            C1.forEach(function(i1) {
              if (!H1[i1]) H1[i1] = {};
              H1 = H1[i1]
            })
          }

          function fq(C1, H1) {
            return function i1(a1) {
              switch (H1) {
                case "hooks":
                  if (a1.length === 1) return !0;
                  if (a1[a1.length - 2] === "hookSource" && a1[a1.length - 1] === "fileName") return !0;
                  if (a1[a1.length - 1] === "subHooks" || a1[a1.length - 2] === "subHooks") return !0;
                  break;
                default:
                  break
              }
              var RA = C1 === null ? Mk : Mk[C1];
              if (!RA) return !1;
              for (var iA = 0; iA < a1.length; iA++)
                if (RA = RA[a1[iA]], !RA) return !1;
              return !0
            }
          }

          function aE1(C1) {
            var {
              hooks: H1,
              id: i1,
              props: a1
            } = C1, RA = i2.get(i1);
            if (RA == null) {
              console.warn('Could not find Fiber with id "'.concat(i1, '"'));
              return
            }
            var {
              elementType: iA,
              stateNode: z0,
              tag: X9,
              type: x2
            } = RA;
            switch (X9) {
              case wA:
              case a6:
              case E8:
                p.$r = z0;
                break;
              case f5:
              case m2:
                p.$r = {
                  hooks: H1,
                  props: a1,
                  type: x2
                };
                break;
              case E2:
                p.$r = {
                  hooks: H1,
                  props: a1,
                  type: x2.render
                };
                break;
              case U5:
              case dB:
                p.$r = {
                  hooks: H1,
                  props: a1,
                  type: iA != null && iA.type != null ? iA.type : x2
                };
                break;
              default:
                p.$r = null;
                break
            }
          }

          function sE1(C1, H1, i1) {
            if (JP(C1)) {
              var a1 = xB(FG, H1),
                RA = "$reactTemp".concat(i1);
              window[RA] = a1, console.log(RA), console.log(a1)
            }
          }

          function rE1(C1, H1) {
            if (JP(C1)) {
              var i1 = xB(FG, H1);
              return OT(i1)
            }
          }

          function oE1(C1, H1, i1, a1) {
            if (i1 !== null) o01(i1);
            if (JP(H1) && !a1) {
              if (!xq)
                if (i1 !== null) {
                  var RA = null;
                  if (i1[0] === "hooks") RA = "hooks";
                  return {
                    id: H1,
                    responseID: C1,
                    type: "hydrated-path",
                    path: i1,
                    value: bW(xB(FG, i1), fq(null, RA), i1)
                  }
                } else return {
                  id: H1,
                  responseID: C1,
                  type: "no-change"
                }
            } else Mk = {};
            xq = !1;
            try {
              FG = r01(H1)
            } catch (i9) {
              if (i9.name === "ReactDebugToolsRenderError") {
                var iA = "Error rendering inspected element.",
                  z0;
                if (console.error(iA + `

`, i9), i9.cause != null) {
                  var X9 = lV(H1),
                    x2 = X9 != null ? m1(X9) : null;
                  if (console.error("React DevTools encountered an error while trying to inspect hooks. This is most likely caused by an error in current inspected component" + (x2 != null ? ': "'.concat(x2, '".') : ".") + `
The error thrown in the component is: 

`, i9.cause), i9.cause instanceof Error) iA = i9.cause.message || iA, z0 = i9.cause.stack
                }
                return {
                  type: "error",
                  errorType: "user",
                  id: H1,
                  responseID: C1,
                  message: iA,
                  stack: z0
                }
              }
              if (i9.name === "ReactDebugToolsUnsupportedHookError") return {
                type: "error",
                errorType: "unknown-hook",
                id: H1,
                responseID: C1,
                message: "Unsupported hook in the react-debug-tools package: " + i9.message
              };
              return console.error(`Error inspecting element.

`, i9), {
                type: "error",
                errorType: "uncaught",
                id: H1,
                responseID: C1,
                message: i9.message,
                stack: i9.stack
              }
            }
            if (FG === null) return {
              id: H1,
              responseID: C1,
              type: "not-found"
            };
            aE1(FG);
            var N9 = OF({}, FG);
            return N9.context = bW(N9.context, fq("context", null)), N9.hooks = bW(N9.hooks, fq("hooks", "hooks")), N9.props = bW(N9.props, fq("props", null)), N9.state = bW(N9.state, fq("state", null)), {
              id: H1,
              responseID: C1,
              type: "full-data",
              value: N9
            }
          }

          function vq(C1) {
            var H1 = nE1(C1) ? FG : r01(C1);
            if (H1 === null) {
              console.warn('Could not find Fiber with id "'.concat(C1, '"'));
              return
            }
            var i1 = typeof console.groupCollapsed === "function";
            if (i1) console.groupCollapsed("[Click to expand] %c<".concat(H1.displayName || "Component", " />"), "color: var(--dom-tag-name-color); font-weight: normal;");
            if (H1.props !== null) console.log("Props:", H1.props);
            if (H1.state !== null) console.log("State:", H1.state);
            if (H1.hooks !== null) console.log("Hooks:", H1.hooks);
            var a1 = i01(C1);
            if (a1 !== null) console.log("Nodes:", a1);
            if (window.chrome || /firefox/i.test(navigator.userAgent)) console.log("Right-click any value to save it as a global variable for further inspection.");
            if (i1) console.groupEnd()
          }

          function tE1(C1, H1, i1, a1) {
            var RA = lV(H1);
            if (RA !== null) {
              var iA = RA.stateNode;
              switch (C1) {
                case "context":
                  switch (a1 = a1.slice(1), RA.tag) {
                    case wA:
                      if (a1.length === 0);
                      else GH(iA.context, a1);
                      iA.forceUpdate();
                      break;
                    case m2:
                      break
                  }
                  break;
                case "hooks":
                  if (typeof EQ === "function") EQ(RA, i1, a1);
                  break;
                case "props":
                  if (iA === null) {
                    if (typeof jF === "function") jF(RA, a1)
                  } else RA.pendingProps = Wq(iA.props, a1), iA.forceUpdate();
                  break;
                case "state":
                  GH(iA.state, a1), iA.forceUpdate();
                  break
              }
            }
          }

          function eE1(C1, H1, i1, a1, RA) {
            var iA = lV(H1);
            if (iA !== null) {
              var z0 = iA.stateNode;
              switch (C1) {
                case "context":
                  switch (a1 = a1.slice(1), RA = RA.slice(1), iA.tag) {
                    case wA:
                      if (a1.length === 0);
                      else fW(z0.context, a1, RA);
                      z0.forceUpdate();
                      break;
                    case m2:
                      break
                  }
                  break;
                case "hooks":
                  if (typeof oQ === "function") oQ(iA, i1, a1, RA);
                  break;
                case "props":
                  if (z0 === null) {
                    if (typeof yF === "function") yF(iA, a1, RA)
                  } else iA.pendingProps = yV(z0.props, a1, RA), z0.forceUpdate();
                  break;
                case "state":
                  fW(z0.state, a1, RA), z0.forceUpdate();
                  break
              }
            }
          }

          function AU1(C1, H1, i1, a1, RA) {
            var iA = lV(H1);
            if (iA !== null) {
              var z0 = iA.stateNode;
              switch (C1) {
                case "context":
                  switch (a1 = a1.slice(1), iA.tag) {
                    case wA:
                      if (a1.length === 0) z0.context = RA;
                      else fE(z0.context, a1, RA);
                      z0.forceUpdate();
                      break;
                    case m2:
                      break
                  }
                  break;
                case "hooks":
                  if (typeof I8 === "function") I8(iA, i1, a1, RA);
                  break;
                case "props":
                  switch (iA.tag) {
                    case wA:
                      iA.pendingProps = zF(z0.props, a1, RA), z0.forceUpdate();
                      break;
                    default:
                      if (typeof _F === "function") _F(iA, a1, RA);
                      break
                  }
                  break;
                case "state":
                  switch (iA.tag) {
                    case wA:
                      fE(z0.state, a1, RA), z0.forceUpdate();
                      break
                  }
                  break
              }
            }
          }
          var fF = null,
            bq = null,
            XU = null,
            Lk = null,
            Gc = null,
            wY = !1,
            Zc = 0,
            FP = !1,
            XP = null;

          function BU1() {
            var C1 = [];
            if (XP === null) throw Error("getProfilingData() called before any profiling data was recorded");
            XP.forEach(function(x2, N9) {
              var i9 = [],
                A6 = [],
                k7 = bq !== null && bq.get(N9) || "Unknown";
              if (Lk != null) Lk.forEach(function(t8, VG) {
                if (Gc != null && Gc.get(VG) === N9) A6.push([VG, t8])
              });
              x2.forEach(function(t8, VG) {
                var {
                  changeDescriptions: x7,
                  durations: wD,
                  effectDuration: nV,
                  maxActualDuration: CG,
                  passiveEffectDuration: aW,
                  priorityLevel: VU,
                  commitTime: CP,
                  updaters: dq
                } = t8, EY = [], xH = [];
                for (var aV = 0; aV < wD.length; aV += 3) {
                  var Tk = wD[aV];
                  EY.push([Tk, wD[aV + 1]]), xH.push([Tk, wD[aV + 2]])
                }
                i9.push({
                  changeDescriptions: x7 !== null ? Array.from(x7.entries()) : null,
                  duration: CG,
                  effectDuration: nV,
                  fiberActualDurations: EY,
                  fiberSelfDurations: xH,
                  passiveEffectDuration: aW,
                  priorityLevel: VU,
                  timestamp: CP,
                  updaters: dq
                })
              }), C1.push({
                commitData: i9,
                displayName: k7,
                initialTreeBaseDurations: A6,
                rootID: N9
              })
            });
            var H1 = null;
            if (typeof l4 === "function") {
              var i1 = l4();
              if (i1) {
                var {
                  batchUIDToMeasuresMap: a1,
                  internalModuleSourceToRanges: RA,
                  laneToLabelMap: iA,
                  laneToReactMeasureMap: z0
                } = i1, X9 = IU(i1, ["batchUIDToMeasuresMap", "internalModuleSourceToRanges", "laneToLabelMap", "laneToReactMeasureMap"]);
                H1 = OF(OF({}, X9), {}, {
                  batchUIDToMeasuresKeyValueArray: Array.from(a1.entries()),
                  internalModuleSourceToRanges: Array.from(RA.entries()),
                  laneToLabelKeyValueArray: Array.from(iA.entries()),
                  laneToReactMeasureKeyValueArray: Array.from(z0.entries())
                })
              }
            }
            return {
              dataForRoots: C1,
              rendererID: f,
              timelineData: H1
            }
          }

          function t01(C1) {
            if (wY) return;
            if (FP = C1, bq = new Map, Lk = new Map(ap), Gc = new Map(sp), XU = new Map, M.getFiberRoots(f).forEach(function(H1) {
                var i1 = HY(H1.current);
                if (bq.set(i1, Ok(H1.current)), C1) h01(H1.current)
              }), wY = !0, Zc = kA(), XP = new Map, o6 !== null) o6(!0)
          }

          function QU1() {
            if (wY = !1, FP = !1, o6 !== null) o6(!1)
          }
          if (W1(N1) === "true") t01(W1(D1) === "true");

          function e01() {
            return null
          }
          var nW = new Map;

          function IU1(C1) {
            if (typeof HD !== "function") throw new Error("Expected overrideError() to not get called for earlier React versions.");
            var H1 = DZ(C1);
            if (H1 === null) return null;
            var i1 = null;
            if (nW.has(H1)) {
              if (i1 = nW.get(H1), i1 === !1) {
                if (nW.delete(H1), nW.size === 0) HD(e01)
              }
            }
            return i1
          }

          function GU1(C1, H1) {
            if (typeof HD !== "function" || typeof JG !== "function") throw new Error("Expected overrideError() to not get called for earlier React versions.");
            if (nW.set(C1, H1), nW.size === 1) HD(IU1);
            var i1 = i2.get(C1);
            if (i1 != null) JG(i1)
          }

          function ZU1() {
            return !1
          }
          var gq = new Set;

          function DU1(C1) {
            var H1 = DZ(C1);
            return H1 !== null && gq.has(H1)
          }

          function YU1(C1, H1) {
            if (typeof kF !== "function" || typeof JG !== "function") throw new Error("Expected overrideSuspense() to not get called for earlier React versions.");
            if (H1) {
              if (gq.add(C1), gq.size === 1) kF(DU1)
            } else if (gq.delete(C1), gq.size === 0) kF(ZU1);
            var i1 = i2.get(C1);
            if (i1 != null) JG(i1)
          }
          var yH = null,
            iV = null,
            VP = -1,
            kH = !1;

          function A21(C1) {
            if (C1 === null) iV = null, VP = -1, kH = !1;
            yH = C1
          }

          function WU1(C1) {
            if (yH === null || !kH) return !1;
            var H1 = C1.return,
              i1 = H1 !== null ? H1.alternate : null;
            if (iV === H1 || iV === i1 && i1 !== null) {
              var a1 = Q21(C1),
                RA = yH[VP + 1];
              if (RA === void 0) throw new Error("Expected to see a frame at the next depth.");
              if (a1.index === RA.index && a1.key === RA.key && a1.displayName === RA.displayName) {
                if (iV = C1, VP++, VP === yH.length - 1) kH = !1;
                else kH = !0;
                return !1
              }
            }
            return kH = !1, !0
          }

          function JU1(C1) {
            kH = C1
          }
          var Rk = new Map,
            hq = new Map;

          function mq(C1, H1) {
            var i1 = Ok(H1),
              a1 = hq.get(i1) || 0;
            hq.set(i1, a1 + 1);
            var RA = "".concat(i1, ":").concat(a1);
            Rk.set(C1, RA)
          }

          function B21(C1) {
            var H1 = Rk.get(C1);
            if (H1 === void 0) throw new Error("Expected root pseudo key to be known.");
            var i1 = H1.slice(0, H1.lastIndexOf(":")),
              a1 = hq.get(i1);
            if (a1 === void 0) throw new Error("Expected counter to be known.");
            if (a1 > 1) hq.set(i1, a1 - 1);
            else hq.delete(i1);
            Rk.delete(C1)
          }

          function Ok(C1) {
            var H1 = null,
              i1 = null,
              a1 = C1.child;
            for (var RA = 0; RA < 3; RA++) {
              if (a1 === null) break;
              var iA = m1(a1);
              if (iA !== null) {
                if (typeof a1.type === "function") H1 = iA;
                else if (i1 === null) i1 = iA
              }
              if (H1 !== null) break;
              a1 = a1.child
            }
            return H1 || i1 || "Anonymous"
          }

          function Q21(C1) {
            var H1 = C1.key,
              i1 = m1(C1),
              a1 = C1.index;
            switch (C1.tag) {
              case K4:
                var RA = HY(C1),
                  iA = Rk.get(RA);
                if (iA === void 0) throw new Error("Expected mounted root to have known pseudo key.");
                i1 = iA;
                break;
              case U6:
                i1 = C1.type;
                break;
              default:
                break
            }
            return {
              displayName: i1,
              key: H1,
              index: a1
            }
          }

          function FU1(C1) {
            var H1 = i2.get(C1);
            if (H1 == null) return null;
            var i1 = [];
            while (H1 !== null) i1.push(Q21(H1)), H1 = H1.return;
            return i1.reverse(), i1
          }

          function XU1() {
            if (yH === null) return null;
            if (iV === null) return null;
            var C1 = iV;
            while (C1 !== null && uV(C1)) C1 = C1.return;
            if (C1 === null) return null;
            return {
              id: HY(C1),
              isFullMatch: VP === yH.length - 1
            }
          }
          var Dc = function C1(H1) {
            if (H1 == null) return "Unknown";
            switch (H1) {
              case rQ:
                return "Immediate";
              case b0:
                return "User-Blocking";
              case O2:
                return "Normal";
              case n2:
                return "Low";
              case e4:
                return "Idle";
              case g6:
              default:
                return "Unknown"
            }
          };

          function VU1(C1) {
            b5 = C1
          }

          function CU1(C1) {
            return i2.has(C1)
          }

          function I21(C1) {
            var H1 = n0.get(C1);
            if (H1 == null) {
              var i1 = j1(b);
              if (i1 == null) return null;
              H1 = iW(s1, C1, i1), n0.set(C1, H1)
            }
            return H1
          }

          function XG(C1) {
            var H1 = I21(C1);
            if (H1 == null) return null;
            return PT(H1)
          }
          return {
            cleanup: hE1,
            clearErrorsAndWarnings: TH,
            clearErrorsForFiberID: I0,
            clearWarningsForFiberID: G0,
            getSerializedElementValueByPath: rE1,
            deletePath: tE1,
            findNativeNodesForFiberID: i01,
            flushInitialOperations: mE1,
            getBestMatchForTrackedPath: XU1,
            getComponentStackForFiber: I21,
            getSourceForFiber: XG,
            getDisplayNameForFiberID: Bc,
            getFiberForNative: cE1,
            getFiberIDForNative: Qc,
            getInstanceAndStyle: iE1,
            getOwnersList: lE1,
            getPathForElement: FU1,
            getProfilingData: BU1,
            handleCommitFiberRoot: pE1,
            handleCommitFiberUnmount: dE1,
            handlePostCommitFiberRoot: uE1,
            hasFiberWithId: CU1,
            inspectElement: oE1,
            logElementToConsole: vq,
            patchConsoleForStrictMode: WE1,
            prepareViewAttributeSource: eQ,
            prepareViewElementSource: JZ,
            overrideError: GU1,
            overrideSuspense: YU1,
            overrideValueAtPath: AU1,
            renamePath: eE1,
            renderer: b,
            setTraceUpdatesEnabled: VU1,
            setTrackedPath: A21,
            startProfiling: t01,
            stopProfiling: QU1,
            storeAsGlobal: sE1,
            unpatchConsoleForStrictMode: bp,
            updateComponentFilters: b8
          }
        }

        function x5(M) {
          return yA(M) || wQ(M) || hA(M) || YI()
        }

        function YI() {
          throw new TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
        }

        function wQ(M) {
          if (typeof Symbol !== "undefined" && Symbol.iterator in Object(M)) return Array.from(M)
        }

        function yA(M) {
          if (Array.isArray(M)) return l0(M)
        }

        function EA(M, f) {
          var b;
          if (typeof Symbol === "undefined" || M[Symbol.iterator] == null) {
            if (Array.isArray(M) || (b = hA(M)) || f && M && typeof M.length === "number") {
              if (b) M = b;
              var p = 0,
                c = function $1() {};
              return {
                s: c,
                n: function $1() {
                  if (p >= M.length) return {
                    done: !0
                  };
                  return {
                    done: !1,
                    value: M[p++]
                  }
                },
                e: function $1(s1) {
                  throw s1
                },
                f: c
              }
            }
            throw new TypeError(`Invalid attempt to iterate non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
          }
          var q1 = !0,
            m1 = !1,
            l1;
          return {
            s: function $1() {
              b = M[Symbol.iterator]()
            },
            n: function $1() {
              var s1 = b.next();
              return q1 = s1.done, s1
            },
            e: function $1(s1) {
              m1 = !0, l1 = s1
            },
            f: function $1() {
              try {
                if (!q1 && b.return != null) b.return()
              } finally {
                if (m1) throw l1
              }
            }
          }
        }

        function hA(M, f) {
          if (!M) return;
          if (typeof M === "string") return l0(M, f);
          var b = Object.prototype.toString.call(M).slice(8, -1);
          if (b === "Object" && M.constructor) b = M.constructor.name;
          if (b === "Map" || b === "Set") return Array.from(M);
          if (b === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(b)) return l0(M, f)
        }

        function l0(M, f) {
          if (f == null || f > M.length) f = M.length;
          for (var b = 0, p = new Array(f); b < f; b++) p[b] = M[b];
          return p
        }
        var t2 = ["error", "trace", "warn"],
          M0 = /\s{4}(in|at)\s{1}/,
          l9 = /:\d+:\d+(\n|$)/;

        function W6(M) {
          return M0.test(M) || l9.test(M)
        }
        var f8 = /^%c/;

        function J6(M) {
          return M.length >= 2 && M[0] === BA
        }
        var KD = / \(\<anonymous\>\)$|\@unknown\:0\:0$|\(|\)|\[|\]/gm;

        function Xk(M, f) {
          return M.replace(KD, "") === f.replace(KD, "")
        }

        function WI(M) {
          if (!J6(M)) return M.slice();
          return M.slice(1)
        }
        var V01 = new Map,
          CY = console,
          Vk = {};
        for (var C01 in console) Vk[C01] = console[C01];
        var Sq = null;

        function m2A(M) {
          CY = M, Vk = {};
          for (var f in CY) Vk[f] = console[f]
        }

        function K01(M, f) {
          var {
            currentDispatcherRef: b,
            getCurrentFiber: p,
            findFiberByHostInstance: c,
            version: q1
          } = M;
          if (typeof c !== "function") return;
          if (b != null && typeof p === "function") {
            var m1 = F0(q1),
              l1 = m1.ReactTypeOfWork;
            V01.set(M, {
              currentDispatcherRef: b,
              getCurrentFiber: p,
              workTagMap: l1,
              onErrorOrWarning: f
            })
          }
        }
        var TF = {
          appendComponentStack: !1,
          breakOnConsoleErrors: !1,
          showInlineWarningsAndErrors: !1,
          hideConsoleLogsInStrictMode: !1,
          browserTheme: "dark"
        };

        function PF(M) {
          var {
            appendComponentStack: f,
            breakOnConsoleErrors: b,
            showInlineWarningsAndErrors: p,
            hideConsoleLogsInStrictMode: c,
            browserTheme: q1
          } = M;
          if (TF.appendComponentStack = f, TF.breakOnConsoleErrors = b, TF.showInlineWarningsAndErrors = p, TF.hideConsoleLogsInStrictMode = c, TF.browserTheme = q1, f || b || p) {
            if (Sq !== null) return;
            var m1 = {};
            Sq = function l1() {
              for (var $1 in m1) try {
                CY[$1] = m1[$1]
              } catch (s1) {}
            }, t2.forEach(function(l1) {
              try {
                var $1 = m1[l1] = CY[l1].__REACT_DEVTOOLS_ORIGINAL_METHOD__ ? CY[l1].__REACT_DEVTOOLS_ORIGINAL_METHOD__ : CY[l1],
                  s1 = function XA() {
                    var jA = !1;
                    for (var wA = arguments.length, pA = new Array(wA), W0 = 0; W0 < wA; W0++) pA[W0] = arguments[W0];
                    if (l1 !== "log" && TF.appendComponentStack) {
                      var E2 = pA.length > 0 ? pA[pA.length - 1] : null;
                      jA = typeof E2 === "string" && W6(E2)
                    }
                    var N0 = TF.showInlineWarningsAndErrors && (l1 === "error" || l1 === "warn"),
                      m2 = EA(V01.values()),
                      K4;
                    try {
                      for (m2.s(); !(K4 = m2.n()).done;) {
                        var E6 = K4.value,
                          D2 = j1(E6),
                          m4 = E6.getCurrentFiber,
                          U6 = E6.onErrorOrWarning,
                          H4 = E6.workTagMap,
                          a6 = m4();
                        if (a6 != null) try {
                          if (N0) {
                            if (typeof U6 === "function") U6(a6, l1, WI(pA))
                          }
                          if (TF.appendComponentStack && !Dk(a6)) {
                            var f5 = iW(H4, a6, D2);
                            if (f5 !== "") {
                              var E8 = new Error("");
                              if (E8.name = "Component Stack", E8.stack = "Error Component Stack:" + f5, jA) {
                                if (J6(pA));
                                else if (Xk(pA[pA.length - 1], f5)) {
                                  var O4 = pA[0];
                                  if (pA.length > 1 && typeof O4 === "string" && O4.endsWith("%s")) pA[0] = O4.slice(0, O4.length - 2);
                                  pA[pA.length - 1] = E8
                                }
                              } else if (pA.push(E8), J6(pA)) pA[0] = HA
                            }
                          }
                        } catch (U5) {
                          setTimeout(function() {
                            throw U5
                          }, 0)
                        } finally {
                          break
                        }
                      }
                    } catch (U5) {
                      m2.e(U5)
                    } finally {
                      m2.f()
                    }
                    if (TF.breakOnConsoleErrors) debugger;
                    $1.apply(void 0, pA)
                  };
                s1.__REACT_DEVTOOLS_ORIGINAL_METHOD__ = $1, $1.__REACT_DEVTOOLS_OVERRIDE_METHOD__ = s1, CY[l1] = s1
              } catch (XA) {}
            })
          } else DG()
        }

        function DG() {
          if (Sq !== null) Sq(), Sq = null
        }
        var ZU = null;

        function WE1() {
          var M = ["error", "group", "groupCollapsed", "info", "log", "trace", "warn"];
          if (ZU !== null) return;
          var f = {};
          ZU = function b() {
            for (var p in f) try {
              CY[p] = f[p]
            } catch (c) {}
          }, M.forEach(function(b) {
            try {
              var p = f[b] = CY[b].__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ ? CY[b].__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ : CY[b],
                c = function q1() {
                  if (!TF.hideConsoleLogsInStrictMode) {
                    for (var m1 = arguments.length, l1 = new Array(m1), $1 = 0; $1 < m1; $1++) l1[$1] = arguments[$1];
                    p.apply(void 0, [BA].concat(x5(yp.apply(void 0, l1))))
                  }
                };
              c.__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ = p, p.__REACT_DEVTOOLS_STRICT_MODE_OVERRIDE_METHOD__ = c, CY[b] = c
            } catch (q1) {}
          })
        }

        function bp() {
          if (ZU !== null) ZU(), ZU = null
        }

        function H01() {
          var M, f, b, p, c, q1 = (M = iQ(window.__REACT_DEVTOOLS_APPEND_COMPONENT_STACK__)) !== null && M !== void 0 ? M : !0,
            m1 = (f = iQ(window.__REACT_DEVTOOLS_BREAK_ON_CONSOLE_ERRORS__)) !== null && f !== void 0 ? f : !1,
            l1 = (b = iQ(window.__REACT_DEVTOOLS_SHOW_INLINE_WARNINGS_AND_ERRORS__)) !== null && b !== void 0 ? b : !0,
            $1 = (p = iQ(window.__REACT_DEVTOOLS_HIDE_CONSOLE_LOGS_IN_STRICT_MODE__)) !== null && p !== void 0 ? p : !1,
            s1 = (c = YD(window.__REACT_DEVTOOLS_BROWSER_THEME__)) !== null && c !== void 0 ? c : "dark";
          PF({
            appendComponentStack: q1,
            breakOnConsoleErrors: m1,
            showInlineWarningsAndErrors: l1,
            hideConsoleLogsInStrictMode: $1,
            browserTheme: s1
          })
        }

        function JE1(M) {
          window.__REACT_DEVTOOLS_APPEND_COMPONENT_STACK__ = M.appendComponentStack, window.__REACT_DEVTOOLS_BREAK_ON_CONSOLE_ERRORS__ = M.breakOnConsoleErrors, window.__REACT_DEVTOOLS_SHOW_INLINE_WARNINGS_AND_ERRORS__ = M.showInlineWarningsAndErrors, window.__REACT_DEVTOOLS_HIDE_CONSOLE_LOGS_IN_STRICT_MODE__ = M.hideConsoleLogsInStrictMode, window.__REACT_DEVTOOLS_BROWSER_THEME__ = M.browserTheme
        }

        function oT() {
          window.__REACT_DEVTOOLS_CONSOLE_FUNCTIONS__ = {
            patchConsoleUsingWindowValues: H01,
            registerRendererWithConsole: K01
          }
        }

        function tT(M) {
          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") tT = function f(b) {
            return typeof b
          };
          else tT = function f(b) {
            return b && typeof Symbol === "function" && b.constructor === Symbol && b !== Symbol.prototype ? "symbol" : typeof b
          };
          return tT(M)
        }

        function z01(M) {
          return CE1(M) || VE1(M) || XE1(M) || FE1()
        }

        function FE1() {
          throw new TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
        }

        function XE1(M, f) {
          if (!M) return;
          if (typeof M === "string") return Ck(M, f);
          var b = Object.prototype.toString.call(M).slice(8, -1);
          if (b === "Object" && M.constructor) b = M.constructor.name;
          if (b === "Map" || b === "Set") return Array.from(M);
          if (b === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(b)) return Ck(M, f)
        }

        function VE1(M) {
          if (typeof Symbol !== "undefined" && Symbol.iterator in Object(M)) return Array.from(M)
        }

        function CE1(M) {
          if (Array.isArray(M)) return Ck(M)
        }

        function Ck(M, f) {
          if (f == null || f > M.length) f = M.length;
          for (var b = 0, p = new Array(f); b < f; b++) p[b] = M[b];
          return p
        }

        function w01(M, f) {
          if (!(M instanceof f)) throw new TypeError("Cannot call a class as a function")
        }

        function E01(M, f) {
          for (var b = 0; b < f.length; b++) {
            var p = f[b];
            if (p.enumerable = p.enumerable || !1, p.configurable = !0, "value" in p) p.writable = !0;
            Object.defineProperty(M, p.key, p)
          }
        }

        function gp(M, f, b) {
          if (f) E01(M.prototype, f);
          if (b) E01(M, b);
          return M
        }

        function U01(M, f) {
          if (typeof f !== "function" && f !== null) throw new TypeError("Super expression must either be null or a function");
          if (M.prototype = Object.create(f && f.prototype, {
              constructor: {
                value: M,
                writable: !0,
                configurable: !0
              }
            }), f) DU(M, f)
        }

        function DU(M, f) {
          return DU = Object.setPrototypeOf || function b(p, c) {
            return p.__proto__ = c, p
          }, DU(M, f)
        }

        function hp(M) {
          var f = Kk();
          return function b() {
            var p = eT(M),
              c;
            if (f) {
              var q1 = eT(this).constructor;
              c = Reflect.construct(p, arguments, q1)
            } else c = p.apply(this, arguments);
            return N01(this, c)
          }
        }

        function N01(M, f) {
          if (f && (tT(f) === "object" || typeof f === "function")) return f;
          return mV(M)
        }

        function mV(M) {
          if (M === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
          return M
        }

        function Kk() {
          if (typeof Reflect === "undefined" || !Reflect.construct) return !1;
          if (Reflect.construct.sham) return !1;
          if (typeof Proxy === "function") return !0;
          try {
            return Date.prototype.toString.call(Reflect.construct(Date, [], function() {})), !0
          } catch (M) {
            return !1
          }
        }

        function eT(M) {
          return eT = Object.setPrototypeOf ? Object.getPrototypeOf : function f(b) {
            return b.__proto__ || Object.getPrototypeOf(b)
          }, eT(M)
        }

        function YG(M, f, b) {
          if (f in M) Object.defineProperty(M, f, {
            value: b,
            enumerable: !0,
            configurable: !0,
            writable: !0
          });
          else M[f] = b;
          return M
        }
        var YU = 100,
          $01 = [{
            version: 0,
            minNpmVersion: '"<4.11.0"',
            maxNpmVersion: '"<4.11.0"'
          }, {
            version: 1,
            minNpmVersion: "4.13.0",
            maxNpmVersion: "4.21.0"
          }, {
            version: 2,
            minNpmVersion: "4.22.0",
            maxNpmVersion: null
          }],
          mp = $01[$01.length - 1],
          KE1 = function(M) {
            U01(b, M);
            var f = hp(b);

            function b(p) {
              var c;
              return w01(this, b), c = f.call(this), YG(mV(c), "_isShutdown", !1), YG(mV(c), "_messageQueue", []), YG(mV(c), "_timeoutID", null), YG(mV(c), "_wallUnlisten", null), YG(mV(c), "_flush", function() {
                if (c._timeoutID !== null) clearTimeout(c._timeoutID), c._timeoutID = null;
                if (c._messageQueue.length) {
                  for (var q1 = 0; q1 < c._messageQueue.length; q1 += 2) {
                    var m1;
                    (m1 = c._wall).send.apply(m1, [c._messageQueue[q1]].concat(z01(c._messageQueue[q1 + 1])))
                  }
                  c._messageQueue.length = 0, c._timeoutID = setTimeout(c._flush, YU)
                }
              }), YG(mV(c), "overrideValueAtPath", function(q1) {
                var {
                  id: m1,
                  path: l1,
                  rendererID: $1,
                  type: s1,
                  value: XA
                } = q1;
                switch (s1) {
                  case "context":
                    c.send("overrideContext", {
                      id: m1,
                      path: l1,
                      rendererID: $1,
                      wasForwarded: !0,
                      value: XA
                    });
                    break;
                  case "hooks":
                    c.send("overrideHookState", {
                      id: m1,
                      path: l1,
                      rendererID: $1,
                      wasForwarded: !0,
                      value: XA
                    });
                    break;
                  case "props":
                    c.send("overrideProps", {
                      id: m1,
                      path: l1,
                      rendererID: $1,
                      wasForwarded: !0,
                      value: XA
                    });
                    break;
                  case "state":
                    c.send("overrideState", {
                      id: m1,
                      path: l1,
                      rendererID: $1,
                      wasForwarded: !0,
                      value: XA
                    });
                    break
                }
              }), c._wall = p, c._wallUnlisten = p.listen(function(q1) {
                if (q1 && q1.event) mV(c).emit(q1.event, q1.payload)
              }) || null, c.addListener("overrideValueAtPath", c.overrideValueAtPath), c
            }
            return gp(b, [{
              key: "send",
              value: function p(c) {
                if (this._isShutdown) {
                  console.warn('Cannot send message "'.concat(c, '" through a Bridge that has been shutdown.'));
                  return
                }
                for (var q1 = arguments.length, m1 = new Array(q1 > 1 ? q1 - 1 : 0), l1 = 1; l1 < q1; l1++) m1[l1 - 1] = arguments[l1];
                if (this._messageQueue.push(c, m1), !this._timeoutID) this._timeoutID = setTimeout(this._flush, 0)
              }
            }, {
              key: "shutdown",
              value: function p() {
                if (this._isShutdown) {
                  console.warn("Bridge was already shutdown.");
                  return
                }
                this.emit("shutdown"), this.send("shutdown"), this._isShutdown = !0, this.addListener = function() {}, this.emit = function() {}, this.removeAllListeners();
                var c = this._wallUnlisten;
                if (c) c();
                do this._flush(); while (this._messageQueue.length);
                if (this._timeoutID !== null) clearTimeout(this._timeoutID), this._timeoutID = null
              }
            }, {
              key: "wall",
              get: function p() {
                return this._wall
              }
            }]), b
          }(W);
        let q01 = KE1;

        function Hk(M) {
          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") Hk = function f(b) {
            return typeof b
          };
          else Hk = function f(b) {
            return b && typeof Symbol === "function" && b.constructor === Symbol && b !== Symbol.prototype ? "symbol" : typeof b
          };
          return Hk(M)
        }

        function HE1(M, f) {
          if (!(M instanceof f)) throw new TypeError("Cannot call a class as a function")
        }

        function M01(M, f) {
          for (var b = 0; b < f.length; b++) {
            var p = f[b];
            if (p.enumerable = p.enumerable || !1, p.configurable = !0, "value" in p) p.writable = !0;
            Object.defineProperty(M, p.key, p)
          }
        }

        function zE1(M, f, b) {
          if (f) M01(M.prototype, f);
          if (b) M01(M, b);
          return M
        }

        function wE1(M, f) {
          if (typeof f !== "function" && f !== null) throw new TypeError("Super expression must either be null or a function");
          if (M.prototype = Object.create(f && f.prototype, {
              constructor: {
                value: M,
                writable: !0,
                configurable: !0
              }
            }), f) dp(M, f)
        }

        function dp(M, f) {
          return dp = Object.setPrototypeOf || function b(p, c) {
            return p.__proto__ = c, p
          }, dp(M, f)
        }

        function EE1(M) {
          var f = L01();
          return function b() {
            var p = AP(M),
              c;
            if (f) {
              var q1 = AP(this).constructor;
              c = Reflect.construct(p, arguments, q1)
            } else c = p.apply(this, arguments);
            return UE1(this, c)
          }
        }

        function UE1(M, f) {
          if (f && (Hk(f) === "object" || typeof f === "function")) return f;
          return C4(M)
        }

        function C4(M) {
          if (M === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
          return M
        }

        function L01() {
          if (typeof Reflect === "undefined" || !Reflect.construct) return !1;
          if (Reflect.construct.sham) return !1;
          if (typeof Proxy === "function") return !0;
          try {
            return Date.prototype.toString.call(Reflect.construct(Date, [], function() {})), !0
          } catch (M) {
            return !1
          }
        }

        function AP(M) {
          return AP = Object.setPrototypeOf ? Object.getPrototypeOf : function f(b) {
            return b.__proto__ || Object.getPrototypeOf(b)
          }, AP(M)
        }

        function N4(M, f, b) {
          if (f in M) Object.defineProperty(M, f, {
            value: b,
            enumerable: !0,
            configurable: !0,
            writable: !0
          });
          else M[f] = b;
          return M
        }
        var R01 = function M(f) {
            if (K) {
              var b;
              for (var p = arguments.length, c = new Array(p > 1 ? p - 1 : 0), q1 = 1; q1 < p; q1++) c[q1 - 1] = arguments[q1];
              (b = console).log.apply(b, ["%cAgent %c".concat(f), "color: purple; font-weight: bold;", "font-weight: bold;"].concat(c))
            }
          },
          O01 = function(M) {
            wE1(b, M);
            var f = EE1(b);

            function b(p) {
              var c;
              if (HE1(this, b), c = f.call(this), N4(C4(c), "_isProfiling", !1), N4(C4(c), "_recordChangeDescriptions", !1), N4(C4(c), "_rendererInterfaces", {}), N4(C4(c), "_persistedSelection", null), N4(C4(c), "_persistedSelectionMatch", null), N4(C4(c), "_traceUpdatesEnabled", !1), N4(C4(c), "clearErrorsAndWarnings", function($1) {
                  var s1 = $1.rendererID,
                    XA = c._rendererInterfaces[s1];
                  if (XA == null) console.warn('Invalid renderer id "'.concat(s1, '"'));
                  else XA.clearErrorsAndWarnings()
                }), N4(C4(c), "clearErrorsForFiberID", function($1) {
                  var {
                    id: s1,
                    rendererID: XA
                  } = $1, jA = c._rendererInterfaces[XA];
                  if (jA == null) console.warn('Invalid renderer id "'.concat(XA, '"'));
                  else jA.clearErrorsForFiberID(s1)
                }), N4(C4(c), "clearWarningsForFiberID", function($1) {
                  var {
                    id: s1,
                    rendererID: XA
                  } = $1, jA = c._rendererInterfaces[XA];
                  if (jA == null) console.warn('Invalid renderer id "'.concat(XA, '"'));
                  else jA.clearWarningsForFiberID(s1)
                }), N4(C4(c), "copyElementPath", function($1) {
                  var {
                    id: s1,
                    path: XA,
                    rendererID: jA
                  } = $1, wA = c._rendererInterfaces[jA];
                  if (wA == null) console.warn('Invalid renderer id "'.concat(jA, '" for element "').concat(s1, '"'));
                  else {
                    var pA = wA.getSerializedElementValueByPath(s1, XA);
                    if (pA != null) c._bridge.send("saveToClipboard", pA);
                    else console.warn('Unable to obtain serialized value for element "'.concat(s1, '"'))
                  }
                }), N4(C4(c), "deletePath", function($1) {
                  var {
                    hookID: s1,
                    id: XA,
                    path: jA,
                    rendererID: wA,
                    type: pA
                  } = $1, W0 = c._rendererInterfaces[wA];
                  if (W0 == null) console.warn('Invalid renderer id "'.concat(wA, '" for element "').concat(XA, '"'));
                  else W0.deletePath(pA, XA, s1, jA)
                }), N4(C4(c), "getBackendVersion", function() {
                  var $1 = "5.3.2-c82bcbeb2b";
                  if ($1) c._bridge.send("backendVersion", $1)
                }), N4(C4(c), "getBridgeProtocol", function() {
                  c._bridge.send("bridgeProtocol", mp)
                }), N4(C4(c), "getProfilingData", function($1) {
                  var s1 = $1.rendererID,
                    XA = c._rendererInterfaces[s1];
                  if (XA == null) console.warn('Invalid renderer id "'.concat(s1, '"'));
                  c._bridge.send("profilingData", XA.getProfilingData())
                }), N4(C4(c), "getProfilingStatus", function() {
                  c._bridge.send("profilingStatus", c._isProfiling)
                }), N4(C4(c), "getOwnersList", function($1) {
                  var {
                    id: s1,
                    rendererID: XA
                  } = $1, jA = c._rendererInterfaces[XA];
                  if (jA == null) console.warn('Invalid renderer id "'.concat(XA, '" for element "').concat(s1, '"'));
                  else {
                    var wA = jA.getOwnersList(s1);
                    c._bridge.send("ownersList", {
                      id: s1,
                      owners: wA
                    })
                  }
                }), N4(C4(c), "inspectElement", function($1) {
                  var {
                    forceFullData: s1,
                    id: XA,
                    path: jA,
                    rendererID: wA,
                    requestID: pA
                  } = $1, W0 = c._rendererInterfaces[wA];
                  if (W0 == null) console.warn('Invalid renderer id "'.concat(wA, '" for element "').concat(XA, '"'));
                  else if (c._bridge.send("inspectedElement", W0.inspectElement(pA, XA, jA, s1)), c._persistedSelectionMatch === null || c._persistedSelectionMatch.id !== XA) c._persistedSelection = null, c._persistedSelectionMatch = null, W0.setTrackedPath(null), c._throttledPersistSelection(wA, XA)
                }), N4(C4(c), "logElementToConsole", function($1) {
                  var {
                    id: s1,
                    rendererID: XA
                  } = $1, jA = c._rendererInterfaces[XA];
                  if (jA == null) console.warn('Invalid renderer id "'.concat(XA, '" for element "').concat(s1, '"'));
                  else jA.logElementToConsole(s1)
                }), N4(C4(c), "overrideError", function($1) {
                  var {
                    id: s1,
                    rendererID: XA,
                    forceError: jA
                  } = $1, wA = c._rendererInterfaces[XA];
                  if (wA == null) console.warn('Invalid renderer id "'.concat(XA, '" for element "').concat(s1, '"'));
                  else wA.overrideError(s1, jA)
                }), N4(C4(c), "overrideSuspense", function($1) {
                  var {
                    id: s1,
                    rendererID: XA,
                    forceFallback: jA
                  } = $1, wA = c._rendererInterfaces[XA];
                  if (wA == null) console.warn('Invalid renderer id "'.concat(XA, '" for element "').concat(s1, '"'));
                  else wA.overrideSuspense(s1, jA)
                }), N4(C4(c), "overrideValueAtPath", function($1) {
                  var {
                    hookID: s1,
                    id: XA,
                    path: jA,
                    rendererID: wA,
                    type: pA,
                    value: W0
                  } = $1, E2 = c._rendererInterfaces[wA];
                  if (E2 == null) console.warn('Invalid renderer id "'.concat(wA, '" for element "').concat(XA, '"'));
                  else E2.overrideValueAtPath(pA, XA, s1, jA, W0)
                }), N4(C4(c), "overrideContext", function($1) {
                  var {
                    id: s1,
                    path: XA,
                    rendererID: jA,
                    wasForwarded: wA,
                    value: pA
                  } = $1;
                  if (!wA) c.overrideValueAtPath({
                    id: s1,
                    path: XA,
                    rendererID: jA,
                    type: "context",
                    value: pA
                  })
                }), N4(C4(c), "overrideHookState", function($1) {
                  var {
                    id: s1,
                    hookID: XA,
                    path: jA,
                    rendererID: wA,
                    wasForwarded: pA,
                    value: W0
                  } = $1;
                  if (!pA) c.overrideValueAtPath({
                    id: s1,
                    path: jA,
                    rendererID: wA,
                    type: "hooks",
                    value: W0
                  })
                }), N4(C4(c), "overrideProps", function($1) {
                  var {
                    id: s1,
                    path: XA,
                    rendererID: jA,
                    wasForwarded: wA,
                    value: pA
                  } = $1;
                  if (!wA) c.overrideValueAtPath({
                    id: s1,
                    path: XA,
                    rendererID: jA,
                    type: "props",
                    value: pA
                  })
                }), N4(C4(c), "overrideState", function($1) {
                  var {
                    id: s1,
                    path: XA,
                    rendererID: jA,
                    wasForwarded: wA,
                    value: pA
                  } = $1;
                  if (!wA) c.overrideValueAtPath({
                    id: s1,
                    path: XA,
                    rendererID: jA,
                    type: "state",
                    value: pA
                  })
                }), N4(C4(c), "reloadAndProfile", function($1) {
                  P1(N1, "true"), P1(D1, $1 ? "true" : "false"), c._bridge.send("reloadAppForProfiling")
                }), N4(C4(c), "renamePath", function($1) {
                  var {
                    hookID: s1,
                    id: XA,
                    newPath: jA,
                    oldPath: wA,
                    rendererID: pA,
                    type: W0
                  } = $1, E2 = c._rendererInterfaces[pA];
                  if (E2 == null) console.warn('Invalid renderer id "'.concat(pA, '" for element "').concat(XA, '"'));
                  else E2.renamePath(W0, XA, s1, wA, jA)
                }), N4(C4(c), "setTraceUpdatesEnabled", function($1) {
                  c._traceUpdatesEnabled = $1, xp($1);
                  for (var s1 in c._rendererInterfaces) {
                    var XA = c._rendererInterfaces[s1];
                    XA.setTraceUpdatesEnabled($1)
                  }
                }), N4(C4(c), "syncSelectionFromNativeElementsPanel", function() {
                  var $1 = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0;
                  if ($1 == null) return;
                  c.selectNode($1)
                }), N4(C4(c), "shutdown", function() {
                  c.emit("shutdown")
                }), N4(C4(c), "startProfiling", function($1) {
                  c._recordChangeDescriptions = $1, c._isProfiling = !0;
                  for (var s1 in c._rendererInterfaces) {
                    var XA = c._rendererInterfaces[s1];
                    XA.startProfiling($1)
                  }
                  c._bridge.send("profilingStatus", c._isProfiling)
                }), N4(C4(c), "stopProfiling", function() {
                  c._isProfiling = !1, c._recordChangeDescriptions = !1;
                  for (var $1 in c._rendererInterfaces) {
                    var s1 = c._rendererInterfaces[$1];
                    s1.stopProfiling()
                  }
                  c._bridge.send("profilingStatus", c._isProfiling)
                }), N4(C4(c), "stopInspectingNative", function($1) {
                  c._bridge.send("stopInspectingNative", $1)
                }), N4(C4(c), "storeAsGlobal", function($1) {
                  var {
                    count: s1,
                    id: XA,
                    path: jA,
                    rendererID: wA
                  } = $1, pA = c._rendererInterfaces[wA];
                  if (pA == null) console.warn('Invalid renderer id "'.concat(wA, '" for element "').concat(XA, '"'));
                  else pA.storeAsGlobal(XA, jA, s1)
                }), N4(C4(c), "updateConsolePatchSettings", function($1) {
                  var {
                    appendComponentStack: s1,
                    breakOnConsoleErrors: XA,
                    showInlineWarningsAndErrors: jA,
                    hideConsoleLogsInStrictMode: wA,
                    browserTheme: pA
                  } = $1;
                  PF({
                    appendComponentStack: s1,
                    breakOnConsoleErrors: XA,
                    showInlineWarningsAndErrors: jA,
                    hideConsoleLogsInStrictMode: wA,
                    browserTheme: pA
                  })
                }), N4(C4(c), "updateComponentFilters", function($1) {
                  for (var s1 in c._rendererInterfaces) {
                    var XA = c._rendererInterfaces[s1];
                    XA.updateComponentFilters($1)
                  }
                }), N4(C4(c), "viewAttributeSource", function($1) {
                  var {
                    id: s1,
                    path: XA,
                    rendererID: jA
                  } = $1, wA = c._rendererInterfaces[jA];
                  if (wA == null) console.warn('Invalid renderer id "'.concat(jA, '" for element "').concat(s1, '"'));
                  else wA.prepareViewAttributeSource(s1, XA)
                }), N4(C4(c), "viewElementSource", function($1) {
                  var {
                    id: s1,
                    rendererID: XA
                  } = $1, jA = c._rendererInterfaces[XA];
                  if (jA == null) console.warn('Invalid renderer id "'.concat(XA, '" for element "').concat(s1, '"'));
                  else jA.prepareViewElementSource(s1)
                }), N4(C4(c), "onTraceUpdates", function($1) {
                  c.emit("traceUpdates", $1)
                }), N4(C4(c), "onFastRefreshScheduled", function() {
                  if (K) R01("onFastRefreshScheduled");
                  c._bridge.send("fastRefreshScheduled")
                }), N4(C4(c), "onHookOperations", function($1) {
                  if (K) R01("onHookOperations", "(".concat($1.length, ") [").concat($1.join(", "), "]"));
                  if (c._bridge.send("operations", $1), c._persistedSelection !== null) {
                    var s1 = $1[0];
                    if (c._persistedSelection.rendererID === s1) {
                      var XA = c._rendererInterfaces[s1];
                      if (XA == null) console.warn('Invalid renderer id "'.concat(s1, '"'));
                      else {
                        var jA = c._persistedSelectionMatch,
                          wA = XA.getBestMatchForTrackedPath();
                        c._persistedSelectionMatch = wA;
                        var pA = jA !== null ? jA.id : null,
                          W0 = wA !== null ? wA.id : null;
                        if (pA !== W0) {
                          if (W0 !== null) c._bridge.send("selectFiber", W0)
                        }
                        if (wA !== null && wA.isFullMatch) c._persistedSelection = null, c._persistedSelectionMatch = null, XA.setTrackedPath(null)
                      }
                    }
                  }
                }), N4(C4(c), "_throttledPersistSelection", F()(function($1, s1) {
                  var XA = c._rendererInterfaces[$1],
                    jA = XA != null ? XA.getPathForElement(s1) : null;
                  if (jA !== null) P1(d, JSON.stringify({
                    rendererID: $1,
                    path: jA
                  }));
                  else w1(d)
                }, 1000)), W1(N1) === "true") c._recordChangeDescriptions = W1(D1) === "true", c._isProfiling = !0, w1(D1), w1(N1);
              var q1 = W1(d);
              if (q1 != null) c._persistedSelection = JSON.parse(q1);
              if (c._bridge = p, p.addListener("clearErrorsAndWarnings", c.clearErrorsAndWarnings), p.addListener("clearErrorsForFiberID", c.clearErrorsForFiberID), p.addListener("clearWarningsForFiberID", c.clearWarningsForFiberID), p.addListener("copyElementPath", c.copyElementPath), p.addListener("deletePath", c.deletePath), p.addListener("getBackendVersion", c.getBackendVersion), p.addListener("getBridgeProtocol", c.getBridgeProtocol), p.addListener("getProfilingData", c.getProfilingData), p.addListener("getProfilingStatus", c.getProfilingStatus), p.addListener("getOwnersList", c.getOwnersList), p.addListener("inspectElement", c.inspectElement), p.addListener("logElementToConsole", c.logElementToConsole), p.addListener("overrideError", c.overrideError), p.addListener("overrideSuspense", c.overrideSuspense), p.addListener("overrideValueAtPath", c.overrideValueAtPath), p.addListener("reloadAndProfile", c.reloadAndProfile), p.addListener("renamePath", c.renamePath), p.addListener("setTraceUpdatesEnabled", c.setTraceUpdatesEnabled), p.addListener("startProfiling", c.startProfiling), p.addListener("stopProfiling", c.stopProfiling), p.addListener("storeAsGlobal", c.storeAsGlobal), p.addListener("syncSelectionFromNativeElementsPanel", c.syncSelectionFromNativeElementsPanel), p.addListener("shutdown", c.shutdown), p.addListener("updateConsolePatchSettings", c.updateConsolePatchSettings), p.addListener("updateComponentFilters", c.updateComponentFilters), p.addListener("viewAttributeSource", c.viewAttributeSource), p.addListener("viewElementSource", c.viewElementSource), p.addListener("overrideContext", c.overrideContext), p.addListener("overrideHookState", c.overrideHookState), p.addListener("overrideProps", c.overrideProps), p.addListener("overrideState", c.overrideState), c._isProfiling) p.send("profilingStatus", !0);
              var m1 = "5.3.2-c82bcbeb2b";
              if (m1) c._bridge.send("backendVersion", m1);
              c._bridge.send("bridgeProtocol", mp);
              var l1 = !1;
              try {
                localStorage.getItem("test"), l1 = !0
              } catch ($1) {}
              return p.send("isBackendStorageAPISupported", l1), p.send("isSynchronousXHRSupported", z3()), jT(p, C4(c)), CQ(C4(c)), c
            }
            return zE1(b, [{
              key: "getInstanceAndStyle",
              value: function p(c) {
                var {
                  id: q1,
                  rendererID: m1
                } = c, l1 = this._rendererInterfaces[m1];
                if (l1 == null) return console.warn('Invalid renderer id "'.concat(m1, '"')), null;
                return l1.getInstanceAndStyle(q1)
              }
            }, {
              key: "getBestMatchingRendererInterface",
              value: function p(c) {
                var q1 = null;
                for (var m1 in this._rendererInterfaces) {
                  var l1 = this._rendererInterfaces[m1],
                    $1 = l1.getFiberForNative(c);
                  if ($1 !== null) {
                    if ($1.stateNode === c) return l1;
                    else if (q1 === null) q1 = l1
                  }
                }
                return q1
              }
            }, {
              key: "getIDForNode",
              value: function p(c) {
                var q1 = this.getBestMatchingRendererInterface(c);
                if (q1 != null) try {
                  return q1.getFiberIDForNative(c, !0)
                } catch (m1) {}
                return null
              }
            }, {
              key: "selectNode",
              value: function p(c) {
                var q1 = this.getIDForNode(c);
                if (q1 !== null) this._bridge.send("selectFiber", q1)
              }
            }, {
              key: "setRendererInterface",
              value: function p(c, q1) {
                if (this._rendererInterfaces[c] = q1, this._isProfiling) q1.startProfiling(this._recordChangeDescriptions);
                q1.setTraceUpdatesEnabled(this._traceUpdatesEnabled);
                var m1 = this._persistedSelection;
                if (m1 !== null && m1.rendererID === c) q1.setTrackedPath(m1.path)
              }
            }, {
              key: "onUnsupportedRenderer",
              value: function p(c) {
                this._bridge.send("unsupportedRendererVersion", c)
              }
            }, {
              key: "rendererInterfaces",
              get: function p() {
                return this._rendererInterfaces
              }
            }]), b
          }(W);

        function up(M, f) {
          return $E1(M) || NE1(M, f) || P01(M, f) || T01()
        }

        function T01() {
          throw new TypeError(`Invalid attempt to destructure non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
        }

        function NE1(M, f) {
          if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(M))) return;
          var b = [],
            p = !0,
            c = !1,
            q1 = void 0;
          try {
            for (var m1 = M[Symbol.iterator](), l1; !(p = (l1 = m1.next()).done); p = !0)
              if (b.push(l1.value), f && b.length === f) break
          } catch ($1) {
            c = !0, q1 = $1
          } finally {
            try {
              if (!p && m1.return != null) m1.return()
            } finally {
              if (c) throw q1
            }
          }
          return b
        }

        function $E1(M) {
          if (Array.isArray(M)) return M
        }

        function zk(M) {
          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") zk = function f(b) {
            return typeof b
          };
          else zk = function f(b) {
            return b && typeof Symbol === "function" && b.constructor === Symbol && b !== Symbol.prototype ? "symbol" : typeof b
          };
          return zk(M)
        }

        function wk(M) {
          return ME1(M) || KY(M) || P01(M) || qE1()
        }

        function qE1() {
          throw new TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)
        }

        function P01(M, f) {
          if (!M) return;
          if (typeof M === "string") return pp(M, f);
          var b = Object.prototype.toString.call(M).slice(8, -1);
          if (b === "Object" && M.constructor) b = M.constructor.name;
          if (b === "Map" || b === "Set") return Array.from(M);
          if (b === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(b)) return pp(M, f)
        }

        function KY(M) {
          if (typeof Symbol !== "undefined" && Symbol.iterator in Object(M)) return Array.from(M)
        }

        function ME1(M) {
          if (Array.isArray(M)) return pp(M)
        }

        function pp(M, f) {
          if (f == null || f > M.length) f = M.length;
          for (var b = 0, p = new Array(f); b < f; b++) p[b] = M[b];
          return p
        }

        function LE1(M) {
          if (M.hasOwnProperty("__REACT_DEVTOOLS_GLOBAL_HOOK__")) return null;
          var f = console,
            b = {};
          for (var p in console) b[p] = console[p];

          function c(b0) {
            f = b0, b = {};
            for (var O2 in f) b[O2] = console[O2]
          }

          function q1(b0) {
            try {
              if (typeof b0.version === "string") {
                if (b0.bundleType > 0) return "development";
                return "production"
              }
              var O2 = Function.prototype.toString;
              if (b0.Mount && b0.Mount._renderNewRootComponent) {
                var n2 = O2.call(b0.Mount._renderNewRootComponent);
                if (n2.indexOf("function") !== 0) return "production";
                if (n2.indexOf("storedMeasure") !== -1) return "development";
                if (n2.indexOf("should be a pure function") !== -1) {
                  if (n2.indexOf("NODE_ENV") !== -1) return "development";
                  if (n2.indexOf("development") !== -1) return "development";
                  if (n2.indexOf("true") !== -1) return "development";
                  if (n2.indexOf("nextElement") !== -1 || n2.indexOf("nextComponent") !== -1) return "unminified";
                  else return "development"
                }
                if (n2.indexOf("nextElement") !== -1 || n2.indexOf("nextComponent") !== -1) return "unminified";
                return "outdated"
              }
            } catch (e4) {}
            return "production"
          }

          function m1(b0) {
            try {
              var O2 = Function.prototype.toString,
                n2 = O2.call(b0);
              if (n2.indexOf("^_^") > -1) W0 = !0, setTimeout(function() {
                throw new Error("React is running in production mode, but dead code elimination has not been applied. Read how to correctly configure React for production: https://react.dev/link/perf-use-production-build")
              })
            } catch (e4) {}
          }

          function l1(b0, O2) {
            if (b0 === void 0 || b0 === null || b0.length === 0 || typeof b0[0] === "string" && b0[0].match(/([^%]|^)(%c)/g) || O2 === void 0) return b0;
            var n2 = /([^%]|^)((%%)*)(%([oOdisf]))/g;
            if (typeof b0[0] === "string" && b0[0].match(n2)) return ["%c".concat(b0[0]), O2].concat(wk(b0.slice(1)));
            else {
              var e4 = b0.reduce(function(g6, X5, r6) {
                if (r6 > 0) g6 += " ";
                switch (zk(X5)) {
                  case "string":
                  case "boolean":
                  case "symbol":
                    return g6 += "%s";
                  case "number":
                    var I8 = Number.isInteger(X5) ? "%i" : "%f";
                    return g6 += I8;
                  default:
                    return g6 += "%o"
                }
              }, "%c");
              return [e4, O2].concat(wk(b0))
            }
          }

          function $1(b0) {
            for (var O2 = arguments.length, n2 = new Array(O2 > 1 ? O2 - 1 : 0), e4 = 1; e4 < O2; e4++) n2[e4 - 1] = arguments[e4];
            if (n2.length === 0 || typeof b0 !== "string") return [b0].concat(n2);
            var g6 = n2.slice(),
              X5 = "",
              r6 = 0;
            for (var I8 = 0; I8 < b0.length; ++I8) {
              var EQ = b0[I8];
              if (EQ !== "%") {
                X5 += EQ;
                continue
              }
              var oQ = b0[I8 + 1];
              switch (++I8, oQ) {
                case "c":
                case "O":
                case "o": {
                  ++r6, X5 += "%".concat(oQ);
                  break
                }
                case "d":
                case "i": {
                  var _F = g6.splice(r6, 1),
                    jF = up(_F, 1),
                    yF = jF[0];
                  X5 += parseInt(yF, 10).toString();
                  break
                }
                case "f": {
                  var OH = g6.splice(r6, 1),
                    HD = up(OH, 1),
                    kF = HD[0];
                  X5 += parseFloat(kF).toString();
                  break
                }
                case "s": {
                  var JG = g6.splice(r6, 1),
                    a0 = up(JG, 1),
                    D9 = a0[0];
                  X5 += D9.toString()
                }
              }
            }
            return [X5].concat(wk(g6))
          }
          var s1 = null;

          function XA(b0) {
            var O2 = ["error", "group", "groupCollapsed", "info", "log", "trace", "warn"];
            if (s1 !== null) return;
            var n2 = {};
            s1 = function e4() {
              for (var g6 in n2) try {
                f[g6] = n2[g6]
              } catch (X5) {}
            }, O2.forEach(function(e4) {
              try {
                var g6 = n2[e4] = f[e4].__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ ? f[e4].__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ : f[e4],
                  X5 = function r6() {
                    if (!b0) {
                      for (var I8 = arguments.length, EQ = new Array(I8), oQ = 0; oQ < I8; oQ++) EQ[oQ] = arguments[oQ];
                      g6.apply(void 0, [BA].concat(wk($1.apply(void 0, EQ))))
                    }
                  };
                X5.__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ = g6, g6.__REACT_DEVTOOLS_STRICT_MODE_OVERRIDE_METHOD__ = X5, f[e4] = X5
              } catch (r6) {}
            })
          }

          function jA() {
            if (s1 !== null) s1(), s1 = null
          }
          var wA = 0;

          function pA(b0) {
            var O2 = ++wA;
            T4.set(O2, b0);
            var n2 = W0 ? "deadcode" : q1(b0);
            if (M.hasOwnProperty("__REACT_DEVTOOLS_CONSOLE_FUNCTIONS__")) {
              var e4 = M.__REACT_DEVTOOLS_CONSOLE_FUNCTIONS__,
                g6 = e4.registerRendererWithConsole,
                X5 = e4.patchConsoleUsingWindowValues;
              if (typeof g6 === "function" && typeof X5 === "function") g6(b0), X5()
            }
            var r6 = M.__REACT_DEVTOOLS_ATTACH__;
            if (typeof r6 === "function") {
              var I8 = r6(rQ, O2, b0, M);
              rQ.rendererInterfaces.set(O2, I8)
            }
            return rQ.emit("renderer", {
              id: O2,
              renderer: b0,
              reactBuildType: n2
            }), O2
          }
          var W0 = !1;

          function E2(b0, O2) {
            return rQ.on(b0, O2),
              function() {
                return rQ.off(b0, O2)
              }
          }

          function N0(b0, O2) {
            if (!s6[b0]) s6[b0] = [];
            s6[b0].push(O2)
          }

          function m2(b0, O2) {
            if (!s6[b0]) return;
            var n2 = s6[b0].indexOf(O2);
            if (n2 !== -1) s6[b0].splice(n2, 1);
            if (!s6[b0].length) delete s6[b0]
          }

          function K4(b0, O2) {
            if (s6[b0]) s6[b0].map(function(n2) {
              return n2(O2)
            })
          }

          function E6(b0) {
            var O2 = dB;
            if (!O2[b0]) O2[b0] = new Set;
            return O2[b0]
          }

          function D2(b0, O2) {
            var n2 = i5.get(b0);
            if (n2 != null) n2.handleCommitFiberUnmount(O2)
          }

          function m4(b0, O2, n2) {
            var e4 = rQ.getFiberRoots(b0),
              g6 = O2.current,
              X5 = e4.has(O2),
              r6 = g6.memoizedState == null || g6.memoizedState.element == null;
            if (!X5 && !r6) e4.add(O2);
            else if (X5 && r6) e4.delete(O2);
            var I8 = i5.get(b0);
            if (I8 != null) I8.handleCommitFiberRoot(O2, n2)
          }

          function U6(b0, O2) {
            var n2 = i5.get(b0);
            if (n2 != null) n2.handlePostCommitFiberRoot(O2)
          }

          function H4(b0, O2) {
            var n2 = i5.get(b0);
            if (n2 != null)
              if (O2) n2.patchConsoleForStrictMode();
              else n2.unpatchConsoleForStrictMode();
            else if (O2) {
              var e4 = window.__REACT_DEVTOOLS_HIDE_CONSOLE_LOGS_IN_STRICT_MODE__ === !0;
              XA(e4)
            } else jA()
          }
          var a6 = [],
            f5 = [];

          function E8(b0) {
            var O2 = b0.stack.split(`
`),
              n2 = O2.length > 1 ? O2[1] : null;
            return n2
          }

          function O4() {
            return f5
          }

          function U5(b0) {
            var O2 = E8(b0);
            if (O2 !== null) a6.push(O2)
          }

          function aQ(b0) {
            if (a6.length > 0) {
              var O2 = a6.pop(),
                n2 = E8(b0);
              if (n2 !== null) f5.push([O2, n2])
            }
          }
          var dB = {},
            i5 = new Map,
            s6 = {},
            T4 = new Map,
            sQ = new Map,
            rQ = {
              rendererInterfaces: i5,
              listeners: s6,
              backends: sQ,
              renderers: T4,
              emit: K4,
              getFiberRoots: E6,
              inject: pA,
              on: N0,
              off: m2,
              sub: E2,
              supportsFiber: !0,
              checkDCE: m1,
              onCommitFiberUnmount: D2,
              onCommitFiberRoot: m4,
              onPostCommitFiberRoot: U6,
              setStrictMode: H4,
              getInternalModuleRanges: O4,
              registerInternalModuleStart: U5,
              registerInternalModuleStop: aQ
            };
          return Object.defineProperty(M, "__REACT_DEVTOOLS_GLOBAL_HOOK__", {
            configurable: !1,
            enumerable: !1,
            get: function b0() {
              return rQ
            }
          }), rQ
        }

        function S01(M, f, b) {
          var p = M[f];
          return M[f] = function(c) {
            return b.call(this, p, arguments)
          }, p
        }

        function RE1(M, f) {
          var b = {};
          for (var p in f) b[p] = S01(M, p, f[p]);
          return b
        }

        function _01(M, f) {
          for (var b in f) M[b] = f[b]
        }

        function dV(M) {
          if (typeof M.forceUpdate === "function") M.forceUpdate();
          else if (M.updater != null && typeof M.updater.enqueueForceUpdate === "function") M.updater.enqueueForceUpdate(this, function() {}, "forceUpdate")
        }

        function j01(M, f) {
          var b = Object.keys(M);
          if (Object.getOwnPropertySymbols) {
            var p = Object.getOwnPropertySymbols(M);
            if (f) p = p.filter(function(c) {
              return Object.getOwnPropertyDescriptor(M, c).enumerable
            });
            b.push.apply(b, p)
          }
          return b
        }

        function RH(M) {
          for (var f = 1; f < arguments.length; f++) {
            var b = arguments[f] != null ? arguments[f] : {};
            if (f % 2) j01(Object(b), !0).forEach(function(p) {
              OE1(M, p, b[p])
            });
            else if (Object.getOwnPropertyDescriptors) Object.defineProperties(M, Object.getOwnPropertyDescriptors(b));
            else j01(Object(b)).forEach(function(p) {
              Object.defineProperty(M, p, Object.getOwnPropertyDescriptor(b, p))
            })
          }
          return M
        }

        function OE1(M, f, b) {
          if (f in M) Object.defineProperty(M, f, {
            value: b,
            enumerable: !0,
            configurable: !0,
            writable: !0
          });
          else M[f] = b;
          return M
        }

        function BP(M) {
          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") BP = function f(b) {
            return typeof b
          };
          else BP = function f(b) {
            return b && typeof Symbol === "function" && b.constructor === Symbol && b !== Symbol.prototype ? "symbol" : typeof b
          };
          return BP(M)
        }

        function QP(M) {
          var f = null,
            b = null;
          if (M._currentElement != null) {
            if (M._currentElement.key) b = String(M._currentElement.key);
            var p = M._currentElement.type;
            if (typeof p === "string") f = p;
            else if (typeof p === "function") f = F5(p)
          }
          return {
            displayName: f,
            key: b
          }
        }

        function SF(M) {
          if (M._currentElement != null) {
            var f = M._currentElement.type;
            if (typeof f === "function") {
              var b = M.getPublicInstance();
              if (b !== null) return n6;
              else return EB
            } else if (typeof f === "string") return t4
          }
          return J5
        }

        function IP(M) {
          var f = [];
          if (BP(M) !== "object");
          else if (M._currentElement === null || M._currentElement === !1);
          else if (M._renderedComponent) {
            var b = M._renderedComponent;
            if (SF(b) !== J5) f.push(b)
          } else if (M._renderedChildren) {
            var p = M._renderedChildren;
            for (var c in p) {
              var q1 = p[c];
              if (SF(q1) !== J5) f.push(q1)
            }
          }
          return f
        }

        function TE1(M, f, b, p) {
          var c = new Map,
            q1 = new WeakMap,
            m1 = new WeakMap,
            l1 = null,
            $1, s1 = function I0(G0) {
              return null
            };
          if (b.ComponentTree) l1 = function I0(G0, K0) {
            var O0 = b.ComponentTree.getClosestInstanceFromNode(G0);
            return q1.get(O0) || null
          }, $1 = function I0(G0) {
            var K0 = c.get(G0);
            return b.ComponentTree.getNodeFromInstance(K0)
          }, s1 = function I0(G0) {
            return b.ComponentTree.getClosestInstanceFromNode(G0)
          };
          else if (b.Mount.getID && b.Mount.getNode) l1 = function I0(G0, K0) {
            return null
          }, $1 = function I0(G0) {
            return null
          };

          function XA(I0) {
            var G0 = c.get(I0);
            return G0 ? QP(G0).displayName : null
          }

          function jA(I0) {
            if (BP(I0) !== "object" || I0 === null) throw new Error("Invalid internal instance: " + I0);
            if (!q1.has(I0)) {
              var G0 = FQ();
              q1.set(I0, G0), c.set(G0, I0)
            }
            return q1.get(I0)
          }

          function wA(I0, G0) {
            if (I0.length !== G0.length) return !1;
            for (var K0 = 0; K0 < I0.length; K0++)
              if (I0[K0] !== G0[K0]) return !1;
            return !0
          }
          var pA = [],
            W0 = null;
          if (b.Reconciler) W0 = RE1(b.Reconciler, {
            mountComponent: function I0(G0, K0) {
              var O0 = K0[0],
                M2 = K0[3];
              if (SF(O0) === J5) return G0.apply(this, K0);
              if (M2._topLevelWrapper === void 0) return G0.apply(this, K0);
              var H9 = jA(O0),
                N6 = pA.length > 0 ? pA[pA.length - 1] : 0;
              N0(O0, H9, N6), pA.push(H9), m1.set(O0, jA(M2._topLevelWrapper));
              try {
                var v5 = G0.apply(this, K0);
                return pA.pop(), v5
              } catch (b2) {
                throw pA = [], b2
              } finally {
                if (pA.length === 0) {
                  var b5 = m1.get(O0);
                  if (b5 === void 0) throw new Error("Expected to find root ID.");
                  E8(b5)
                }
              }
            },
            performUpdateIfNecessary: function I0(G0, K0) {
              var O0 = K0[0];
              if (SF(O0) === J5) return G0.apply(this, K0);
              var M2 = jA(O0);
              pA.push(M2);
              var H9 = IP(O0);
              try {
                var N6 = G0.apply(this, K0),
                  v5 = IP(O0);
                if (!wA(H9, v5)) m2(O0, M2, v5);
                return pA.pop(), N6
              } catch (b2) {
                throw pA = [], b2
              } finally {
                if (pA.length === 0) {
                  var b5 = m1.get(O0);
                  if (b5 === void 0) throw new Error("Expected to find root ID.");
                  E8(b5)
                }
              }
            },
            receiveComponent: function I0(G0, K0) {
              var O0 = K0[0];
              if (SF(O0) === J5) return G0.apply(this, K0);
              var M2 = jA(O0);
              pA.push(M2);
              var H9 = IP(O0);
              try {
                var N6 = G0.apply(this, K0),
                  v5 = IP(O0);
                if (!wA(H9, v5)) m2(O0, M2, v5);
                return pA.pop(), N6
              } catch (b2) {
                throw pA = [], b2
              } finally {
                if (pA.length === 0) {
                  var b5 = m1.get(O0);
                  if (b5 === void 0) throw new Error("Expected to find root ID.");
                  E8(b5)
                }
              }
            },
            unmountComponent: function I0(G0, K0) {
              var O0 = K0[0];
              if (SF(O0) === J5) return G0.apply(this, K0);
              var M2 = jA(O0);
              pA.push(M2);
              try {
                var H9 = G0.apply(this, K0);
                return pA.pop(), K4(O0, M2), H9
              } catch (v5) {
                throw pA = [], v5
              } finally {
                if (pA.length === 0) {
                  var N6 = m1.get(O0);
                  if (N6 === void 0) throw new Error("Expected to find root ID.");
                  E8(N6)
                }
              }
            }
          });

          function E2() {
            if (W0 !== null)
              if (b.Component) _01(b.Component.Mixin, W0);
              else _01(b.Reconciler, W0);
            W0 = null
          }

          function N0(I0, G0, K0) {
            var O0 = K0 === 0;
            if (K) console.log("%crecordMount()", "color: green; font-weight: bold;", G0, QP(I0).displayName);
            if (O0) {
              var M2 = I0._currentElement != null && I0._currentElement._owner != null;
              O4(N), O4(G0), O4(P6), O4(0), O4(0), O4(0), O4(M2 ? 1 : 0)
            } else {
              var H9 = SF(I0),
                N6 = QP(I0),
                v5 = N6.displayName,
                b5 = N6.key,
                b2 = I0._currentElement != null && I0._currentElement._owner != null ? jA(I0._currentElement._owner) : 0,
                xF = U5(v5),
                v8 = U5(b5);
              O4(N), O4(G0), O4(H9), O4(K0), O4(b2), O4(xF), O4(v8)
            }
          }

          function m2(I0, G0, K0) {
            O4(O), O4(G0);
            var O0 = K0.map(jA);
            O4(O0.length);
            for (var M2 = 0; M2 < O0.length; M2++) O4(O0[M2])
          }

          function K4(I0, G0) {
            H4.push(G0), c.delete(G0)
          }

          function E6(I0, G0, K0) {
            if (K) console.group("crawlAndRecordInitialMounts() id:", I0);
            var O0 = c.get(I0);
            if (O0 != null) m1.set(O0, K0), N0(O0, I0, G0), IP(O0).forEach(function(M2) {
              return E6(jA(M2), I0, K0)
            });
            if (K) console.groupEnd()
          }

          function D2() {
            var I0 = b.Mount._instancesByReactRootID || b.Mount._instancesByContainerID;
            for (var G0 in I0) {
              var K0 = I0[G0],
                O0 = jA(K0);
              E6(O0, 0, O0), E8(O0)
            }
          }
          var m4 = [],
            U6 = new Map,
            H4 = [],
            a6 = 0,
            f5 = null;

          function E8(I0) {
            if (m4.length === 0 && H4.length === 0 && f5 === null) return;
            var G0 = H4.length + (f5 === null ? 0 : 1),
              K0 = new Array(3 + a6 + (G0 > 0 ? 2 + G0 : 0) + m4.length),
              O0 = 0;
            if (K0[O0++] = f, K0[O0++] = I0, K0[O0++] = a6, U6.forEach(function(N6, v5) {
                K0[O0++] = v5.length;
                var b5 = VF(v5);
                for (var b2 = 0; b2 < b5.length; b2++) K0[O0 + b2] = b5[b2];
                O0 += v5.length
              }), G0 > 0) {
              K0[O0++] = q, K0[O0++] = G0;
              for (var M2 = 0; M2 < H4.length; M2++) K0[O0++] = H4[M2];
              if (f5 !== null) K0[O0] = f5, O0++
            }
            for (var H9 = 0; H9 < m4.length; H9++) K0[O0 + H9] = m4[H9];
            if (O0 += m4.length, K) LT(K0);
            M.emit("operations", K0), m4.length = 0, H4 = [], f5 = null, U6.clear(), a6 = 0
          }

          function O4(I0) {
            m4.push(I0)
          }

          function U5(I0) {
            if (I0 === null) return 0;
            var G0 = U6.get(I0);
            if (G0 !== void 0) return G0;
            var K0 = U6.size + 1;
            return U6.set(I0, K0), a6 += I0.length + 1, K0
          }
          var aQ = null,
            dB = {};

          function i5(I0) {
            var G0 = dB;
            I0.forEach(function(K0) {
              if (!G0[K0]) G0[K0] = {};
              G0 = G0[K0]
            })
          }

          function s6(I0) {
            return function G0(K0) {
              var O0 = dB[I0];
              if (!O0) return !1;
              for (var M2 = 0; M2 < K0.length; M2++)
                if (O0 = O0[K0[M2]], !O0) return !1;
              return !0
            }
          }

          function T4(I0) {
            var G0 = null,
              K0 = null,
              O0 = c.get(I0);
            if (O0 != null) {
              G0 = O0._instance || null;
              var M2 = O0._currentElement;
              if (M2 != null && M2.props != null) K0 = M2.props.style || null
            }
            return {
              instance: G0,
              style: K0
            }
          }

          function sQ(I0) {
            var G0 = c.get(I0);
            if (G0 == null) {
              console.warn('Could not find instance with id "'.concat(I0, '"'));
              return
            }
            switch (SF(G0)) {
              case n6:
                p.$r = G0._instance;
                break;
              case EB:
                var K0 = G0._currentElement;
                if (K0 == null) {
                  console.warn('Could not find element with id "'.concat(I0, '"'));
                  return
                }
                p.$r = {
                  props: K0.props,
                  type: K0.type
                };
                break;
              default:
                p.$r = null;
                break
            }
          }

          function rQ(I0, G0, K0) {
            var O0 = n2(I0);
            if (O0 !== null) {
              var M2 = xB(O0, G0),
                H9 = "$reactTemp".concat(K0);
              window[H9] = M2, console.log(H9), console.log(M2)
            }
          }

          function b0(I0, G0) {
            var K0 = n2(I0);
            if (K0 !== null) {
              var O0 = xB(K0, G0);
              return OT(O0)
            }
          }

          function O2(I0, G0, K0, O0) {
            if (O0 || aQ !== G0) aQ = G0, dB = {};
            var M2 = n2(G0);
            if (M2 === null) return {
              id: G0,
              responseID: I0,
              type: "not-found"
            };
            if (K0 !== null) i5(K0);
            return sQ(G0), M2.context = bW(M2.context, s6("context")), M2.props = bW(M2.props, s6("props")), M2.state = bW(M2.state, s6("state")), {
              id: G0,
              responseID: I0,
              type: "full-data",
              value: M2
            }
          }

          function n2(I0) {
            var G0 = c.get(I0);
            if (G0 == null) return null;
            var K0 = QP(G0),
              O0 = K0.displayName,
              M2 = K0.key,
              H9 = SF(G0),
              N6 = null,
              v5 = null,
              b5 = null,
              b2 = null,
              xF = G0._currentElement;
            if (xF !== null) {
              b5 = xF.props;
              var v8 = xF._owner;
              if (v8) {
                v5 = [];
                while (v8 != null)
                  if (v5.push({
                      displayName: QP(v8).displayName || "Unknown",
                      id: jA(v8),
                      key: xF.key,
                      type: SF(v8)
                    }), v8._currentElement) v8 = v8._currentElement._owner
              }
            }
            var b8 = G0._instance;
            if (b8 != null) N6 = b8.context || null, b2 = b8.state || null;
            var uV = [],
              UQ = [];
            return {
              id: I0,
              canEditHooks: !1,
              canEditFunctionProps: !1,
              canEditHooksAndDeletePaths: !1,
              canEditHooksAndRenamePaths: !1,
              canEditFunctionPropsDeletePaths: !1,
              canEditFunctionPropsRenamePaths: !1,
              canToggleError: !1,
              isErrored: !1,
              targetErrorBoundaryID: null,
              canToggleSuspense: !1,
              canViewSource: H9 === n6 || H9 === EB,
              source: null,
              hasLegacyContext: !0,
              displayName: O0,
              type: H9,
              key: M2 != null ? M2 : null,
              context: N6,
              hooks: null,
              props: b5,
              state: b2,
              errors: uV,
              warnings: UQ,
              owners: v5,
              rootType: null,
              rendererPackageName: null,
              rendererVersion: null,
              plugins: {
                stylex: null
              }
            }
          }

          function e4(I0) {
            var G0 = n2(I0);
            if (G0 === null) {
              console.warn('Could not find element with id "'.concat(I0, '"'));
              return
            }
            var K0 = typeof console.groupCollapsed === "function";
            if (K0) console.groupCollapsed("[Click to expand] %c<".concat(G0.displayName || "Component", " />"), "color: var(--dom-tag-name-color); font-weight: normal;");
            if (G0.props !== null) console.log("Props:", G0.props);
            if (G0.state !== null) console.log("State:", G0.state);
            if (G0.context !== null) console.log("Context:", G0.context);
            var O0 = $1(I0);
            if (O0 !== null) console.log("Node:", O0);
            if (window.chrome || /firefox/i.test(navigator.userAgent)) console.log("Right-click any value to save it as a global variable for further inspection.");
            if (K0) console.groupEnd()
          }

          function g6(I0, G0) {
            var K0 = n2(I0);
            if (K0 !== null) window.$attribute = xB(K0, G0)
          }

          function X5(I0) {
            var G0 = c.get(I0);
            if (G0 == null) {
              console.warn('Could not find instance with id "'.concat(I0, '"'));
              return
            }
            var K0 = G0._currentElement;
            if (K0 == null) {
              console.warn('Could not find element with id "'.concat(I0, '"'));
              return
            }
            p.$type = K0.type
          }

          function r6(I0, G0, K0, O0) {
            var M2 = c.get(G0);
            if (M2 != null) {
              var H9 = M2._instance;
              if (H9 != null) switch (I0) {
                case "context":
                  GH(H9.context, O0), dV(H9);
                  break;
                case "hooks":
                  throw new Error("Hooks not supported by this renderer");
                case "props":
                  var N6 = M2._currentElement;
                  M2._currentElement = RH(RH({}, N6), {}, {
                    props: Wq(N6.props, O0)
                  }), dV(H9);
                  break;
                case "state":
                  GH(H9.state, O0), dV(H9);
                  break
              }
            }
          }

          function I8(I0, G0, K0, O0, M2) {
            var H9 = c.get(G0);
            if (H9 != null) {
              var N6 = H9._instance;
              if (N6 != null) switch (I0) {
                case "context":
                  fW(N6.context, O0, M2), dV(N6);
                  break;
                case "hooks":
                  throw new Error("Hooks not supported by this renderer");
                case "props":
                  var v5 = H9._currentElement;
                  H9._currentElement = RH(RH({}, v5), {}, {
                    props: yV(v5.props, O0, M2)
                  }), dV(N6);
                  break;
                case "state":
                  fW(N6.state, O0, M2), dV(N6);
                  break
              }
            }
          }

          function EQ(I0, G0, K0, O0, M2) {
            var H9 = c.get(G0);
            if (H9 != null) {
              var N6 = H9._instance;
              if (N6 != null) switch (I0) {
                case "context":
                  fE(N6.context, O0, M2), dV(N6);
                  break;
                case "hooks":
                  throw new Error("Hooks not supported by this renderer");
                case "props":
                  var v5 = H9._currentElement;
                  H9._currentElement = RH(RH({}, v5), {}, {
                    props: zF(v5.props, O0, M2)
                  }), dV(N6);
                  break;
                case "state":
                  fE(N6.state, O0, M2), dV(N6);
                  break
              }
            }
          }
          var oQ = function I0() {
              throw new Error("getProfilingData not supported by this renderer")
            },
            _F = function I0() {
              throw new Error("handleCommitFiberRoot not supported by this renderer")
            },
            jF = function I0() {
              throw new Error("handleCommitFiberUnmount not supported by this renderer")
            },
            yF = function I0() {
              throw new Error("handlePostCommitFiberRoot not supported by this renderer")
            },
            OH = function I0() {
              throw new Error("overrideError not supported by this renderer")
            },
            HD = function I0() {
              throw new Error("overrideSuspense not supported by this renderer")
            },
            kF = function I0() {},
            JG = function I0() {};

          function a0() {
            return null
          }

          function D9(I0) {
            return null
          }

          function l4(I0) {}

          function o6(I0) {}

          function uB(I0) {}

          function t6(I0) {
            return null
          }

          function _7() {}

          function ZZ(I0) {}

          function o8(I0) {}

          function j7() {}

          function TH() {}

          function PH(I0) {
            return c.has(I0)
          }
          return {
            clearErrorsAndWarnings: _7,
            clearErrorsForFiberID: ZZ,
            clearWarningsForFiberID: o8,
            cleanup: E2,
            getSerializedElementValueByPath: b0,
            deletePath: r6,
            flushInitialOperations: D2,
            getBestMatchForTrackedPath: a0,
            getDisplayNameForFiberID: XA,
            getFiberForNative: s1,
            getFiberIDForNative: l1,
            getInstanceAndStyle: T4,
            findNativeNodesForFiberID: function I0(G0) {
              var K0 = $1(G0);
              return K0 == null ? null : [K0]
            },
            getOwnersList: t6,
            getPathForElement: D9,
            getProfilingData: oQ,
            handleCommitFiberRoot: _F,
            handleCommitFiberUnmount: jF,
            handlePostCommitFiberRoot: yF,
            hasFiberWithId: PH,
            inspectElement: O2,
            logElementToConsole: e4,
            overrideError: OH,
            overrideSuspense: HD,
            overrideValueAtPath: EQ,
            renamePath: I8,
            patchConsoleForStrictMode: j7,
            prepareViewAttributeSource: g6,
            prepareViewElementSource: X5,
            renderer: b,
            setTraceUpdatesEnabled: o6,
            setTrackedPath: uB,
            startProfiling: kF,
            stopProfiling: JG,
            storeAsGlobal: rQ,
            unpatchConsoleForStrictMode: TH,
            updateComponentFilters: l4
          }
        }

        function PE1(M) {
          return !py(M)
        }

        function y01(M, f, b) {
          if (M == null) return function() {};
          var p = [M.sub("renderer-attached", function(m1) {
              var {
                id: l1,
                renderer: $1,
                rendererInterface: s1
              } = m1;
              f.setRendererInterface(l1, s1), s1.flushInitialOperations()
            }), M.sub("unsupported-renderer-version", function(m1) {
              f.onUnsupportedRenderer(m1)
            }), M.sub("fastRefreshScheduled", f.onFastRefreshScheduled), M.sub("operations", f.onHookOperations), M.sub("traceUpdates", f.onTraceUpdates)],
            c = function m1(l1, $1) {
              if (!PE1($1.reconcilerVersion || $1.version)) return;
              var s1 = M.rendererInterfaces.get(l1);
              if (s1 == null) {
                if (typeof $1.findFiberByHostInstance === "function") s1 = l5(M, l1, $1, b);
                else if ($1.ComponentTree) s1 = TE1(M, l1, $1, b);
                if (s1 != null) M.rendererInterfaces.set(l1, s1)
              }
              if (s1 != null) M.emit("renderer-attached", {
                id: l1,
                renderer: $1,
                rendererInterface: s1
              });
              else M.emit("unsupported-renderer-version", l1)
            };
          M.renderers.forEach(function(m1, l1) {
            c(l1, m1)
          }), p.push(M.sub("renderer", function(m1) {
            var {
              id: l1,
              renderer: $1
            } = m1;
            c(l1, $1)
          })), M.emit("react-devtools", f), M.reactDevtoolsAgent = f;
          var q1 = function m1() {
            p.forEach(function(l1) {
              return l1()
            }), M.rendererInterfaces.forEach(function(l1) {
              l1.cleanup()
            }), M.reactDevtoolsAgent = null
          };
          return f.addListener("shutdown", q1), p.push(function() {
              f.removeListener("shutdown", q1)
            }),
            function() {
              p.forEach(function(m1) {
                return m1()
              })
            }
        }

        function k01(M, f) {
          var b = !1,
            p = {
              bottom: 0,
              left: 0,
              right: 0,
              top: 0
            },
            c = f[M];
          if (c != null) {
            for (var q1 = 0, m1 = Object.keys(p); q1 < m1.length; q1++) {
              var l1 = m1[q1];
              p[l1] = c
            }
            b = !0
          }
          var $1 = f[M + "Horizontal"];
          if ($1 != null) p.left = $1, p.right = $1, b = !0;
          else {
            var s1 = f[M + "Left"];
            if (s1 != null) p.left = s1, b = !0;
            var XA = f[M + "Right"];
            if (XA != null) p.right = XA, b = !0;
            var jA = f[M + "End"];
            if (jA != null) p.right = jA, b = !0;
            var wA = f[M + "Start"];
            if (wA != null) p.left = wA, b = !0
          }
          var pA = f[M + "Vertical"];
          if (pA != null) p.bottom = pA, p.top = pA, b = !0;
          else {
            var W0 = f[M + "Bottom"];
            if (W0 != null) p.bottom = W0, b = !0;
            var E2 = f[M + "Top"];
            if (E2 != null) p.top = E2, b = !0
          }
          return b ? p : null
        }

        function _q(M) {
          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") _q = function f(b) {
            return typeof b
          };
          else _q = function f(b) {
            return b && typeof Symbol === "function" && b.constructor === Symbol && b !== Symbol.prototype ? "symbol" : typeof b
          };
          return _q(M)
        }

        function Ek(M, f, b) {
          if (f in M) Object.defineProperty(M, f, {
            value: b,
            enumerable: !0,
            configurable: !0,
            writable: !0
          });
          else M[f] = b;
          return M
        }

        function cp(M, f, b, p) {
          M.addListener("NativeStyleEditor_measure", function(c) {
            var {
              id: q1,
              rendererID: m1
            } = c;
            lp(f, M, b, q1, m1)
          }), M.addListener("NativeStyleEditor_renameAttribute", function(c) {
            var {
              id: q1,
              rendererID: m1,
              oldName: l1,
              newName: $1,
              value: s1
            } = c;
            SE1(f, q1, m1, l1, $1, s1), setTimeout(function() {
              return lp(f, M, b, q1, m1)
            })
          }), M.addListener("NativeStyleEditor_setValue", function(c) {
            var {
              id: q1,
              rendererID: m1,
              name: l1,
              value: $1
            } = c;
            _E1(f, q1, m1, l1, $1), setTimeout(function() {
              return lp(f, M, b, q1, m1)
            })
          }), M.send("isNativeStyleEditorSupported", {
            isSupported: !0,
            validAttributes: p
          })
        }
        var x01 = {
            top: 0,
            left: 0,
            right: 0,
            bottom: 0
          },
          GP = new Map;

        function lp(M, f, b, p, c) {
          var q1 = M.getInstanceAndStyle({
            id: p,
            rendererID: c
          });
          if (!q1 || !q1.style) {
            f.send("NativeStyleEditor_styleAndLayout", {
              id: p,
              layout: null,
              style: null
            });
            return
          }
          var {
            instance: m1,
            style: l1
          } = q1, $1 = b(l1), s1 = GP.get(p);
          if (s1 != null) $1 = Object.assign({}, $1, s1);
          if (!m1 || typeof m1.measure !== "function") {
            f.send("NativeStyleEditor_styleAndLayout", {
              id: p,
              layout: null,
              style: $1 || null
            });
            return
          }
          m1.measure(function(XA, jA, wA, pA, W0, E2) {
            if (typeof XA !== "number") {
              f.send("NativeStyleEditor_styleAndLayout", {
                id: p,
                layout: null,
                style: $1 || null
              });
              return
            }
            var N0 = $1 != null && k01("margin", $1) || x01,
              m2 = $1 != null && k01("padding", $1) || x01;
            f.send("NativeStyleEditor_styleAndLayout", {
              id: p,
              layout: {
                x: XA,
                y: jA,
                width: wA,
                height: pA,
                left: W0,
                top: E2,
                margin: N0,
                padding: m2
              },
              style: $1 || null
            })
          })
        }

        function f01(M) {
          var f = {};
          for (var b in M) f[b] = M[b];
          return f
        }

        function SE1(M, f, b, p, c, q1) {
          var m1, l1 = M.getInstanceAndStyle({
            id: f,
            rendererID: b
          });
          if (!l1 || !l1.style) return;
          var {
            instance: $1,
            style: s1
          } = l1, XA = c ? (m1 = {}, Ek(m1, p, void 0), Ek(m1, c, q1), m1) : Ek({}, p, void 0), jA;
          if ($1 !== null && typeof $1.setNativeProps === "function") {
            var wA = GP.get(f);
            if (!wA) GP.set(f, XA);
            else Object.assign(wA, XA);
            $1.setNativeProps({
              style: XA
            })
          } else if (K3(s1)) {
            var pA = s1.length - 1;
            if (_q(s1[pA]) === "object" && !K3(s1[pA])) {
              if (jA = f01(s1[pA]), delete jA[p], c) jA[c] = q1;
              else jA[p] = void 0;
              M.overrideValueAtPath({
                type: "props",
                id: f,
                rendererID: b,
                path: ["style", pA],
                value: jA
              })
            } else M.overrideValueAtPath({
              type: "props",
              id: f,
              rendererID: b,
              path: ["style"],
              value: s1.concat([XA])
            })
          } else if (_q(s1) === "object") {
            if (jA = f01(s1), delete jA[p], c) jA[c] = q1;
            else jA[p] = void 0;
            M.overrideValueAtPath({
              type: "props",
              id: f,
              rendererID: b,
              path: ["style"],
              value: jA
            })
          } else M.overrideValueAtPath({
            type: "props",
            id: f,
            rendererID: b,
            path: ["style"],
            value: [s1, XA]
          });
          M.emit("hideNativeHighlight")
        }

        function _E1(M, f, b, p, c) {
          var q1 = M.getInstanceAndStyle({
            id: f,
            rendererID: b
          });
          if (!q1 || !q1.style) return;
          var {
            instance: m1,
            style: l1
          } = q1, $1 = Ek({}, p, c);
          if (m1 !== null && typeof m1.setNativeProps === "function") {
            var s1 = GP.get(f);
            if (!s1) GP.set(f, $1);
            else Object.assign(s1, $1);
            m1.setNativeProps({
              style: $1
            })
          } else if (K3(l1)) {
            var XA = l1.length - 1;
            if (_q(l1[XA]) === "object" && !K3(l1[XA])) M.overrideValueAtPath({
              type: "props",
              id: f,
              rendererID: b,
              path: ["style", XA, p],
              value: c
            });
            else M.overrideValueAtPath({
              type: "props",
              id: f,
              rendererID: b,
              path: ["style"],
              value: l1.concat([$1])
            })
          } else M.overrideValueAtPath({
            type: "props",
            id: f,
            rendererID: b,
            path: ["style"],
            value: [l1, $1]
          });
          M.emit("hideNativeHighlight")
        }

        function v01(M) {
          jE1(M)
        }

        function jE1(M) {
          if (M.getConsolePatchSettings == null) return;
          var f = M.getConsolePatchSettings();
          if (f == null) return;
          var b = ip(f);
          if (b == null) return;
          JE1(b)
        }

        function ip(M) {
          var f, b, p, c, q1, m1 = JSON.parse(M !== null && M !== void 0 ? M : "{}"),
            l1 = m1.appendComponentStack,
            $1 = m1.breakOnConsoleErrors,
            s1 = m1.showInlineWarningsAndErrors,
            XA = m1.hideConsoleLogsInStrictMode,
            jA = m1.browserTheme;
          return {
            appendComponentStack: (f = iQ(l1)) !== null && f !== void 0 ? f : !0,
            breakOnConsoleErrors: (b = iQ($1)) !== null && b !== void 0 ? b : !1,
            showInlineWarningsAndErrors: (p = iQ(s1)) !== null && p !== void 0 ? p : !0,
            hideConsoleLogsInStrictMode: (c = iQ(XA)) !== null && c !== void 0 ? c : !1,
            browserTheme: (q1 = YD(jA)) !== null && q1 !== void 0 ? q1 : "dark"
          }
        }

        function np(M, f) {
          if (M.setConsolePatchSettings == null) return;
          M.setConsolePatchSettings(JSON.stringify(f))
        }
        oT(), LE1(window);
        var WG = window.__REACT_DEVTOOLS_GLOBAL_HOOK__,
          Uk = Zq();

        function ZP(M) {
          if (K) {
            var f;
            for (var b = arguments.length, p = new Array(b > 1 ? b - 1 : 0), c = 1; c < b; c++) p[c - 1] = arguments[c];
            (f = console).log.apply(f, ["%c[core/backend] %c".concat(M), "color: teal; font-weight: bold;", "font-weight: bold;"].concat(p))
          }
        }

        function b01(M) {
          if (WG == null) return;
          var f = M || {},
            b = f.host,
            p = b === void 0 ? "localhost" : b,
            c = f.nativeStyleEditorValidAttributes,
            q1 = f.useHttps,
            m1 = q1 === void 0 ? !1 : q1,
            l1 = f.port,
            $1 = l1 === void 0 ? 8097 : l1,
            s1 = f.websocket,
            XA = f.resolveRNStyle,
            jA = XA === void 0 ? null : XA,
            wA = f.retryConnectionDelay,
            pA = wA === void 0 ? 2000 : wA,
            W0 = f.isAppActive,
            E2 = W0 === void 0 ? function() {
              return !0
            } : W0,
            N0 = f.devToolsSettingsManager,
            m2 = m1 ? "wss" : "ws",
            K4 = null;

          function E6() {
            if (K4 === null) K4 = setTimeout(function() {
              return b01(M)
            }, pA)
          }
          if (N0 != null) try {
            v01(N0)
          } catch (O4) {
            console.error(O4)
          }
          if (!E2()) {
            E6();
            return
          }
          var D2 = null,
            m4 = [],
            U6 = m2 + "://" + p + ":" + $1,
            H4 = s1 ? s1 : new window.WebSocket(U6);
          H4.onclose = a6, H4.onerror = f5, H4.onmessage = E8, H4.onopen = function() {
            if (D2 = new q01({
                listen: function i5(s6) {
                  return m4.push(s6),
                    function() {
                      var T4 = m4.indexOf(s6);
                      if (T4 >= 0) m4.splice(T4, 1)
                    }
                },
                send: function i5(s6, T4, sQ) {
                  if (H4.readyState === H4.OPEN) {
                    if (K) ZP("wall.send()", s6, T4);
                    H4.send(JSON.stringify({
                      event: s6,
                      payload: T4
                    }))
                  } else {
                    if (K) ZP("wall.send()", "Shutting down bridge because of closed WebSocket connection");
                    if (D2 !== null) D2.shutdown();
                    E6()
                  }
                }
              }), D2.addListener("updateComponentFilters", function(i5) {
                Uk = i5
              }), N0 != null && D2 != null) D2.addListener("updateConsolePatchSettings", function(i5) {
              return np(N0, i5)
            });
            if (window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ == null) D2.send("overrideComponentFilters", Uk);
            var O4 = new O01(D2);
            if (O4.addListener("shutdown", function() {
                WG.emit("shutdown")
              }), y01(WG, O4, window), jA != null || WG.resolveRNStyle != null) cp(D2, O4, jA || WG.resolveRNStyle, c || WG.nativeStyleEditorValidAttributes || null);
            else {
              var U5, aQ, dB = function i5() {
                if (D2 !== null) cp(D2, O4, U5, aQ)
              };
              if (!WG.hasOwnProperty("resolveRNStyle")) Object.defineProperty(WG, "resolveRNStyle", {
                enumerable: !1,
                get: function i5() {
                  return U5
                },
                set: function i5(s6) {
                  U5 = s6, dB()
                }
              });
              if (!WG.hasOwnProperty("nativeStyleEditorValidAttributes")) Object.defineProperty(WG, "nativeStyleEditorValidAttributes", {
                enumerable: !1,
                get: function i5() {
                  return aQ
                },
                set: function i5(s6) {
                  aQ = s6, dB()
                }
              })
            }
          };

          function a6() {
            if (K) ZP("WebSocket.onclose");
            if (D2 !== null) D2.emit("shutdown");
            E6()
          }

          function f5() {
            if (K) ZP("WebSocket.onerror");
            E6()
          }

          function E8(O4) {
            var U5;
            try {
              if (typeof O4.data === "string") {
                if (U5 = JSON.parse(O4.data), K) ZP("WebSocket.onmessage", U5)
              } else throw Error()
            } catch (aQ) {
              console.error("[React DevTools] Failed to parse JSON: " + O4.data);
              return
            }
            m4.forEach(function(aQ) {
              try {
                aQ(U5)
              } catch (dB) {
                throw console.log("[React DevTools] Error calling listener", U5), console.log("error:", dB), dB
              }
            })
          }
        }

        function yE1(M) {
          var {
            onSubscribe: f,
            onUnsubscribe: b,
            onMessage: p,
            settingsManager: c,
            nativeStyleEditorValidAttributes: q1,
            resolveRNStyle: m1
          } = M;
          if (WG == null) return;
          if (c != null) try {
            v01(c)
          } catch (pA) {
            console.error(pA)
          }
          var l1 = {
              listen: function pA(W0) {
                return f(W0),
                  function() {
                    b(W0)
                  }
              },
              send: function pA(W0, E2) {
                p(W0, E2)
              }
            },
            $1 = new q01(l1);
          if ($1.addListener("updateComponentFilters", function(pA) {
              Uk = pA
            }), c != null) $1.addListener("updateConsolePatchSettings", function(pA) {
            return np(c, pA)
          });
          if (window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ == null) $1.send("overrideComponentFilters", Uk);
          var s1 = new O01($1);
          s1.addListener("shutdown", function() {
            WG.emit("shutdown")
          });
          var XA = y01(WG, s1, window),
            jA = m1 || WG.resolveRNStyle;
          if (jA != null) {
            var wA = q1 || WG.nativeStyleEditorValidAttributes || null;
            cp($1, s1, jA, wA)
          }
          return XA
        }
      })(), I
    })()
  })
})
// @from(Start 2988209, End 2988217)
f14 = {}
// @from(Start 2988223, End 2988226)
FhA
// @from(Start 2988232, End 2988317)
XhA = J21(() => {
  WhA();
  FhA = I1(JhA(), 1);
  FhA.default.connectToDevTools()
})
// @from(Start 2988323, End 2989803)
zhA = z((q48, b14) => {
  b14.exports = {
    single: {
      topLeft: "┌",
      top: "─",
      topRight: "┐",
      right: "│",
      bottomRight: "┘",
      bottom: "─",
      bottomLeft: "└",
      left: "│"
    },
    double: {
      topLeft: "╔",
      top: "═",
      topRight: "╗",
      right: "║",
      bottomRight: "╝",
      bottom: "═",
      bottomLeft: "╚",
      left: "║"
    },
    round: {
      topLeft: "╭",
      top: "─",
      topRight: "╮",
      right: "│",
      bottomRight: "╯",
      bottom: "─",
      bottomLeft: "╰",
      left: "│"
    },
    bold: {
      topLeft: "┏",
      top: "━",
      topRight: "┓",
      right: "┃",
      bottomRight: "┛",
      bottom: "━",
      bottomLeft: "┗",
      left: "┃"
    },
    singleDouble: {
      topLeft: "╓",
      top: "─",
      topRight: "╖",
      right: "║",
      bottomRight: "╜",
      bottom: "─",
      bottomLeft: "╙",
      left: "║"
    },
    doubleSingle: {
      topLeft: "╒",
      top: "═",
      topRight: "╕",
      right: "│",
      bottomRight: "╛",
      bottom: "═",
      bottomLeft: "╘",
      left: "│"
    },
    classic: {
      topLeft: "+",
      top: "-",
      topRight: "+",
      right: "|",
      bottomRight: "+",
      bottom: "-",
      bottomLeft: "+",
      left: "|"
    },
    arrow: {
      topLeft: "↘",
      top: "↓",
      topRight: "↙",
      right: "←",
      bottomRight: "↖",
      bottom: "↑",
      bottomLeft: "↗",
      left: "→"
    }
  }
})
// @from(Start 2989809, End 2989903)
EhA = z((M48, zS1) => {
  var whA = zhA();
  zS1.exports = whA;
  zS1.exports.default = whA
})
// @from(Start 2989909, End 2990132)
yhA = z(($68, OS1) => {
  var jhA = (A, B) => {
    for (let Q of Reflect.ownKeys(B)) Object.defineProperty(A, Q, Object.getOwnPropertyDescriptor(B, Q));
    return A
  };
  OS1.exports = jhA;
  OS1.exports.default = jhA
})
// @from(Start 2990138, End 2990889)
xhA = z((q68, Y31) => {
  var WA4 = yhA(),
    D31 = new WeakMap,
    khA = (A, B = {}) => {
      if (typeof A !== "function") throw new TypeError("Expected a function");
      let Q, I = 0,
        G = A.displayName || A.name || "<anonymous>",
        Z = function(...D) {
          if (D31.set(Z, ++I), I === 1) Q = A.apply(this, D), A = null;
          else if (B.throw === !0) throw new Error(`Function \`${G}\` can only be called once`);
          return Q
        };
      return WA4(Z, A), D31.set(Z, I), Z
    };
  Y31.exports = khA;
  Y31.exports.default = khA;
  Y31.exports.callCount = (A) => {
    if (!D31.has(A)) throw new Error(`The given function \`${A.name}\` is not wrapped by the \`onetime\` package`);
    return D31.get(A)
  }
})
// @from(Start 2990895, End 2991243)
fhA = z((M68, W31) => {
  W31.exports = ["SIGABRT", "SIGALRM", "SIGHUP", "SIGINT", "SIGTERM"];
  if (process.platform !== "win32") W31.exports.push("SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
  if (process.platform === "linux") W31.exports.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED")
})
// @from(Start 2991249, End 2994176)
vhA = z((L68, ov) => {
  var aB = global.process,
    yS = function(A) {
      return A && typeof A === "object" && typeof A.removeListener === "function" && typeof A.emit === "function" && typeof A.reallyExit === "function" && typeof A.listeners === "function" && typeof A.kill === "function" && typeof A.pid === "number" && typeof A.on === "function"
    };
  if (!yS(aB)) ov.exports = function() {
    return function() {}
  };
  else {
    if (TS1 = Z1("assert"), kS = fhA(), PS1 = /^win/i.test(aB.platform), rv = Z1("events"), typeof rv !== "function") rv = rv.EventEmitter;
    if (aB.__signal_exit_emitter__) g7 = aB.__signal_exit_emitter__;
    else g7 = aB.__signal_exit_emitter__ = new rv, g7.count = 0, g7.emitted = {};
    if (!g7.infinite) g7.setMaxListeners(1 / 0), g7.infinite = !0;
    ov.exports = function(A, B) {
      if (!yS(global.process)) return function() {};
      if (TS1.equal(typeof A, "function", "a callback must be provided for exit handler"), xS === !1) J31();
      var Q = "exit";
      if (B && B.alwaysLast) Q = "afterexit";
      var I = function() {
        if (g7.removeListener(Q, A), g7.listeners("exit").length === 0 && g7.listeners("afterexit").length === 0) _n()
      };
      return g7.on(Q, A), I
    }, _n = function A() {
      if (!xS || !yS(global.process)) return;
      xS = !1, kS.forEach(function(B) {
        try {
          aB.removeListener(B, jn[B])
        } catch (Q) {}
      }), aB.emit = yn, aB.reallyExit = F31, g7.count -= 1
    }, ov.exports.unload = _n, VL = function A(B, Q, I) {
      if (g7.emitted[B]) return;
      g7.emitted[B] = !0, g7.emit(B, Q, I)
    }, jn = {}, kS.forEach(function(A) {
      jn[A] = function B() {
        if (!yS(global.process)) return;
        var Q = aB.listeners(A);
        if (Q.length === g7.count) {
          if (_n(), VL("exit", null, A), VL("afterexit", null, A), PS1 && A === "SIGHUP") A = "SIGINT";
          aB.kill(aB.pid, A)
        }
      }
    }), ov.exports.signals = function() {
      return kS
    }, xS = !1, J31 = function A() {
      if (xS || !yS(global.process)) return;
      xS = !0, g7.count += 1, kS = kS.filter(function(B) {
        try {
          return aB.on(B, jn[B]), !0
        } catch (Q) {
          return !1
        }
      }), aB.emit = _S1, aB.reallyExit = SS1
    }, ov.exports.load = J31, F31 = aB.reallyExit, SS1 = function A(B) {
      if (!yS(global.process)) return;
      aB.exitCode = B || 0, VL("exit", aB.exitCode, null), VL("afterexit", aB.exitCode, null), F31.call(aB, aB.exitCode)
    }, yn = aB.emit, _S1 = function A(B, Q) {
      if (B === "exit" && yS(global.process)) {
        if (Q !== void 0) aB.exitCode = Q;
        var I = yn.apply(this, arguments);
        return VL("exit", aB.exitCode, null), VL("afterexit", aB.exitCode, null), I
      } else return yn.apply(this, arguments)
    }
  }
  var TS1, kS, PS1, rv, g7, _n, VL, jn, xS, J31, F31, SS1, yn, _S1
})
// @from(Start 2994182, End 2994380)
ehA = z((m68, thA) => {
  var HA4 = /[|\\{}()[\]^$+*?.-]/g;
  thA.exports = (A) => {
    if (typeof A !== "string") throw new TypeError("Expected a string");
    return A.replace(HA4, "\\$&")
  }
})
// @from(Start 2994386, End 2999432)
ImA = z((d68, QmA) => {
  var zA4 = ehA(),
    wA4 = typeof process === "object" && process && typeof process.cwd === "function" ? process.cwd() : ".",
    BmA = [].concat(Z1("module").builtinModules, "bootstrap_node", "node").map((A) => new RegExp(`(?:\\((?:node:)?${A}(?:\\.js)?:\\d+:\\d+\\)$|^\\s*at (?:node:)?${A}(?:\\.js)?:\\d+:\\d+$)`));
  BmA.push(/\((?:node:)?internal\/[^:]+:\d+:\d+\)$/, /\s*at (?:node:)?internal\/[^:]+:\d+:\d+$/, /\/\.node-spawn-wrap-\w+-\w+\/node:\d+:\d+\)?$/);
  class xS1 {
    constructor(A) {
      if (A = {
          ignoredPackages: [],
          ...A
        }, "internals" in A === !1) A.internals = xS1.nodeInternals();
      if ("cwd" in A === !1) A.cwd = wA4;
      this._cwd = A.cwd.replace(/\\/g, "/"), this._internals = [].concat(A.internals, EA4(A.ignoredPackages)), this._wrapCallSite = A.wrapCallSite || !1
    }
    static nodeInternals() {
      return [...BmA]
    }
    clean(A, B = 0) {
      if (B = " ".repeat(B), !Array.isArray(A)) A = A.split(`
`);
      if (!/^\s*at /.test(A[0]) && /^\s*at /.test(A[1])) A = A.slice(1);
      let Q = !1,
        I = null,
        G = [];
      return A.forEach((Z) => {
        if (Z = Z.replace(/\\/g, "/"), this._internals.some((Y) => Y.test(Z))) return;
        let D = /^\s*at /.test(Z);
        if (Q) Z = Z.trimEnd().replace(/^(\s+)at /, "$1");
        else if (Z = Z.trim(), D) Z = Z.slice(3);
        if (Z = Z.replace(`${this._cwd}/`, ""), Z)
          if (D) {
            if (I) G.push(I), I = null;
            G.push(Z)
          } else Q = !0, I = Z
      }), G.map((Z) => `${B}${Z}
`).join("")
    }
    captureString(A, B = this.captureString) {
      if (typeof A === "function") B = A, A = 1 / 0;
      let {
        stackTraceLimit: Q
      } = Error;
      if (A) Error.stackTraceLimit = A;
      let I = {};
      Error.captureStackTrace(I, B);
      let {
        stack: G
      } = I;
      return Error.stackTraceLimit = Q, this.clean(G)
    }
    capture(A, B = this.capture) {
      if (typeof A === "function") B = A, A = 1 / 0;
      let {
        prepareStackTrace: Q,
        stackTraceLimit: I
      } = Error;
      if (Error.prepareStackTrace = (D, Y) => {
          if (this._wrapCallSite) return Y.map(this._wrapCallSite);
          return Y
        }, A) Error.stackTraceLimit = A;
      let G = {};
      Error.captureStackTrace(G, B);
      let {
        stack: Z
      } = G;
      return Object.assign(Error, {
        prepareStackTrace: Q,
        stackTraceLimit: I
      }), Z
    }
    at(A = this.at) {
      let [B] = this.capture(1, A);
      if (!B) return {};
      let Q = {
        line: B.getLineNumber(),
        column: B.getColumnNumber()
      };
      if (AmA(Q, B.getFileName(), this._cwd), B.isConstructor()) Object.defineProperty(Q, "constructor", {
        value: !0,
        configurable: !0
      });
      if (B.isEval()) Q.evalOrigin = B.getEvalOrigin();
      if (B.isNative()) Q.native = !0;
      let I;
      try {
        I = B.getTypeName()
      } catch (D) {}
      if (I && I !== "Object" && I !== "[object Object]") Q.type = I;
      let G = B.getFunctionName();
      if (G) Q.function = G;
      let Z = B.getMethodName();
      if (Z && G !== Z) Q.method = Z;
      return Q
    }
    parseLine(A) {
      let B = A && A.match(UA4);
      if (!B) return null;
      let Q = B[1] === "new",
        I = B[2],
        G = B[3],
        Z = B[4],
        D = Number(B[5]),
        Y = Number(B[6]),
        W = B[7],
        J = B[8],
        F = B[9],
        X = B[10] === "native",
        V = B[11] === ")",
        C, K = {};
      if (J) K.line = Number(J);
      if (F) K.column = Number(F);
      if (V && W) {
        let E = 0;
        for (let N = W.length - 1; N > 0; N--)
          if (W.charAt(N) === ")") E++;
          else if (W.charAt(N) === "(" && W.charAt(N - 1) === " ") {
          if (E--, E === -1 && W.charAt(N - 1) === " ") {
            let q = W.slice(0, N - 1);
            W = W.slice(N + 1), I += ` (${q}`;
            break
          }
        }
      }
      if (I) {
        let E = I.match(NA4);
        if (E) I = E[1], C = E[2]
      }
      if (AmA(K, W, this._cwd), Q) Object.defineProperty(K, "constructor", {
        value: !0,
        configurable: !0
      });
      if (G) K.evalOrigin = G, K.evalLine = D, K.evalColumn = Y, K.evalFile = Z && Z.replace(/\\/g, "/");
      if (X) K.native = !0;
      if (I) K.function = I;
      if (C && I !== C) K.method = C;
      return K
    }
  }

  function AmA(A, B, Q) {
    if (B) {
      if (B = B.replace(/\\/g, "/"), B.startsWith(`${Q}/`)) B = B.slice(Q.length + 1);
      A.file = B
    }
  }

  function EA4(A) {
    if (A.length === 0) return [];
    let B = A.map((Q) => zA4(Q));
    return new RegExp(`[/\\\\]node_modules[/\\\\](?:${B.join("|")})[/\\\\][^:]+:\\d+:\\d+`)
  }
  var UA4 = new RegExp("^(?:\\s*at )?(?:(new) )?(?:(.*?) \\()?(?:eval at ([^ ]+) \\((.+?):(\\d+):(\\d+)\\), )?(?:(.+?):(\\d+):(\\d+)|(native))(\\)?)$"),
    NA4 = /^(.*?) \[as (.*?)\]$/;
  QmA.exports = xS1
})
// @from(Start 2999438, End 3005791)
pmA = z((vB8, umA) => {
  var KL = Z1("constants"),
    J04 = process.cwd,
    P31 = null,
    F04 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
  process.cwd = function() {
    if (!P31) P31 = J04.call(process);
    return P31
  };
  try {
    process.cwd()
  } catch (A) {}
  if (typeof process.chdir === "function") {
    if (S31 = process.chdir, process.chdir = function(A) {
        P31 = null, S31.call(process, A)
      }, Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, S31)
  }
  var S31;
  umA.exports = X04;

  function X04(A) {
    if (KL.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) B(A);
    if (!A.lutimes) Q(A);
    if (A.chown = Z(A.chown), A.fchown = Z(A.fchown), A.lchown = Z(A.lchown), A.chmod = I(A.chmod), A.fchmod = I(A.fchmod), A.lchmod = I(A.lchmod), A.chownSync = D(A.chownSync), A.fchownSync = D(A.fchownSync), A.lchownSync = D(A.lchownSync), A.chmodSync = G(A.chmodSync), A.fchmodSync = G(A.fchmodSync), A.lchmodSync = G(A.lchmodSync), A.stat = Y(A.stat), A.fstat = Y(A.fstat), A.lstat = Y(A.lstat), A.statSync = W(A.statSync), A.fstatSync = W(A.fstatSync), A.lstatSync = W(A.lstatSync), A.chmod && !A.lchmod) A.lchmod = function(F, X, V) {
      if (V) process.nextTick(V)
    }, A.lchmodSync = function() {};
    if (A.chown && !A.lchown) A.lchown = function(F, X, V, C) {
      if (C) process.nextTick(C)
    }, A.lchownSync = function() {};
    if (F04 === "win32") A.rename = typeof A.rename !== "function" ? A.rename : function(F) {
      function X(V, C, K) {
        var E = Date.now(),
          N = 0;
        F(V, C, function q(O) {
          if (O && (O.code === "EACCES" || O.code === "EPERM" || O.code === "EBUSY") && Date.now() - E < 60000) {
            if (setTimeout(function() {
                A.stat(C, function(R, T) {
                  if (R && R.code === "ENOENT") F(V, C, q);
                  else K(O)
                })
              }, N), N < 100) N += 10;
            return
          }
          if (K) K(O)
        })
      }
      if (Object.setPrototypeOf) Object.setPrototypeOf(X, F);
      return X
    }(A.rename);
    A.read = typeof A.read !== "function" ? A.read : function(F) {
      function X(V, C, K, E, N, q) {
        var O;
        if (q && typeof q === "function") {
          var R = 0;
          O = function(T, L, _) {
            if (T && T.code === "EAGAIN" && R < 10) return R++, F.call(A, V, C, K, E, N, O);
            q.apply(this, arguments)
          }
        }
        return F.call(A, V, C, K, E, N, O)
      }
      if (Object.setPrototypeOf) Object.setPrototypeOf(X, F);
      return X
    }(A.read), A.readSync = typeof A.readSync !== "function" ? A.readSync : function(F) {
      return function(X, V, C, K, E) {
        var N = 0;
        while (!0) try {
          return F.call(A, X, V, C, K, E)
        } catch (q) {
          if (q.code === "EAGAIN" && N < 10) {
            N++;
            continue
          }
          throw q
        }
      }
    }(A.readSync);

    function B(F) {
      F.lchmod = function(X, V, C) {
        F.open(X, KL.O_WRONLY | KL.O_SYMLINK, V, function(K, E) {
          if (K) {
            if (C) C(K);
            return
          }
          F.fchmod(E, V, function(N) {
            F.close(E, function(q) {
              if (C) C(N || q)
            })
          })
        })
      }, F.lchmodSync = function(X, V) {
        var C = F.openSync(X, KL.O_WRONLY | KL.O_SYMLINK, V),
          K = !0,
          E;
        try {
          E = F.fchmodSync(C, V), K = !1
        } finally {
          if (K) try {
            F.closeSync(C)
          } catch (N) {} else F.closeSync(C)
        }
        return E
      }
    }

    function Q(F) {
      if (KL.hasOwnProperty("O_SYMLINK") && F.futimes) F.lutimes = function(X, V, C, K) {
        F.open(X, KL.O_SYMLINK, function(E, N) {
          if (E) {
            if (K) K(E);
            return
          }
          F.futimes(N, V, C, function(q) {
            F.close(N, function(O) {
              if (K) K(q || O)
            })
          })
        })
      }, F.lutimesSync = function(X, V, C) {
        var K = F.openSync(X, KL.O_SYMLINK),
          E, N = !0;
        try {
          E = F.futimesSync(K, V, C), N = !1
        } finally {
          if (N) try {
            F.closeSync(K)
          } catch (q) {} else F.closeSync(K)
        }
        return E
      };
      else if (F.futimes) F.lutimes = function(X, V, C, K) {
        if (K) process.nextTick(K)
      }, F.lutimesSync = function() {}
    }

    function I(F) {
      if (!F) return F;
      return function(X, V, C) {
        return F.call(A, X, V, function(K) {
          if (J(K)) K = null;
          if (C) C.apply(this, arguments)
        })
      }
    }

    function G(F) {
      if (!F) return F;
      return function(X, V) {
        try {
          return F.call(A, X, V)
        } catch (C) {
          if (!J(C)) throw C
        }
      }
    }

    function Z(F) {
      if (!F) return F;
      return function(X, V, C, K) {
        return F.call(A, X, V, C, function(E) {
          if (J(E)) E = null;
          if (K) K.apply(this, arguments)
        })
      }
    }

    function D(F) {
      if (!F) return F;
      return function(X, V, C) {
        try {
          return F.call(A, X, V, C)
        } catch (K) {
          if (!J(K)) throw K
        }
      }
    }

    function Y(F) {
      if (!F) return F;
      return function(X, V, C) {
        if (typeof V === "function") C = V, V = null;

        function K(E, N) {
          if (N) {
            if (N.uid < 0) N.uid += 4294967296;
            if (N.gid < 0) N.gid += 4294967296
          }
          if (C) C.apply(this, arguments)
        }
        return V ? F.call(A, X, V, K) : F.call(A, X, K)
      }
    }

    function W(F) {
      if (!F) return F;
      return function(X, V) {
        var C = V ? F.call(A, X, V) : F.call(A, X);
        if (C) {
          if (C.uid < 0) C.uid += 4294967296;
          if (C.gid < 0) C.gid += 4294967296
        }
        return C
      }
    }

    function J(F) {
      if (!F) return !0;
      if (F.code === "ENOSYS") return !0;
      var X = !process.getuid || process.getuid() !== 0;
      if (X) {
        if (F.code === "EINVAL" || F.code === "EPERM") return !0
      }
      return !1
    }
  }
})
// @from(Start 3005797, End 3007921)
imA = z((bB8, lmA) => {
  var cmA = Z1("stream").Stream;
  lmA.exports = V04;

  function V04(A) {
    return {
      ReadStream: B,
      WriteStream: Q
    };

    function B(I, G) {
      if (!(this instanceof B)) return new B(I, G);
      cmA.call(this);
      var Z = this;
      this.path = I, this.fd = null, this.readable = !0, this.paused = !1, this.flags = "r", this.mode = 438, this.bufferSize = 65536, G = G || {};
      var D = Object.keys(G);
      for (var Y = 0, W = D.length; Y < W; Y++) {
        var J = D[Y];
        this[J] = G[J]
      }
      if (this.encoding) this.setEncoding(this.encoding);
      if (this.start !== void 0) {
        if (typeof this.start !== "number") throw TypeError("start must be a Number");
        if (this.end === void 0) this.end = 1 / 0;
        else if (typeof this.end !== "number") throw TypeError("end must be a Number");
        if (this.start > this.end) throw new Error("start must be <= end");
        this.pos = this.start
      }
      if (this.fd !== null) {
        process.nextTick(function() {
          Z._read()
        });
        return
      }
      A.open(this.path, this.flags, this.mode, function(F, X) {
        if (F) {
          Z.emit("error", F), Z.readable = !1;
          return
        }
        Z.fd = X, Z.emit("open", X), Z._read()
      })
    }

    function Q(I, G) {
      if (!(this instanceof Q)) return new Q(I, G);
      cmA.call(this), this.path = I, this.fd = null, this.writable = !0, this.flags = "w", this.encoding = "binary", this.mode = 438, this.bytesWritten = 0, G = G || {};
      var Z = Object.keys(G);
      for (var D = 0, Y = Z.length; D < Y; D++) {
        var W = Z[D];
        this[W] = G[W]
      }
      if (this.start !== void 0) {
        if (typeof this.start !== "number") throw TypeError("start must be a Number");
        if (this.start < 0) throw new Error("start must be >= zero");
        this.pos = this.start
      }
      if (this.busy = !1, this._queue = [], this.fd === null) this._open = A.open, this._queue.push([this._open, this.path, this.flags, this.mode, void 0]), this.flush()
    }
  }
})
// @from(Start 3007927, End 3008387)
amA = z((gB8, nmA) => {
  nmA.exports = K04;
  var C04 = Object.getPrototypeOf || function(A) {
    return A.__proto__
  };

  function K04(A) {
    if (A === null || typeof A !== "object") return A;
    if (A instanceof Object) var B = {
      __proto__: C04(A)
    };
    else var B = Object.create(null);
    return Object.getOwnPropertyNames(A).forEach(function(Q) {
      Object.defineProperty(B, Q, Object.getOwnPropertyDescriptor(A, Q))
    }), B
  }
})
// @from(Start 3008393, End 3016213)
oS1 = z((hB8, rS1) => {
  var N3 = Z1("fs"),
    H04 = pmA(),
    z04 = imA(),
    w04 = amA(),
    _31 = Z1("util"),
    MG, y31;
  if (typeof Symbol === "function" && typeof Symbol.for === "function") MG = Symbol.for("graceful-fs.queue"), y31 = Symbol.for("graceful-fs.previous");
  else MG = "___graceful-fs.queue", y31 = "___graceful-fs.previous";

  function E04() {}

  function rmA(A, B) {
    Object.defineProperty(A, MG, {
      get: function() {
        return B
      }
    })
  }
  var vS = E04;
  if (_31.debuglog) vS = _31.debuglog("gfs4");
  else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) vS = function() {
    var A = _31.format.apply(_31, arguments);
    A = "GFS4: " + A.split(/\n/).join(`
GFS4: `), console.error(A)
  };
  if (!N3[MG]) {
    if (nS1 = global[MG] || [], rmA(N3, nS1), N3.close = function(A) {
        function B(Q, I) {
          return A.call(N3, Q, function(G) {
            if (!G) smA();
            if (typeof I === "function") I.apply(this, arguments)
          })
        }
        return Object.defineProperty(B, y31, {
          value: A
        }), B
      }(N3.close), N3.closeSync = function(A) {
        function B(Q) {
          A.apply(N3, arguments), smA()
        }
        return Object.defineProperty(B, y31, {
          value: A
        }), B
      }(N3.closeSync), /\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) process.on("exit", function() {
      vS(N3[MG]), Z1("assert").equal(N3[MG].length, 0)
    })
  }
  var nS1;
  if (!global[MG]) rmA(global, N3[MG]);
  rS1.exports = aS1(w04(N3));
  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !N3.__patched) rS1.exports = aS1(N3), N3.__patched = !0;

  function aS1(A) {
    H04(A), A.gracefulify = aS1, A.createReadStream = L, A.createWriteStream = _;
    var B = A.readFile;
    A.readFile = Q;

    function Q(x, s, d) {
      if (typeof s === "function") d = s, s = null;
      return F1(x, s, d);

      function F1(X1, v, D1, N1) {
        return B(X1, v, function(u1) {
          if (u1 && (u1.code === "EMFILE" || u1.code === "ENFILE")) Ib([F1, [X1, v, D1], u1, N1 || Date.now(), Date.now()]);
          else if (typeof D1 === "function") D1.apply(this, arguments)
        })
      }
    }
    var I = A.writeFile;
    A.writeFile = G;

    function G(x, s, d, F1) {
      if (typeof d === "function") F1 = d, d = null;
      return X1(x, s, d, F1);

      function X1(v, D1, N1, u1, d1) {
        return I(v, D1, N1, function(YA) {
          if (YA && (YA.code === "EMFILE" || YA.code === "ENFILE")) Ib([X1, [v, D1, N1, u1], YA, d1 || Date.now(), Date.now()]);
          else if (typeof u1 === "function") u1.apply(this, arguments)
        })
      }
    }
    var Z = A.appendFile;
    if (Z) A.appendFile = D;

    function D(x, s, d, F1) {
      if (typeof d === "function") F1 = d, d = null;
      return X1(x, s, d, F1);

      function X1(v, D1, N1, u1, d1) {
        return Z(v, D1, N1, function(YA) {
          if (YA && (YA.code === "EMFILE" || YA.code === "ENFILE")) Ib([X1, [v, D1, N1, u1], YA, d1 || Date.now(), Date.now()]);
          else if (typeof u1 === "function") u1.apply(this, arguments)
        })
      }
    }
    var Y = A.copyFile;
    if (Y) A.copyFile = W;

    function W(x, s, d, F1) {
      if (typeof d === "function") F1 = d, d = 0;
      return X1(x, s, d, F1);

      function X1(v, D1, N1, u1, d1) {
        return Y(v, D1, N1, function(YA) {
          if (YA && (YA.code === "EMFILE" || YA.code === "ENFILE")) Ib([X1, [v, D1, N1, u1], YA, d1 || Date.now(), Date.now()]);
          else if (typeof u1 === "function") u1.apply(this, arguments)
        })
      }
    }
    var J = A.readdir;
    A.readdir = X;
    var F = /^v[0-5]\./;

    function X(x, s, d) {
      if (typeof s === "function") d = s, s = null;
      var F1 = F.test(process.version) ? function v(D1, N1, u1, d1) {
        return J(D1, X1(D1, N1, u1, d1))
      } : function v(D1, N1, u1, d1) {
        return J(D1, N1, X1(D1, N1, u1, d1))
      };
      return F1(x, s, d);

      function X1(v, D1, N1, u1) {
        return function(d1, YA) {
          if (d1 && (d1.code === "EMFILE" || d1.code === "ENFILE")) Ib([F1, [v, D1, N1], d1, u1 || Date.now(), Date.now()]);
          else {
            if (YA && YA.sort) YA.sort();
            if (typeof N1 === "function") N1.call(this, d1, YA)
          }
        }
      }
    }
    if (process.version.substr(0, 4) === "v0.8") {
      var V = z04(A);
      q = V.ReadStream, R = V.WriteStream
    }
    var C = A.ReadStream;
    if (C) q.prototype = Object.create(C.prototype), q.prototype.open = O;
    var K = A.WriteStream;
    if (K) R.prototype = Object.create(K.prototype), R.prototype.open = T;
    Object.defineProperty(A, "ReadStream", {
      get: function() {
        return q
      },
      set: function(x) {
        q = x
      },
      enumerable: !0,
      configurable: !0
    }), Object.defineProperty(A, "WriteStream", {
      get: function() {
        return R
      },
      set: function(x) {
        R = x
      },
      enumerable: !0,
      configurable: !0
    });
    var E = q;
    Object.defineProperty(A, "FileReadStream", {
      get: function() {
        return E
      },
      set: function(x) {
        E = x
      },
      enumerable: !0,
      configurable: !0
    });
    var N = R;
    Object.defineProperty(A, "FileWriteStream", {
      get: function() {
        return N
      },
      set: function(x) {
        N = x
      },
      enumerable: !0,
      configurable: !0
    });

    function q(x, s) {
      if (this instanceof q) return C.apply(this, arguments), this;
      else return q.apply(Object.create(q.prototype), arguments)
    }

    function O() {
      var x = this;
      i(x.path, x.flags, x.mode, function(s, d) {
        if (s) {
          if (x.autoClose) x.destroy();
          x.emit("error", s)
        } else x.fd = d, x.emit("open", d), x.read()
      })
    }

    function R(x, s) {
      if (this instanceof R) return K.apply(this, arguments), this;
      else return R.apply(Object.create(R.prototype), arguments)
    }

    function T() {
      var x = this;
      i(x.path, x.flags, x.mode, function(s, d) {
        if (s) x.destroy(), x.emit("error", s);
        else x.fd = d, x.emit("open", d)
      })
    }

    function L(x, s) {
      return new A.ReadStream(x, s)
    }

    function _(x, s) {
      return new A.WriteStream(x, s)
    }
    var k = A.open;
    A.open = i;

    function i(x, s, d, F1) {
      if (typeof d === "function") F1 = d, d = null;
      return X1(x, s, d, F1);

      function X1(v, D1, N1, u1, d1) {
        return k(v, D1, N1, function(YA, bA) {
          if (YA && (YA.code === "EMFILE" || YA.code === "ENFILE")) Ib([X1, [v, D1, N1, u1], YA, d1 || Date.now(), Date.now()]);
          else if (typeof u1 === "function") u1.apply(this, arguments)
        })
      }
    }
    return A
  }

  function Ib(A) {
    vS("ENQUEUE", A[0].name, A[1]), N3[MG].push(A), sS1()
  }
  var j31;

  function smA() {
    var A = Date.now();
    for (var B = 0; B < N3[MG].length; ++B)
      if (N3[MG][B].length > 2) N3[MG][B][3] = A, N3[MG][B][4] = A;
    sS1()
  }

  function sS1() {
    if (clearTimeout(j31), j31 = void 0, N3[MG].length === 0) return;
    var A = N3[MG].shift(),
      B = A[0],
      Q = A[1],
      I = A[2],
      G = A[3],
      Z = A[4];
    if (G === void 0) vS("RETRY", B.name, Q), B.apply(null, Q);
    else if (Date.now() - G >= 60000) {
      vS("TIMEOUT", B.name, Q);
      var D = Q.pop();
      if (typeof D === "function") D.call(null, I)
    } else {
      var Y = Date.now() - Z,
        W = Math.max(Z - G, 1),
        J = Math.min(W * 1.2, 100);
      if (Y >= J) vS("RETRY", B.name, Q), B.apply(null, Q.concat([G]));
      else N3[MG].push(A)
    }
    if (j31 === void 0) j31 = setTimeout(sS1, 0)
  }
})
// @from(Start 3016219, End 3019115)
tmA = z((mB8, omA) => {
  function IX(A, B) {
    if (typeof B === "boolean") B = {
      forever: B
    };
    if (this._originalTimeouts = JSON.parse(JSON.stringify(A)), this._timeouts = A, this._options = B || {}, this._maxRetryTime = B && B.maxRetryTime || 1 / 0, this._fn = null, this._errors = [], this._attempts = 1, this._operationTimeout = null, this._operationTimeoutCb = null, this._timeout = null, this._operationStart = null, this._options.forever) this._cachedTimeouts = this._timeouts.slice(0)
  }
  omA.exports = IX;
  IX.prototype.reset = function() {
    this._attempts = 1, this._timeouts = this._originalTimeouts
  };
  IX.prototype.stop = function() {
    if (this._timeout) clearTimeout(this._timeout);
    this._timeouts = [], this._cachedTimeouts = null
  };
  IX.prototype.retry = function(A) {
    if (this._timeout) clearTimeout(this._timeout);
    if (!A) return !1;
    var B = new Date().getTime();
    if (A && B - this._operationStart >= this._maxRetryTime) return this._errors.unshift(new Error("RetryOperation timeout occurred")), !1;
    this._errors.push(A);
    var Q = this._timeouts.shift();
    if (Q === void 0)
      if (this._cachedTimeouts) this._errors.splice(this._errors.length - 1, this._errors.length), this._timeouts = this._cachedTimeouts.slice(0), Q = this._timeouts.shift();
      else return !1;
    var I = this,
      G = setTimeout(function() {
        if (I._attempts++, I._operationTimeoutCb) {
          if (I._timeout = setTimeout(function() {
              I._operationTimeoutCb(I._attempts)
            }, I._operationTimeout), I._options.unref) I._timeout.unref()
        }
        I._fn(I._attempts)
      }, Q);
    if (this._options.unref) G.unref();
    return !0
  };
  IX.prototype.attempt = function(A, B) {
    if (this._fn = A, B) {
      if (B.timeout) this._operationTimeout = B.timeout;
      if (B.cb) this._operationTimeoutCb = B.cb
    }
    var Q = this;
    if (this._operationTimeoutCb) this._timeout = setTimeout(function() {
      Q._operationTimeoutCb()
    }, Q._operationTimeout);
    this._operationStart = new Date().getTime(), this._fn(this._attempts)
  };
  IX.prototype.try = function(A) {
    console.log("Using RetryOperation.try() is deprecated"), this.attempt(A)
  };
  IX.prototype.start = function(A) {
    console.log("Using RetryOperation.start() is deprecated"), this.attempt(A)
  };
  IX.prototype.start = IX.prototype.try;
  IX.prototype.errors = function() {
    return this._errors
  };
  IX.prototype.attempts = function() {
    return this._attempts
  };
  IX.prototype.mainError = function() {
    if (this._errors.length === 0) return null;
    var A = {},
      B = null,
      Q = 0;
    for (var I = 0; I < this._errors.length; I++) {
      var G = this._errors[I],
        Z = G.message,
        D = (A[Z] || 0) + 1;
      if (A[Z] = D, D >= Q) B = G, Q = D
    }
    return B
  }
})
// @from(Start 3019121, End 3020790)
AdA = z((N04) => {
  var U04 = tmA();
  N04.operation = function(A) {
    var B = N04.timeouts(A);
    return new U04(B, {
      forever: A && A.forever,
      unref: A && A.unref,
      maxRetryTime: A && A.maxRetryTime
    })
  };
  N04.timeouts = function(A) {
    if (A instanceof Array) return [].concat(A);
    var B = {
      retries: 10,
      factor: 2,
      minTimeout: 1000,
      maxTimeout: 1 / 0,
      randomize: !1
    };
    for (var Q in A) B[Q] = A[Q];
    if (B.minTimeout > B.maxTimeout) throw new Error("minTimeout is greater than maxTimeout");
    var I = [];
    for (var G = 0; G < B.retries; G++) I.push(this.createTimeout(G, B));
    if (A && A.forever && !I.length) I.push(this.createTimeout(G, B));
    return I.sort(function(Z, D) {
      return Z - D
    }), I
  };
  N04.createTimeout = function(A, B) {
    var Q = B.randomize ? Math.random() + 1 : 1,
      I = Math.round(Q * B.minTimeout * Math.pow(B.factor, A));
    return I = Math.min(I, B.maxTimeout), I
  };
  N04.wrap = function(A, B, Q) {
    if (B instanceof Array) Q = B, B = null;
    if (!Q) {
      Q = [];
      for (var I in A)
        if (typeof A[I] === "function") Q.push(I)
    }
    for (var G = 0; G < Q.length; G++) {
      var Z = Q[G],
        D = A[Z];
      A[Z] = function Y(W) {
        var J = N04.operation(B),
          F = Array.prototype.slice.call(arguments, 1),
          X = F.pop();
        F.push(function(V) {
          if (J.retry(V)) return;
          if (V) arguments[0] = J.mainError();
          X.apply(this, arguments)
        }), J.attempt(function() {
          W.apply(A, F)
        })
      }.bind(A, D), A[Z].options = B
    }
  }
})
// @from(Start 3020796, End 3021144)
BdA = z((uB8, k31) => {
  k31.exports = ["SIGABRT", "SIGALRM", "SIGHUP", "SIGINT", "SIGTERM"];
  if (process.platform !== "win32") k31.exports.push("SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
  if (process.platform === "linux") k31.exports.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED")
})
// @from(Start 3021150, End 3024077)
QdA = z((pB8, Zb) => {
  var sB = global.process,
    bS = function(A) {
      return A && typeof A === "object" && typeof A.removeListener === "function" && typeof A.emit === "function" && typeof A.reallyExit === "function" && typeof A.listeners === "function" && typeof A.kill === "function" && typeof A.pid === "number" && typeof A.on === "function"
    };
  if (!bS(sB)) Zb.exports = function() {
    return function() {}
  };
  else {
    if (tS1 = Z1("assert"), gS = BdA(), eS1 = /^win/i.test(sB.platform), Gb = Z1("events"), typeof Gb !== "function") Gb = Gb.EventEmitter;
    if (sB.__signal_exit_emitter__) h7 = sB.__signal_exit_emitter__;
    else h7 = sB.__signal_exit_emitter__ = new Gb, h7.count = 0, h7.emitted = {};
    if (!h7.infinite) h7.setMaxListeners(1 / 0), h7.infinite = !0;
    Zb.exports = function(A, B) {
      if (!bS(global.process)) return function() {};
      if (tS1.equal(typeof A, "function", "a callback must be provided for exit handler"), hS === !1) x31();
      var Q = "exit";
      if (B && B.alwaysLast) Q = "afterexit";
      var I = function() {
        if (h7.removeListener(Q, A), h7.listeners("exit").length === 0 && h7.listeners("afterexit").length === 0) bn()
      };
      return h7.on(Q, A), I
    }, bn = function A() {
      if (!hS || !bS(global.process)) return;
      hS = !1, gS.forEach(function(B) {
        try {
          sB.removeListener(B, gn[B])
        } catch (Q) {}
      }), sB.emit = hn, sB.reallyExit = f31, h7.count -= 1
    }, Zb.exports.unload = bn, HL = function A(B, Q, I) {
      if (h7.emitted[B]) return;
      h7.emitted[B] = !0, h7.emit(B, Q, I)
    }, gn = {}, gS.forEach(function(A) {
      gn[A] = function B() {
        if (!bS(global.process)) return;
        var Q = sB.listeners(A);
        if (Q.length === h7.count) {
          if (bn(), HL("exit", null, A), HL("afterexit", null, A), eS1 && A === "SIGHUP") A = "SIGINT";
          sB.kill(sB.pid, A)
        }
      }
    }), Zb.exports.signals = function() {
      return gS
    }, hS = !1, x31 = function A() {
      if (hS || !bS(global.process)) return;
      hS = !0, h7.count += 1, gS = gS.filter(function(B) {
        try {
          return sB.on(B, gn[B]), !0
        } catch (Q) {
          return !1
        }
      }), sB.emit = B_1, sB.reallyExit = A_1
    }, Zb.exports.load = x31, f31 = sB.reallyExit, A_1 = function A(B) {
      if (!bS(global.process)) return;
      sB.exitCode = B || 0, HL("exit", sB.exitCode, null), HL("afterexit", sB.exitCode, null), f31.call(sB, sB.exitCode)
    }, hn = sB.emit, B_1 = function A(B, Q) {
      if (B === "exit" && bS(global.process)) {
        if (Q !== void 0) sB.exitCode = Q;
        var I = hn.apply(this, arguments);
        return HL("exit", sB.exitCode, null), HL("afterexit", sB.exitCode, null), I
      } else return hn.apply(this, arguments)
    }
  }
  var tS1, gS, eS1, Gb, h7, bn, HL, gn, hS, x31, f31, A_1, hn, B_1
})
// @from(Start 3024083, End 3024789)
GdA = z((O04, Q_1) => {
  var IdA = Symbol();

  function L04(A, B, Q) {
    let I = B[IdA];
    if (I) return B.stat(A, (Z, D) => {
      if (Z) return Q(Z);
      Q(null, D.mtime, I)
    });
    let G = new Date(Math.ceil(Date.now() / 1000) * 1000 + 5);
    B.utimes(A, G, G, (Z) => {
      if (Z) return Q(Z);
      B.stat(A, (D, Y) => {
        if (D) return Q(D);
        let W = Y.mtime.getTime() % 1000 === 0 ? "s" : "ms";
        Object.defineProperty(B, IdA, {
          value: W
        }), Q(null, Y.mtime, W)
      })
    })
  }

  function R04(A) {
    let B = Date.now();
    if (A === "s") B = Math.ceil(B / 1000) * 1000;
    return new Date(B)
  }
  O04.probe = L04;
  O04.getMtime = R04
})
// @from(Start 3024795, End 3029908)
JdA = z((f04, dn) => {
  var S04 = Z1("path"),
    Z_1 = oS1(),
    _04 = AdA(),
    j04 = QdA(),
    ZdA = GdA(),
    IN = {};

  function mn(A, B) {
    return B.lockfilePath || `${A}.lock`
  }

  function D_1(A, B, Q) {
    if (!B.realpath) return Q(null, S04.resolve(A));
    B.fs.realpath(A, Q)
  }

  function G_1(A, B, Q) {
    let I = mn(A, B);
    B.fs.mkdir(I, (G) => {
      if (!G) return ZdA.probe(I, B.fs, (Z, D, Y) => {
        if (Z) return B.fs.rmdir(I, () => {}), Q(Z);
        Q(null, D, Y)
      });
      if (G.code !== "EEXIST") return Q(G);
      if (B.stale <= 0) return Q(Object.assign(new Error("Lock file is already being held"), {
        code: "ELOCKED",
        file: A
      }));
      B.fs.stat(I, (Z, D) => {
        if (Z) {
          if (Z.code === "ENOENT") return G_1(A, {
            ...B,
            stale: 0
          }, Q);
          return Q(Z)
        }
        if (!DdA(D, B)) return Q(Object.assign(new Error("Lock file is already being held"), {
          code: "ELOCKED",
          file: A
        }));
        YdA(A, B, (Y) => {
          if (Y) return Q(Y);
          G_1(A, {
            ...B,
            stale: 0
          }, Q)
        })
      })
    })
  }

  function DdA(A, B) {
    return A.mtime.getTime() < Date.now() - B.stale
  }

  function YdA(A, B, Q) {
    B.fs.rmdir(mn(A, B), (I) => {
      if (I && I.code !== "ENOENT") return Q(I);
      Q()
    })
  }

  function v31(A, B) {
    let Q = IN[A];
    if (Q.updateTimeout) return;
    if (Q.updateDelay = Q.updateDelay || B.update, Q.updateTimeout = setTimeout(() => {
        Q.updateTimeout = null, B.fs.stat(Q.lockfilePath, (I, G) => {
          let Z = Q.lastUpdate + B.stale < Date.now();
          if (I) {
            if (I.code === "ENOENT" || Z) return I_1(A, Q, Object.assign(I, {
              code: "ECOMPROMISED"
            }));
            return Q.updateDelay = 1000, v31(A, B)
          }
          if (Q.mtime.getTime() !== G.mtime.getTime()) return I_1(A, Q, Object.assign(new Error("Unable to update lock within the stale threshold"), {
            code: "ECOMPROMISED"
          }));
          let Y = ZdA.getMtime(Q.mtimePrecision);
          B.fs.utimes(Q.lockfilePath, Y, Y, (W) => {
            let J = Q.lastUpdate + B.stale < Date.now();
            if (Q.released) return;
            if (W) {
              if (W.code === "ENOENT" || J) return I_1(A, Q, Object.assign(W, {
                code: "ECOMPROMISED"
              }));
              return Q.updateDelay = 1000, v31(A, B)
            }
            Q.mtime = Y, Q.lastUpdate = Date.now(), Q.updateDelay = null, v31(A, B)
          })
        })
      }, Q.updateDelay), Q.updateTimeout.unref) Q.updateTimeout.unref()
  }

  function I_1(A, B, Q) {
    if (B.released = !0, B.updateTimeout) clearTimeout(B.updateTimeout);
    if (IN[A] === B) delete IN[A];
    B.options.onCompromised(Q)
  }

  function y04(A, B, Q) {
    B = {
      stale: 1e4,
      update: null,
      realpath: !0,
      retries: 0,
      fs: Z_1,
      onCompromised: (I) => {
        throw I
      },
      ...B
    }, B.retries = B.retries || 0, B.retries = typeof B.retries === "number" ? {
      retries: B.retries
    } : B.retries, B.stale = Math.max(B.stale || 0, 2000), B.update = B.update == null ? B.stale / 2 : B.update || 0, B.update = Math.max(Math.min(B.update, B.stale / 2), 1000), D_1(A, B, (I, G) => {
      if (I) return Q(I);
      let Z = _04.operation(B.retries);
      Z.attempt(() => {
        G_1(G, B, (D, Y, W) => {
          if (Z.retry(D)) return;
          if (D) return Q(Z.mainError());
          let J = IN[G] = {
            lockfilePath: mn(G, B),
            mtime: Y,
            mtimePrecision: W,
            options: B,
            lastUpdate: Date.now()
          };
          v31(G, B), Q(null, (F) => {
            if (J.released) return F && F(Object.assign(new Error("Lock is already released"), {
              code: "ERELEASED"
            }));
            WdA(G, {
              ...B,
              realpath: !1
            }, F)
          })
        })
      })
    })
  }

  function WdA(A, B, Q) {
    B = {
      fs: Z_1,
      realpath: !0,
      ...B
    }, D_1(A, B, (I, G) => {
      if (I) return Q(I);
      let Z = IN[G];
      if (!Z) return Q(Object.assign(new Error("Lock is not acquired/owned by you"), {
        code: "ENOTACQUIRED"
      }));
      Z.updateTimeout && clearTimeout(Z.updateTimeout), Z.released = !0, delete IN[G], YdA(G, B, Q)
    })
  }

  function k04(A, B, Q) {
    B = {
      stale: 1e4,
      realpath: !0,
      fs: Z_1,
      ...B
    }, B.stale = Math.max(B.stale || 0, 2000), D_1(A, B, (I, G) => {
      if (I) return Q(I);
      B.fs.stat(mn(G, B), (Z, D) => {
        if (Z) return Z.code === "ENOENT" ? Q(null, !1) : Q(Z);
        return Q(null, !DdA(D, B))
      })
    })
  }

  function x04() {
    return IN
  }
  j04(() => {
    for (let A in IN) {
      let B = IN[A].options;
      try {
        B.fs.rmdirSync(mn(A, B))
      } catch (Q) {}
    }
  });
  f04.lock = y04;
  f04.unlock = WdA;
  f04.check = k04;
  f04.getLocks = x04
})
// @from(Start 3029914, End 3031050)
XdA = z((cB8, FdA) => {
  var m04 = oS1();

  function d04(A) {
    let B = ["mkdir", "realpath", "stat", "rmdir", "utimes"],
      Q = {
        ...A
      };
    return B.forEach((I) => {
      Q[I] = (...G) => {
        let Z = G.pop(),
          D;
        try {
          D = A[`${I}Sync`](...G)
        } catch (Y) {
          return Z(Y)
        }
        Z(null, D)
      }
    }), Q
  }

  function u04(A) {
    return (...B) => new Promise((Q, I) => {
      B.push((G, Z) => {
        if (G) I(G);
        else Q(Z)
      }), A(...B)
    })
  }

  function p04(A) {
    return (...B) => {
      let Q, I;
      if (B.push((G, Z) => {
          Q = G, I = Z
        }), A(...B), Q) throw Q;
      return I
    }
  }

  function c04(A) {
    if (A = {
        ...A
      }, A.fs = d04(A.fs || m04), typeof A.retries === "number" && A.retries > 0 || A.retries && typeof A.retries.retries === "number" && A.retries.retries > 0) throw Object.assign(new Error("Cannot use retries with the sync api"), {
      code: "ESYNC"
    });
    return A
  }
  FdA.exports = {
    toPromise: u04,
    toSync: p04,
    toSyncOptions: c04
  }
})
// @from(Start 3031056, End 3031793)
W_1 = z((lB8, zL) => {
  var Db = JdA(),
    {
      toPromise: b31,
      toSync: g31,
      toSyncOptions: Y_1
    } = XdA();
  async function VdA(A, B) {
    let Q = await b31(Db.lock)(A, B);
    return b31(Q)
  }

  function l04(A, B) {
    let Q = g31(Db.lock)(A, Y_1(B));
    return g31(Q)
  }

  function i04(A, B) {
    return b31(Db.unlock)(A, B)
  }

  function n04(A, B) {
    return g31(Db.unlock)(A, Y_1(B))
  }

  function a04(A, B) {
    return b31(Db.check)(A, B)
  }

  function s04(A, B) {
    return g31(Db.check)(A, Y_1(B))
  }
  zL.exports = VdA;
  zL.exports.lock = VdA;
  zL.exports.unlock = i04;
  zL.exports.lockSync = l04;
  zL.exports.unlockSync = n04;
  zL.exports.check = a04;
  zL.exports.checkSync = s04
})
// @from(Start 3031799, End 3034582)
_dA = z((z38, SdA) => {
  var {
    defineProperty: d31,
    getOwnPropertyDescriptor: A24,
    getOwnPropertyNames: B24
  } = Object, Q24 = Object.prototype.hasOwnProperty, u31 = (A, B) => d31(A, "name", {
    value: B,
    configurable: !0
  }), I24 = (A, B) => {
    for (var Q in B) d31(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, G24 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of B24(B))
        if (!Q24.call(A, G) && G !== Q) d31(A, G, {
          get: () => B[G],
          enumerable: !(I = A24(B, G)) || I.enumerable
        })
    }
    return A
  }, Z24 = (A) => G24(d31({}, "__esModule", {
    value: !0
  }), A), $dA = {};
  I24($dA, {
    AlgorithmId: () => RdA,
    EndpointURLScheme: () => LdA,
    FieldPosition: () => OdA,
    HttpApiKeyAuthLocation: () => MdA,
    HttpAuthLocation: () => qdA,
    IniSectionType: () => TdA,
    RequestHandlerProtocol: () => PdA,
    SMITHY_CONTEXT_KEY: () => F24,
    getDefaultClientConfiguration: () => W24,
    resolveDefaultRuntimeConfig: () => J24
  });
  SdA.exports = Z24($dA);
  var qdA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(qdA || {}),
    MdA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(MdA || {}),
    LdA = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(LdA || {}),
    RdA = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(RdA || {}),
    D24 = u31((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    Y24 = u31((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    W24 = u31((A) => {
      return D24(A)
    }, "getDefaultClientConfiguration"),
    J24 = u31((A) => {
      return Y24(A)
    }, "resolveDefaultRuntimeConfig"),
    OdA = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(OdA || {}),
    F24 = "__smithy_context",
    TdA = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(TdA || {}),
    PdA = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(PdA || {})
})
// @from(Start 3034588, End 3039095)
vdA = z((w38, fdA) => {
  var {
    defineProperty: p31,
    getOwnPropertyDescriptor: X24,
    getOwnPropertyNames: V24
  } = Object, C24 = Object.prototype.hasOwnProperty, wL = (A, B) => p31(A, "name", {
    value: B,
    configurable: !0
  }), K24 = (A, B) => {
    for (var Q in B) p31(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, H24 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of V24(B))
        if (!C24.call(A, G) && G !== Q) p31(A, G, {
          get: () => B[G],
          enumerable: !(I = X24(B, G)) || I.enumerable
        })
    }
    return A
  }, z24 = (A) => H24(p31({}, "__esModule", {
    value: !0
  }), A), jdA = {};
  K24(jdA, {
    Field: () => U24,
    Fields: () => N24,
    HttpRequest: () => $24,
    HttpResponse: () => q24,
    IHttpRequest: () => ydA.HttpRequest,
    getHttpHandlerExtensionConfiguration: () => w24,
    isValidHostname: () => xdA,
    resolveHttpHandlerRuntimeConfig: () => E24
  });
  fdA.exports = z24(jdA);
  var w24 = wL((A) => {
      return {
        setHttpHandler(B) {
          A.httpHandler = B
        },
        httpHandler() {
          return A.httpHandler
        },
        updateHttpClientConfig(B, Q) {
          A.httpHandler?.updateHttpClientConfig(B, Q)
        },
        httpHandlerConfigs() {
          return A.httpHandler.httpHandlerConfigs()
        }
      }
    }, "getHttpHandlerExtensionConfiguration"),
    E24 = wL((A) => {
      return {
        httpHandler: A.httpHandler()
      }
    }, "resolveHttpHandlerRuntimeConfig"),
    ydA = _dA(),
    U24 = class {
      static {
        wL(this, "Field")
      }
      constructor({
        name: A,
        kind: B = ydA.FieldPosition.HEADER,
        values: Q = []
      }) {
        this.name = A, this.kind = B, this.values = Q
      }
      add(A) {
        this.values.push(A)
      }
      set(A) {
        this.values = A
      }
      remove(A) {
        this.values = this.values.filter((B) => B !== A)
      }
      toString() {
        return this.values.map((A) => A.includes(",") || A.includes(" ") ? `"${A}"` : A).join(", ")
      }
      get() {
        return this.values
      }
    },
    N24 = class {
      constructor({
        fields: A = [],
        encoding: B = "utf-8"
      }) {
        this.entries = {}, A.forEach(this.setField.bind(this)), this.encoding = B
      }
      static {
        wL(this, "Fields")
      }
      setField(A) {
        this.entries[A.name.toLowerCase()] = A
      }
      getField(A) {
        return this.entries[A.toLowerCase()]
      }
      removeField(A) {
        delete this.entries[A.toLowerCase()]
      }
      getByType(A) {
        return Object.values(this.entries).filter((B) => B.kind === A)
      }
    },
    $24 = class A {
      static {
        wL(this, "HttpRequest")
      }
      constructor(B) {
        this.method = B.method || "GET", this.hostname = B.hostname || "localhost", this.port = B.port, this.query = B.query || {}, this.headers = B.headers || {}, this.body = B.body, this.protocol = B.protocol ? B.protocol.slice(-1) !== ":" ? `${B.protocol}:` : B.protocol : "https:", this.path = B.path ? B.path.charAt(0) !== "/" ? `/${B.path}` : B.path : "/", this.username = B.username, this.password = B.password, this.fragment = B.fragment
      }
      static clone(B) {
        let Q = new A({
          ...B,
          headers: {
            ...B.headers
          }
        });
        if (Q.query) Q.query = kdA(Q.query);
        return Q
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return "method" in Q && "protocol" in Q && "hostname" in Q && "path" in Q && typeof Q.query === "object" && typeof Q.headers === "object"
      }
      clone() {
        return A.clone(this)
      }
    };

  function kdA(A) {
    return Object.keys(A).reduce((B, Q) => {
      let I = A[Q];
      return {
        ...B,
        [Q]: Array.isArray(I) ? [...I] : I
      }
    }, {})
  }
  wL(kdA, "cloneQuery");
  var q24 = class {
    static {
      wL(this, "HttpResponse")
    }
    constructor(A) {
      this.statusCode = A.statusCode, this.reason = A.reason, this.headers = A.headers || {}, this.body = A.body
    }
    static isInstance(A) {
      if (!A) return !1;
      let B = A;
      return typeof B.statusCode === "number" && typeof B.headers === "object"
    }
  };

  function xdA(A) {
    return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(A)
  }
  wL(xdA, "isValidHostname")
})
// @from(Start 3039101, End 3040964)
cS = z(($38, ddA) => {
  var {
    defineProperty: l31,
    getOwnPropertyDescriptor: M24,
    getOwnPropertyNames: L24
  } = Object, R24 = Object.prototype.hasOwnProperty, c31 = (A, B) => l31(A, "name", {
    value: B,
    configurable: !0
  }), O24 = (A, B) => {
    for (var Q in B) l31(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, T24 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of L24(B))
        if (!R24.call(A, G) && G !== Q) l31(A, G, {
          get: () => B[G],
          enumerable: !(I = M24(B, G)) || I.enumerable
        })
    }
    return A
  }, P24 = (A) => T24(l31({}, "__esModule", {
    value: !0
  }), A), bdA = {};
  O24(bdA, {
    getHostHeaderPlugin: () => _24,
    hostHeaderMiddleware: () => hdA,
    hostHeaderMiddlewareOptions: () => mdA,
    resolveHostHeaderConfig: () => gdA
  });
  ddA.exports = P24(bdA);
  var S24 = vdA();

  function gdA(A) {
    return A
  }
  c31(gdA, "resolveHostHeaderConfig");
  var hdA = c31((A) => (B) => async (Q) => {
      if (!S24.HttpRequest.isInstance(Q.request)) return B(Q);
      let {
        request: I
      } = Q, {
        handlerProtocol: G = ""
      } = A.requestHandler.metadata || {};
      if (G.indexOf("h2") >= 0 && !I.headers[":authority"]) delete I.headers.host, I.headers[":authority"] = I.hostname + (I.port ? ":" + I.port : "");
      else if (!I.headers.host) {
        let Z = I.hostname;
        if (I.port != null) Z += `:${I.port}`;
        I.headers.host = Z
      }
      return B(Q)
    }, "hostHeaderMiddleware"),
    mdA = {
      name: "hostHeaderMiddleware",
      step: "build",
      priority: "low",
      tags: ["HOST"],
      override: !0
    },
    _24 = c31((A) => ({
      applyToStack: c31((B) => {
        B.add(hdA(A), mdA)
      }, "applyToStack")
    }), "getHostHeaderPlugin")
})
// @from(Start 3040970, End 3043269)
lS = z((q38, ldA) => {
  var {
    defineProperty: i31,
    getOwnPropertyDescriptor: j24,
    getOwnPropertyNames: y24
  } = Object, k24 = Object.prototype.hasOwnProperty, X_1 = (A, B) => i31(A, "name", {
    value: B,
    configurable: !0
  }), x24 = (A, B) => {
    for (var Q in B) i31(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, f24 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of y24(B))
        if (!k24.call(A, G) && G !== Q) i31(A, G, {
          get: () => B[G],
          enumerable: !(I = j24(B, G)) || I.enumerable
        })
    }
    return A
  }, v24 = (A) => f24(i31({}, "__esModule", {
    value: !0
  }), A), udA = {};
  x24(udA, {
    getLoggerPlugin: () => b24,
    loggerMiddleware: () => pdA,
    loggerMiddlewareOptions: () => cdA
  });
  ldA.exports = v24(udA);
  var pdA = X_1(() => (A, B) => async (Q) => {
      try {
        let I = await A(Q),
          {
            clientName: G,
            commandName: Z,
            logger: D,
            dynamoDbDocumentClientOptions: Y = {}
          } = B,
          {
            overrideInputFilterSensitiveLog: W,
            overrideOutputFilterSensitiveLog: J
          } = Y,
          F = W ?? B.inputFilterSensitiveLog,
          X = J ?? B.outputFilterSensitiveLog,
          {
            $metadata: V,
            ...C
          } = I.output;
        return D?.info?.({
          clientName: G,
          commandName: Z,
          input: F(Q.input),
          output: X(C),
          metadata: V
        }), I
      } catch (I) {
        let {
          clientName: G,
          commandName: Z,
          logger: D,
          dynamoDbDocumentClientOptions: Y = {}
        } = B, {
          overrideInputFilterSensitiveLog: W
        } = Y, J = W ?? B.inputFilterSensitiveLog;
        throw D?.error?.({
          clientName: G,
          commandName: Z,
          input: J(Q.input),
          error: I,
          metadata: I.$metadata
        }), I
      }
    }, "loggerMiddleware"),
    cdA = {
      name: "loggerMiddleware",
      tags: ["LOGGER"],
      step: "initialize",
      override: !0
    },
    b24 = X_1((A) => ({
      applyToStack: X_1((B) => {
        B.add(pdA(), cdA)
      }, "applyToStack")
    }), "getLoggerPlugin")
})
// @from(Start 3043275, End 3046058)
BuA = z((M38, AuA) => {
  var {
    defineProperty: n31,
    getOwnPropertyDescriptor: g24,
    getOwnPropertyNames: h24
  } = Object, m24 = Object.prototype.hasOwnProperty, a31 = (A, B) => n31(A, "name", {
    value: B,
    configurable: !0
  }), d24 = (A, B) => {
    for (var Q in B) n31(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, u24 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of h24(B))
        if (!m24.call(A, G) && G !== Q) n31(A, G, {
          get: () => B[G],
          enumerable: !(I = g24(B, G)) || I.enumerable
        })
    }
    return A
  }, p24 = (A) => u24(n31({}, "__esModule", {
    value: !0
  }), A), idA = {};
  d24(idA, {
    AlgorithmId: () => rdA,
    EndpointURLScheme: () => sdA,
    FieldPosition: () => odA,
    HttpApiKeyAuthLocation: () => adA,
    HttpAuthLocation: () => ndA,
    IniSectionType: () => tdA,
    RequestHandlerProtocol: () => edA,
    SMITHY_CONTEXT_KEY: () => a24,
    getDefaultClientConfiguration: () => i24,
    resolveDefaultRuntimeConfig: () => n24
  });
  AuA.exports = p24(idA);
  var ndA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(ndA || {}),
    adA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(adA || {}),
    sdA = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(sdA || {}),
    rdA = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(rdA || {}),
    c24 = a31((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    l24 = a31((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    i24 = a31((A) => {
      return c24(A)
    }, "getDefaultClientConfiguration"),
    n24 = a31((A) => {
      return l24(A)
    }, "resolveDefaultRuntimeConfig"),
    odA = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(odA || {}),
    a24 = "__smithy_context",
    tdA = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(tdA || {}),
    edA = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(edA || {})
})
// @from(Start 3046064, End 3050571)
YuA = z((L38, DuA) => {
  var {
    defineProperty: s31,
    getOwnPropertyDescriptor: s24,
    getOwnPropertyNames: r24
  } = Object, o24 = Object.prototype.hasOwnProperty, EL = (A, B) => s31(A, "name", {
    value: B,
    configurable: !0
  }), t24 = (A, B) => {
    for (var Q in B) s31(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, e24 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of r24(B))
        if (!o24.call(A, G) && G !== Q) s31(A, G, {
          get: () => B[G],
          enumerable: !(I = s24(B, G)) || I.enumerable
        })
    }
    return A
  }, A94 = (A) => e24(s31({}, "__esModule", {
    value: !0
  }), A), QuA = {};
  t24(QuA, {
    Field: () => I94,
    Fields: () => G94,
    HttpRequest: () => Z94,
    HttpResponse: () => D94,
    IHttpRequest: () => IuA.HttpRequest,
    getHttpHandlerExtensionConfiguration: () => B94,
    isValidHostname: () => ZuA,
    resolveHttpHandlerRuntimeConfig: () => Q94
  });
  DuA.exports = A94(QuA);
  var B94 = EL((A) => {
      return {
        setHttpHandler(B) {
          A.httpHandler = B
        },
        httpHandler() {
          return A.httpHandler
        },
        updateHttpClientConfig(B, Q) {
          A.httpHandler?.updateHttpClientConfig(B, Q)
        },
        httpHandlerConfigs() {
          return A.httpHandler.httpHandlerConfigs()
        }
      }
    }, "getHttpHandlerExtensionConfiguration"),
    Q94 = EL((A) => {
      return {
        httpHandler: A.httpHandler()
      }
    }, "resolveHttpHandlerRuntimeConfig"),
    IuA = BuA(),
    I94 = class {
      static {
        EL(this, "Field")
      }
      constructor({
        name: A,
        kind: B = IuA.FieldPosition.HEADER,
        values: Q = []
      }) {
        this.name = A, this.kind = B, this.values = Q
      }
      add(A) {
        this.values.push(A)
      }
      set(A) {
        this.values = A
      }
      remove(A) {
        this.values = this.values.filter((B) => B !== A)
      }
      toString() {
        return this.values.map((A) => A.includes(",") || A.includes(" ") ? `"${A}"` : A).join(", ")
      }
      get() {
        return this.values
      }
    },
    G94 = class {
      constructor({
        fields: A = [],
        encoding: B = "utf-8"
      }) {
        this.entries = {}, A.forEach(this.setField.bind(this)), this.encoding = B
      }
      static {
        EL(this, "Fields")
      }
      setField(A) {
        this.entries[A.name.toLowerCase()] = A
      }
      getField(A) {
        return this.entries[A.toLowerCase()]
      }
      removeField(A) {
        delete this.entries[A.toLowerCase()]
      }
      getByType(A) {
        return Object.values(this.entries).filter((B) => B.kind === A)
      }
    },
    Z94 = class A {
      static {
        EL(this, "HttpRequest")
      }
      constructor(B) {
        this.method = B.method || "GET", this.hostname = B.hostname || "localhost", this.port = B.port, this.query = B.query || {}, this.headers = B.headers || {}, this.body = B.body, this.protocol = B.protocol ? B.protocol.slice(-1) !== ":" ? `${B.protocol}:` : B.protocol : "https:", this.path = B.path ? B.path.charAt(0) !== "/" ? `/${B.path}` : B.path : "/", this.username = B.username, this.password = B.password, this.fragment = B.fragment
      }
      static clone(B) {
        let Q = new A({
          ...B,
          headers: {
            ...B.headers
          }
        });
        if (Q.query) Q.query = GuA(Q.query);
        return Q
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return "method" in Q && "protocol" in Q && "hostname" in Q && "path" in Q && typeof Q.query === "object" && typeof Q.headers === "object"
      }
      clone() {
        return A.clone(this)
      }
    };

  function GuA(A) {
    return Object.keys(A).reduce((B, Q) => {
      let I = A[Q];
      return {
        ...B,
        [Q]: Array.isArray(I) ? [...I] : I
      }
    }, {})
  }
  EL(GuA, "cloneQuery");
  var D94 = class {
    static {
      EL(this, "HttpResponse")
    }
    constructor(A) {
      this.statusCode = A.statusCode, this.reason = A.reason, this.headers = A.headers || {}, this.body = A.body
    }
    static isInstance(A) {
      if (!A) return !1;
      let B = A;
      return typeof B.statusCode === "number" && typeof B.headers === "object"
    }
  };

  function ZuA(A) {
    return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(A)
  }
  EL(ZuA, "isValidHostname")
})
// @from(Start 3050577, End 3052509)
iS = z((P38, XuA) => {
  var {
    defineProperty: o31,
    getOwnPropertyDescriptor: Y94,
    getOwnPropertyNames: W94
  } = Object, J94 = Object.prototype.hasOwnProperty, r31 = (A, B) => o31(A, "name", {
    value: B,
    configurable: !0
  }), F94 = (A, B) => {
    for (var Q in B) o31(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, X94 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of W94(B))
        if (!J94.call(A, G) && G !== Q) o31(A, G, {
          get: () => B[G],
          enumerable: !(I = Y94(B, G)) || I.enumerable
        })
    }
    return A
  }, V94 = (A) => X94(o31({}, "__esModule", {
    value: !0
  }), A), WuA = {};
  F94(WuA, {
    addRecursionDetectionMiddlewareOptions: () => FuA,
    getRecursionDetectionPlugin: () => z94,
    recursionDetectionMiddleware: () => JuA
  });
  XuA.exports = V94(WuA);
  var C94 = YuA(),
    V_1 = "X-Amzn-Trace-Id",
    K94 = "AWS_LAMBDA_FUNCTION_NAME",
    H94 = "_X_AMZN_TRACE_ID",
    JuA = r31((A) => (B) => async (Q) => {
      let {
        request: I
      } = Q;
      if (!C94.HttpRequest.isInstance(I) || A.runtime !== "node") return B(Q);
      let G = Object.keys(I.headers ?? {}).find((W) => W.toLowerCase() === V_1.toLowerCase()) ?? V_1;
      if (I.headers.hasOwnProperty(G)) return B(Q);
      let Z = process.env[K94],
        D = process.env[H94],
        Y = r31((W) => typeof W === "string" && W.length > 0, "nonEmptyString");
      if (Y(Z) && Y(D)) I.headers[V_1] = D;
      return B({
        ...Q,
        request: I
      })
    }, "recursionDetectionMiddleware"),
    FuA = {
      step: "build",
      tags: ["RECURSION_DETECTION"],
      name: "recursionDetectionMiddleware",
      override: !0,
      priority: "low"
    },
    z94 = r31((A) => ({
      applyToStack: r31((B) => {
        B.add(JuA(A), FuA)
      }, "applyToStack")
    }), "getRecursionDetectionPlugin")
})
// @from(Start 3052515, End 3055298)
C_1 = z((S38, NuA) => {
  var {
    defineProperty: t31,
    getOwnPropertyDescriptor: w94,
    getOwnPropertyNames: E94
  } = Object, U94 = Object.prototype.hasOwnProperty, e31 = (A, B) => t31(A, "name", {
    value: B,
    configurable: !0
  }), N94 = (A, B) => {
    for (var Q in B) t31(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, $94 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of E94(B))
        if (!U94.call(A, G) && G !== Q) t31(A, G, {
          get: () => B[G],
          enumerable: !(I = w94(B, G)) || I.enumerable
        })
    }
    return A
  }, q94 = (A) => $94(t31({}, "__esModule", {
    value: !0
  }), A), VuA = {};
  N94(VuA, {
    AlgorithmId: () => zuA,
    EndpointURLScheme: () => HuA,
    FieldPosition: () => wuA,
    HttpApiKeyAuthLocation: () => KuA,
    HttpAuthLocation: () => CuA,
    IniSectionType: () => EuA,
    RequestHandlerProtocol: () => UuA,
    SMITHY_CONTEXT_KEY: () => T94,
    getDefaultClientConfiguration: () => R94,
    resolveDefaultRuntimeConfig: () => O94
  });
  NuA.exports = q94(VuA);
  var CuA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(CuA || {}),
    KuA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(KuA || {}),
    HuA = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(HuA || {}),
    zuA = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(zuA || {}),
    M94 = e31((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    L94 = e31((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    R94 = e31((A) => {
      return M94(A)
    }, "getDefaultClientConfiguration"),
    O94 = e31((A) => {
      return L94(A)
    }, "resolveDefaultRuntimeConfig"),
    wuA = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(wuA || {}),
    T94 = "__smithy_context",
    EuA = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(EuA || {}),
    UuA = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(UuA || {})
})
// @from(Start 3055304, End 3058087)
_uA = z((_38, SuA) => {
  var {
    defineProperty: AQ1,
    getOwnPropertyDescriptor: P94,
    getOwnPropertyNames: S94
  } = Object, _94 = Object.prototype.hasOwnProperty, BQ1 = (A, B) => AQ1(A, "name", {
    value: B,
    configurable: !0
  }), j94 = (A, B) => {
    for (var Q in B) AQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, y94 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of S94(B))
        if (!_94.call(A, G) && G !== Q) AQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = P94(B, G)) || I.enumerable
        })
    }
    return A
  }, k94 = (A) => y94(AQ1({}, "__esModule", {
    value: !0
  }), A), $uA = {};
  j94($uA, {
    AlgorithmId: () => RuA,
    EndpointURLScheme: () => LuA,
    FieldPosition: () => OuA,
    HttpApiKeyAuthLocation: () => MuA,
    HttpAuthLocation: () => quA,
    IniSectionType: () => TuA,
    RequestHandlerProtocol: () => PuA,
    SMITHY_CONTEXT_KEY: () => g94,
    getDefaultClientConfiguration: () => v94,
    resolveDefaultRuntimeConfig: () => b94
  });
  SuA.exports = k94($uA);
  var quA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(quA || {}),
    MuA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(MuA || {}),
    LuA = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(LuA || {}),
    RuA = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(RuA || {}),
    x94 = BQ1((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    f94 = BQ1((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    v94 = BQ1((A) => {
      return x94(A)
    }, "getDefaultClientConfiguration"),
    b94 = BQ1((A) => {
      return f94(A)
    }, "resolveDefaultRuntimeConfig"),
    OuA = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(OuA || {}),
    g94 = "__smithy_context",
    TuA = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(TuA || {}),
    PuA = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(PuA || {})
})
// @from(Start 3058093, End 3059190)
ZX = z((j38, xuA) => {
  var {
    defineProperty: QQ1,
    getOwnPropertyDescriptor: h94,
    getOwnPropertyNames: m94
  } = Object, d94 = Object.prototype.hasOwnProperty, yuA = (A, B) => QQ1(A, "name", {
    value: B,
    configurable: !0
  }), u94 = (A, B) => {
    for (var Q in B) QQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, p94 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of m94(B))
        if (!d94.call(A, G) && G !== Q) QQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = h94(B, G)) || I.enumerable
        })
    }
    return A
  }, c94 = (A) => p94(QQ1({}, "__esModule", {
    value: !0
  }), A), kuA = {};
  u94(kuA, {
    getSmithyContext: () => l94,
    normalizeProvider: () => i94
  });
  xuA.exports = c94(kuA);
  var juA = _uA(),
    l94 = yuA((A) => A[juA.SMITHY_CONTEXT_KEY] || (A[juA.SMITHY_CONTEXT_KEY] = {}), "getSmithyContext"),
    i94 = yuA((A) => {
      if (typeof A === "function") return A;
      let B = Promise.resolve(A);
      return () => B
    }, "normalizeProvider")
})
// @from(Start 3059196, End 3062056)
yz = z((y38, duA) => {
  var {
    defineProperty: IQ1,
    getOwnPropertyDescriptor: n94,
    getOwnPropertyNames: a94
  } = Object, s94 = Object.prototype.hasOwnProperty, K_1 = (A, B) => IQ1(A, "name", {
    value: B,
    configurable: !0
  }), r94 = (A, B) => {
    for (var Q in B) IQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, o94 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of a94(B))
        if (!s94.call(A, G) && G !== Q) IQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = n94(B, G)) || I.enumerable
        })
    }
    return A
  }, t94 = (A) => o94(IQ1({}, "__esModule", {
    value: !0
  }), A), fuA = {};
  r94(fuA, {
    deserializerMiddleware: () => vuA,
    deserializerMiddlewareOption: () => guA,
    getSerdePlugin: () => muA,
    serializerMiddleware: () => buA,
    serializerMiddlewareOption: () => huA
  });
  duA.exports = t94(fuA);
  var vuA = K_1((A, B) => (Q, I) => async (G) => {
      let {
        response: Z
      } = await Q(G);
      try {
        let D = await B(Z, A);
        return {
          response: Z,
          output: D
        }
      } catch (D) {
        if (Object.defineProperty(D, "$response", {
            value: Z
          }), !("$metadata" in D)) {
          try {
            D.message += `
  Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`
          } catch (W) {
            if (!I.logger || I.logger?.constructor?.name === "NoOpLogger") console.warn("Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.");
            else I.logger?.warn?.("Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.")
          }
          if (typeof D.$responseBodyText !== "undefined") {
            if (D.$response) D.$response.body = D.$responseBodyText
          }
        }
        throw D
      }
    }, "deserializerMiddleware"),
    buA = K_1((A, B) => (Q, I) => async (G) => {
      let Z = I.endpointV2?.url && A.urlParser ? async () => A.urlParser(I.endpointV2.url): A.endpoint;
      if (!Z) throw new Error("No valid endpoint provider available.");
      let D = await B(G.input, {
        ...A,
        endpoint: Z
      });
      return Q({
        ...G,
        request: D
      })
    }, "serializerMiddleware"),
    guA = {
      name: "deserializerMiddleware",
      step: "deserialize",
      tags: ["DESERIALIZER"],
      override: !0
    },
    huA = {
      name: "serializerMiddleware",
      step: "serialize",
      tags: ["SERIALIZER"],
      override: !0
    };

  function muA(A, B, Q) {
    return {
      applyToStack: (I) => {
        I.add(vuA(A, Q), guA), I.add(buA(A, B), huA)
      }
    }
  }
  K_1(muA, "getSerdePlugin")
})
// @from(Start 3062062, End 3066569)
H_1 = z((k38, iuA) => {
  var {
    defineProperty: GQ1,
    getOwnPropertyDescriptor: e94,
    getOwnPropertyNames: A44
  } = Object, B44 = Object.prototype.hasOwnProperty, UL = (A, B) => GQ1(A, "name", {
    value: B,
    configurable: !0
  }), Q44 = (A, B) => {
    for (var Q in B) GQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, I44 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of A44(B))
        if (!B44.call(A, G) && G !== Q) GQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = e94(B, G)) || I.enumerable
        })
    }
    return A
  }, G44 = (A) => I44(GQ1({}, "__esModule", {
    value: !0
  }), A), uuA = {};
  Q44(uuA, {
    Field: () => Y44,
    Fields: () => W44,
    HttpRequest: () => J44,
    HttpResponse: () => F44,
    IHttpRequest: () => puA.HttpRequest,
    getHttpHandlerExtensionConfiguration: () => Z44,
    isValidHostname: () => luA,
    resolveHttpHandlerRuntimeConfig: () => D44
  });
  iuA.exports = G44(uuA);
  var Z44 = UL((A) => {
      return {
        setHttpHandler(B) {
          A.httpHandler = B
        },
        httpHandler() {
          return A.httpHandler
        },
        updateHttpClientConfig(B, Q) {
          A.httpHandler?.updateHttpClientConfig(B, Q)
        },
        httpHandlerConfigs() {
          return A.httpHandler.httpHandlerConfigs()
        }
      }
    }, "getHttpHandlerExtensionConfiguration"),
    D44 = UL((A) => {
      return {
        httpHandler: A.httpHandler()
      }
    }, "resolveHttpHandlerRuntimeConfig"),
    puA = C_1(),
    Y44 = class {
      static {
        UL(this, "Field")
      }
      constructor({
        name: A,
        kind: B = puA.FieldPosition.HEADER,
        values: Q = []
      }) {
        this.name = A, this.kind = B, this.values = Q
      }
      add(A) {
        this.values.push(A)
      }
      set(A) {
        this.values = A
      }
      remove(A) {
        this.values = this.values.filter((B) => B !== A)
      }
      toString() {
        return this.values.map((A) => A.includes(",") || A.includes(" ") ? `"${A}"` : A).join(", ")
      }
      get() {
        return this.values
      }
    },
    W44 = class {
      constructor({
        fields: A = [],
        encoding: B = "utf-8"
      }) {
        this.entries = {}, A.forEach(this.setField.bind(this)), this.encoding = B
      }
      static {
        UL(this, "Fields")
      }
      setField(A) {
        this.entries[A.name.toLowerCase()] = A
      }
      getField(A) {
        return this.entries[A.toLowerCase()]
      }
      removeField(A) {
        delete this.entries[A.toLowerCase()]
      }
      getByType(A) {
        return Object.values(this.entries).filter((B) => B.kind === A)
      }
    },
    J44 = class A {
      static {
        UL(this, "HttpRequest")
      }
      constructor(B) {
        this.method = B.method || "GET", this.hostname = B.hostname || "localhost", this.port = B.port, this.query = B.query || {}, this.headers = B.headers || {}, this.body = B.body, this.protocol = B.protocol ? B.protocol.slice(-1) !== ":" ? `${B.protocol}:` : B.protocol : "https:", this.path = B.path ? B.path.charAt(0) !== "/" ? `/${B.path}` : B.path : "/", this.username = B.username, this.password = B.password, this.fragment = B.fragment
      }
      static clone(B) {
        let Q = new A({
          ...B,
          headers: {
            ...B.headers
          }
        });
        if (Q.query) Q.query = cuA(Q.query);
        return Q
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return "method" in Q && "protocol" in Q && "hostname" in Q && "path" in Q && typeof Q.query === "object" && typeof Q.headers === "object"
      }
      clone() {
        return A.clone(this)
      }
    };

  function cuA(A) {
    return Object.keys(A).reduce((B, Q) => {
      let I = A[Q];
      return {
        ...B,
        [Q]: Array.isArray(I) ? [...I] : I
      }
    }, {})
  }
  UL(cuA, "cloneQuery");
  var F44 = class {
    static {
      UL(this, "HttpResponse")
    }
    constructor(A) {
      this.statusCode = A.statusCode, this.reason = A.reason, this.headers = A.headers || {}, this.body = A.body
    }
    static isInstance(A) {
      if (!A) return !1;
      let B = A;
      return typeof B.statusCode === "number" && typeof B.headers === "object"
    }
  };

  function luA(A) {
    return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(A)
  }
  UL(luA, "isValidHostname")
})
// @from(Start 3066575, End 3067528)
suA = z((b38, auA) => {
  var {
    defineProperty: ZQ1,
    getOwnPropertyDescriptor: X44,
    getOwnPropertyNames: V44
  } = Object, C44 = Object.prototype.hasOwnProperty, K44 = (A, B) => ZQ1(A, "name", {
    value: B,
    configurable: !0
  }), H44 = (A, B) => {
    for (var Q in B) ZQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, z44 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of V44(B))
        if (!C44.call(A, G) && G !== Q) ZQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = X44(B, G)) || I.enumerable
        })
    }
    return A
  }, w44 = (A) => z44(ZQ1({}, "__esModule", {
    value: !0
  }), A), nuA = {};
  H44(nuA, {
    isArrayBuffer: () => E44
  });
  auA.exports = w44(nuA);
  var E44 = K44((A) => typeof ArrayBuffer === "function" && A instanceof ArrayBuffer || Object.prototype.toString.call(A) === "[object ArrayBuffer]", "isArrayBuffer")
})
// @from(Start 3067534, End 3068882)
MZ = z((g38, tuA) => {
  var {
    defineProperty: DQ1,
    getOwnPropertyDescriptor: U44,
    getOwnPropertyNames: N44
  } = Object, $44 = Object.prototype.hasOwnProperty, ruA = (A, B) => DQ1(A, "name", {
    value: B,
    configurable: !0
  }), q44 = (A, B) => {
    for (var Q in B) DQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, M44 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of N44(B))
        if (!$44.call(A, G) && G !== Q) DQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = U44(B, G)) || I.enumerable
        })
    }
    return A
  }, L44 = (A) => M44(DQ1({}, "__esModule", {
    value: !0
  }), A), ouA = {};
  q44(ouA, {
    fromArrayBuffer: () => O44,
    fromString: () => T44
  });
  tuA.exports = L44(ouA);
  var R44 = suA(),
    z_1 = Z1("buffer"),
    O44 = ruA((A, B = 0, Q = A.byteLength - B) => {
      if (!R44.isArrayBuffer(A)) throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof A} (${A})`);
      return z_1.Buffer.from(A, B, Q)
    }, "fromArrayBuffer"),
    T44 = ruA((A, B) => {
      if (typeof A !== "string") throw new TypeError(`The "input" argument must be of type string. Received type ${typeof A} (${A})`);
      return B ? z_1.Buffer.from(A, B) : z_1.Buffer.from(A)
    }, "fromString")
})
// @from(Start 3068888, End 3069378)
BpA = z((euA) => {
  Object.defineProperty(euA, "__esModule", {
    value: !0
  });
  euA.fromBase64 = void 0;
  var P44 = MZ(),
    S44 = /^[A-Za-z0-9+/]*={0,2}$/,
    _44 = (A) => {
      if (A.length * 3 % 4 !== 0) throw new TypeError("Incorrect padding on base64 string.");
      if (!S44.exec(A)) throw new TypeError("Invalid base64 string.");
      let B = P44.fromString(A, "base64");
      return new Uint8Array(B.buffer, B.byteOffset, B.byteLength)
    };
  euA.fromBase64 = _44
})
// @from(Start 3069384, End 3071039)
RQ = z((m38, ZpA) => {
  var {
    defineProperty: YQ1,
    getOwnPropertyDescriptor: j44,
    getOwnPropertyNames: y44
  } = Object, k44 = Object.prototype.hasOwnProperty, w_1 = (A, B) => YQ1(A, "name", {
    value: B,
    configurable: !0
  }), x44 = (A, B) => {
    for (var Q in B) YQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, f44 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of y44(B))
        if (!k44.call(A, G) && G !== Q) YQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = j44(B, G)) || I.enumerable
        })
    }
    return A
  }, v44 = (A) => f44(YQ1({}, "__esModule", {
    value: !0
  }), A), QpA = {};
  x44(QpA, {
    fromUtf8: () => GpA,
    toUint8Array: () => b44,
    toUtf8: () => g44
  });
  ZpA.exports = v44(QpA);
  var IpA = MZ(),
    GpA = w_1((A) => {
      let B = IpA.fromString(A, "utf8");
      return new Uint8Array(B.buffer, B.byteOffset, B.byteLength / Uint8Array.BYTES_PER_ELEMENT)
    }, "fromUtf8"),
    b44 = w_1((A) => {
      if (typeof A === "string") return GpA(A);
      if (ArrayBuffer.isView(A)) return new Uint8Array(A.buffer, A.byteOffset, A.byteLength / Uint8Array.BYTES_PER_ELEMENT);
      return new Uint8Array(A)
    }, "toUint8Array"),
    g44 = w_1((A) => {
      if (typeof A === "string") return A;
      if (typeof A !== "object" || typeof A.byteOffset !== "number" || typeof A.byteLength !== "number") throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
      return IpA.fromArrayBuffer(A.buffer, A.byteOffset, A.byteLength).toString("utf8")
    }, "toUtf8")
})
// @from(Start 3071045, End 3071618)
WpA = z((DpA) => {
  Object.defineProperty(DpA, "__esModule", {
    value: !0
  });
  DpA.toBase64 = void 0;
  var h44 = MZ(),
    m44 = RQ(),
    d44 = (A) => {
      let B;
      if (typeof A === "string") B = m44.fromUtf8(A);
      else B = A;
      if (typeof B !== "object" || typeof B.byteOffset !== "number" || typeof B.byteLength !== "number") throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
      return h44.fromArrayBuffer(B.buffer, B.byteOffset, B.byteLength).toString("base64")
    };
  DpA.toBase64 = d44
})
// @from(Start 3071624, End 3072319)
Wb = z((u38, WQ1) => {
  var {
    defineProperty: JpA,
    getOwnPropertyDescriptor: u44,
    getOwnPropertyNames: p44
  } = Object, c44 = Object.prototype.hasOwnProperty, E_1 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of p44(B))
        if (!c44.call(A, G) && G !== Q) JpA(A, G, {
          get: () => B[G],
          enumerable: !(I = u44(B, G)) || I.enumerable
        })
    }
    return A
  }, FpA = (A, B, Q) => (E_1(A, B, "default"), Q && E_1(Q, B, "default")), l44 = (A) => E_1(JpA({}, "__esModule", {
    value: !0
  }), A), U_1 = {};
  WQ1.exports = l44(U_1);
  FpA(U_1, BpA(), WQ1.exports);
  FpA(U_1, WpA(), WQ1.exports)
})
// @from(Start 3072325, End 3073732)
N_1 = z((VpA) => {
  Object.defineProperty(VpA, "__esModule", {
    value: !0
  });
  VpA.ChecksumStream = void 0;
  var i44 = Wb(),
    n44 = Z1("stream");
  class XpA extends n44.Duplex {
    constructor({
      expectedChecksum: A,
      checksum: B,
      source: Q,
      checksumSourceLocation: I,
      base64Encoder: G
    }) {
      var Z, D;
      super();
      if (typeof Q.pipe === "function") this.source = Q;
      else throw new Error(`@smithy/util-stream: unsupported source type ${(D=(Z=Q===null||Q===void 0?void 0:Q.constructor)===null||Z===void 0?void 0:Z.name)!==null&&D!==void 0?D:Q} in ChecksumStream.`);
      this.base64Encoder = G !== null && G !== void 0 ? G : i44.toBase64, this.expectedChecksum = A, this.checksum = B, this.checksumSourceLocation = I, this.source.pipe(this)
    }
    _read(A) {}
    _write(A, B, Q) {
      try {
        this.checksum.update(A), this.push(A)
      } catch (I) {
        return Q(I)
      }
      return Q()
    }
    async _final(A) {
      try {
        let B = await this.checksum.digest(),
          Q = this.base64Encoder(B);
        if (this.expectedChecksum !== Q) return A(new Error(`Checksum mismatch: expected "${this.expectedChecksum}" but received "${Q}" in response header "${this.checksumSourceLocation}".`))
      } catch (B) {
        return A(B)
      }
      return this.push(null), A()
    }
  }
  VpA.ChecksumStream = XpA
})
// @from(Start 3073738, End 3074384)
NL = z((KpA) => {
  Object.defineProperty(KpA, "__esModule", {
    value: !0
  });
  KpA.isBlob = KpA.isReadableStream = void 0;
  var a44 = (A) => {
    var B;
    return typeof ReadableStream === "function" && (((B = A === null || A === void 0 ? void 0 : A.constructor) === null || B === void 0 ? void 0 : B.name) === ReadableStream.name || A instanceof ReadableStream)
  };
  KpA.isReadableStream = a44;
  var s44 = (A) => {
    var B;
    return typeof Blob === "function" && (((B = A === null || A === void 0 ? void 0 : A.constructor) === null || B === void 0 ? void 0 : B.name) === Blob.name || A instanceof Blob)
  };
  KpA.isBlob = s44
})
// @from(Start 3074390, End 3074644)
UpA = z((wpA) => {
  Object.defineProperty(wpA, "__esModule", {
    value: !0
  });
  wpA.ChecksumStream = void 0;
  var o44 = typeof ReadableStream === "function" ? ReadableStream : function() {};
  class zpA extends o44 {}
  wpA.ChecksumStream = zpA
})
// @from(Start 3074650, End 3076052)
qpA = z((NpA) => {
  Object.defineProperty(NpA, "__esModule", {
    value: !0
  });
  NpA.createChecksumStream = void 0;
  var t44 = Wb(),
    e44 = NL(),
    A64 = UpA(),
    B64 = ({
      expectedChecksum: A,
      checksum: B,
      source: Q,
      checksumSourceLocation: I,
      base64Encoder: G
    }) => {
      var Z, D;
      if (!e44.isReadableStream(Q)) throw new Error(`@smithy/util-stream: unsupported source type ${(D=(Z=Q===null||Q===void 0?void 0:Q.constructor)===null||Z===void 0?void 0:Z.name)!==null&&D!==void 0?D:Q} in ChecksumStream.`);
      let Y = G !== null && G !== void 0 ? G : t44.toBase64;
      if (typeof TransformStream !== "function") throw new Error("@smithy/util-stream: unable to instantiate ChecksumStream because API unavailable: ReadableStream/TransformStream.");
      let W = new TransformStream({
        start() {},
        async transform(F, X) {
          B.update(F), X.enqueue(F)
        },
        async flush(F) {
          let X = await B.digest(),
            V = Y(X);
          if (A !== V) {
            let C = new Error(`Checksum mismatch: expected "${A}" but received "${V}" in response header "${I}".`);
            F.error(C)
          } else F.terminate()
        }
      });
      Q.pipeThrough(W);
      let J = W.readable;
      return Object.setPrototypeOf(J, A64.ChecksumStream.prototype), J
    };
  NpA.createChecksumStream = B64
})
// @from(Start 3076058, End 3076444)
RpA = z((MpA) => {
  Object.defineProperty(MpA, "__esModule", {
    value: !0
  });
  MpA.createChecksumStream = void 0;
  var Q64 = NL(),
    I64 = N_1(),
    G64 = qpA();

  function Z64(A) {
    if (typeof ReadableStream === "function" && Q64.isReadableStream(A.source)) return G64.createChecksumStream(A);
    return new I64.ChecksumStream(A)
  }
  MpA.createChecksumStream = Z64
})
// @from(Start 3076450, End 3077244)
$_1 = z((TpA) => {
  Object.defineProperty(TpA, "__esModule", {
    value: !0
  });
  TpA.ByteArrayCollector = void 0;
  class OpA {
    constructor(A) {
      this.allocByteArray = A, this.byteLength = 0, this.byteArrays = []
    }
    push(A) {
      this.byteArrays.push(A), this.byteLength += A.byteLength
    }
    flush() {
      if (this.byteArrays.length === 1) {
        let Q = this.byteArrays[0];
        return this.reset(), Q
      }
      let A = this.allocByteArray(this.byteLength),
        B = 0;
      for (let Q = 0; Q < this.byteArrays.length; ++Q) {
        let I = this.byteArrays[Q];
        A.set(I, B), B += I.byteLength
      }
      return this.reset(), A
    }
    reset() {
      this.byteArrays = [], this.byteLength = 0
    }
  }
  TpA.ByteArrayCollector = OpA
})
// @from(Start 3077250, End 3079652)
xpA = z((ypA) => {
  Object.defineProperty(ypA, "__esModule", {
    value: !0
  });
  ypA.modeOf = ypA.sizeOf = ypA.flush = ypA.merge = ypA.createBufferedReadable = ypA.createBufferedReadableStream = void 0;
  var D64 = $_1();

  function SpA(A, B, Q) {
    let I = A.getReader(),
      G = !1,
      Z = 0,
      D = ["", new D64.ByteArrayCollector((J) => new Uint8Array(J))],
      Y = -1,
      W = async (J) => {
        let {
          value: F,
          done: X
        } = await I.read(), V = F;
        if (X) {
          if (Y !== -1) {
            let C = JQ1(D, Y);
            if (Jb(C) > 0) J.enqueue(C)
          }
          J.close()
        } else {
          let C = jpA(V, !1);
          if (Y !== C) {
            if (Y >= 0) J.enqueue(JQ1(D, Y));
            Y = C
          }
          if (Y === -1) {
            J.enqueue(V);
            return
          }
          let K = Jb(V);
          Z += K;
          let E = Jb(D[Y]);
          if (K >= B && E === 0) J.enqueue(V);
          else {
            let N = _pA(D, Y, V);
            if (!G && Z > B * 2) G = !0, Q === null || Q === void 0 || Q.warn(`@smithy/util-stream - stream chunk size ${K} is below threshold of ${B}, automatically buffering.`);
            if (N >= B) J.enqueue(JQ1(D, Y));
            else await W(J)
          }
        }
      };
    return new ReadableStream({
      pull: W
    })
  }
  ypA.createBufferedReadableStream = SpA;
  ypA.createBufferedReadable = SpA;

  function _pA(A, B, Q) {
    switch (B) {
      case 0:
        return A[0] += Q, Jb(A[0]);
      case 1:
      case 2:
        return A[B].push(Q), Jb(A[B])
    }
  }
  ypA.merge = _pA;

  function JQ1(A, B) {
    switch (B) {
      case 0:
        let Q = A[0];
        return A[0] = "", Q;
      case 1:
      case 2:
        return A[B].flush()
    }
    throw new Error(`@smithy/util-stream - invalid index ${B} given to flush()`)
  }
  ypA.flush = JQ1;

  function Jb(A) {
    var B, Q;
    return (Q = (B = A === null || A === void 0 ? void 0 : A.byteLength) !== null && B !== void 0 ? B : A === null || A === void 0 ? void 0 : A.length) !== null && Q !== void 0 ? Q : 0
  }
  ypA.sizeOf = Jb;

  function jpA(A, B = !0) {
    if (B && typeof Buffer !== "undefined" && A instanceof Buffer) return 2;
    if (A instanceof Uint8Array) return 1;
    if (typeof A === "string") return 0;
    return -1
  }
  ypA.modeOf = jpA
})
// @from(Start 3079658, End 3081011)
gpA = z((vpA) => {
  Object.defineProperty(vpA, "__esModule", {
    value: !0
  });
  vpA.createBufferedReadable = void 0;
  var V64 = Z1("node:stream"),
    fpA = $_1(),
    ZN = xpA(),
    C64 = NL();

  function K64(A, B, Q) {
    if (C64.isReadableStream(A)) return ZN.createBufferedReadableStream(A, B, Q);
    let I = new V64.Readable({
        read() {}
      }),
      G = !1,
      Z = 0,
      D = ["", new fpA.ByteArrayCollector((W) => new Uint8Array(W)), new fpA.ByteArrayCollector((W) => Buffer.from(new Uint8Array(W)))],
      Y = -1;
    return A.on("data", (W) => {
      let J = ZN.modeOf(W, !0);
      if (Y !== J) {
        if (Y >= 0) I.push(ZN.flush(D, Y));
        Y = J
      }
      if (Y === -1) {
        I.push(W);
        return
      }
      let F = ZN.sizeOf(W);
      Z += F;
      let X = ZN.sizeOf(D[Y]);
      if (F >= B && X === 0) I.push(W);
      else {
        let V = ZN.merge(D, Y, W);
        if (!G && Z > B * 2) G = !0, Q === null || Q === void 0 || Q.warn(`@smithy/util-stream - stream chunk size ${F} is below threshold of ${B}, automatically buffering.`);
        if (V >= B) I.push(ZN.flush(D, Y))
      }
    }), A.on("end", () => {
      if (Y !== -1) {
        let W = ZN.flush(D, Y);
        if (ZN.sizeOf(W) > 0) I.push(W)
      }
      I.push(null)
    }), I
  }
  vpA.createBufferedReadable = K64
})
// @from(Start 3081017, End 3081877)
dpA = z((hpA) => {
  Object.defineProperty(hpA, "__esModule", {
    value: !0
  });
  hpA.getAwsChunkedEncodingStream = void 0;
  var H64 = Z1("stream"),
    z64 = (A, B) => {
      let {
        base64Encoder: Q,
        bodyLengthChecker: I,
        checksumAlgorithmFn: G,
        checksumLocationName: Z,
        streamHasher: D
      } = B, Y = Q !== void 0 && G !== void 0 && Z !== void 0 && D !== void 0, W = Y ? D(G, A) : void 0, J = new H64.Readable({
        read: () => {}
      });
      return A.on("data", (F) => {
        let X = I(F) || 0;
        J.push(`${X.toString(16)}\r
`), J.push(F), J.push(`\r
`)
      }), A.on("end", async () => {
        if (J.push(`0\r
`), Y) {
          let F = Q(await W);
          J.push(`${Z}:${F}\r
`), J.push(`\r
`)
        }
        J.push(null)
      }), J
    };
  hpA.getAwsChunkedEncodingStream = z64
})
// @from(Start 3081883, End 3082659)
cpA = z((upA) => {
  Object.defineProperty(upA, "__esModule", {
    value: !0
  });
  upA.headStream = void 0;
  async function w64(A, B) {
    var Q;
    let I = 0,
      G = [],
      Z = A.getReader(),
      D = !1;
    while (!D) {
      let {
        done: J,
        value: F
      } = await Z.read();
      if (F) G.push(F), I += (Q = F === null || F === void 0 ? void 0 : F.byteLength) !== null && Q !== void 0 ? Q : 0;
      if (I >= B) break;
      D = J
    }
    Z.releaseLock();
    let Y = new Uint8Array(Math.min(B, I)),
      W = 0;
    for (let J of G) {
      if (J.byteLength > Y.byteLength - W) {
        Y.set(J.subarray(0, Y.byteLength - W), W);
        break
      } else Y.set(J, W);
      W += J.length
    }
    return Y
  }
  upA.headStream = w64
})
// @from(Start 3082665, End 3083816)
apA = z((ipA) => {
  Object.defineProperty(ipA, "__esModule", {
    value: !0
  });
  ipA.headStream = void 0;
  var E64 = Z1("stream"),
    U64 = cpA(),
    N64 = NL(),
    $64 = (A, B) => {
      if (N64.isReadableStream(A)) return U64.headStream(A, B);
      return new Promise((Q, I) => {
        let G = new lpA;
        G.limit = B, A.pipe(G), A.on("error", (Z) => {
          G.end(), I(Z)
        }), G.on("error", I), G.on("finish", function() {
          let Z = new Uint8Array(Buffer.concat(this.buffers));
          Q(Z)
        })
      })
    };
  ipA.headStream = $64;
  class lpA extends E64.Writable {
    constructor() {
      super(...arguments);
      this.buffers = [], this.limit = 1 / 0, this.bytesBuffered = 0
    }
    _write(A, B, Q) {
      var I;
      if (this.buffers.push(A), this.bytesBuffered += (I = A.byteLength) !== null && I !== void 0 ? I : 0, this.bytesBuffered >= this.limit) {
        let G = this.bytesBuffered - this.limit,
          Z = this.buffers[this.buffers.length - 1];
        this.buffers[this.buffers.length - 1] = Z.subarray(0, Z.byteLength - G), this.emit("finish")
      }
      Q()
    }
  }
})
// @from(Start 3083822, End 3086605)
GcA = z((AQ8, IcA) => {
  var {
    defineProperty: FQ1,
    getOwnPropertyDescriptor: q64,
    getOwnPropertyNames: M64
  } = Object, L64 = Object.prototype.hasOwnProperty, XQ1 = (A, B) => FQ1(A, "name", {
    value: B,
    configurable: !0
  }), R64 = (A, B) => {
    for (var Q in B) FQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, O64 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of M64(B))
        if (!L64.call(A, G) && G !== Q) FQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = q64(B, G)) || I.enumerable
        })
    }
    return A
  }, T64 = (A) => O64(FQ1({}, "__esModule", {
    value: !0
  }), A), spA = {};
  R64(spA, {
    AlgorithmId: () => epA,
    EndpointURLScheme: () => tpA,
    FieldPosition: () => AcA,
    HttpApiKeyAuthLocation: () => opA,
    HttpAuthLocation: () => rpA,
    IniSectionType: () => BcA,
    RequestHandlerProtocol: () => QcA,
    SMITHY_CONTEXT_KEY: () => y64,
    getDefaultClientConfiguration: () => _64,
    resolveDefaultRuntimeConfig: () => j64
  });
  IcA.exports = T64(spA);
  var rpA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(rpA || {}),
    opA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(opA || {}),
    tpA = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(tpA || {}),
    epA = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(epA || {}),
    P64 = XQ1((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    S64 = XQ1((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    _64 = XQ1((A) => {
      return P64(A)
    }, "getDefaultClientConfiguration"),
    j64 = XQ1((A) => {
      return S64(A)
    }, "resolveDefaultRuntimeConfig"),
    AcA = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(AcA || {}),
    y64 = "__smithy_context",
    BcA = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(BcA || {}),
    QcA = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(QcA || {})
})
// @from(Start 3086611, End 3091118)
FcA = z((BQ8, JcA) => {
  var {
    defineProperty: VQ1,
    getOwnPropertyDescriptor: k64,
    getOwnPropertyNames: x64
  } = Object, f64 = Object.prototype.hasOwnProperty, $L = (A, B) => VQ1(A, "name", {
    value: B,
    configurable: !0
  }), v64 = (A, B) => {
    for (var Q in B) VQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, b64 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of x64(B))
        if (!f64.call(A, G) && G !== Q) VQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = k64(B, G)) || I.enumerable
        })
    }
    return A
  }, g64 = (A) => b64(VQ1({}, "__esModule", {
    value: !0
  }), A), ZcA = {};
  v64(ZcA, {
    Field: () => d64,
    Fields: () => u64,
    HttpRequest: () => p64,
    HttpResponse: () => c64,
    IHttpRequest: () => DcA.HttpRequest,
    getHttpHandlerExtensionConfiguration: () => h64,
    isValidHostname: () => WcA,
    resolveHttpHandlerRuntimeConfig: () => m64
  });
  JcA.exports = g64(ZcA);
  var h64 = $L((A) => {
      return {
        setHttpHandler(B) {
          A.httpHandler = B
        },
        httpHandler() {
          return A.httpHandler
        },
        updateHttpClientConfig(B, Q) {
          A.httpHandler?.updateHttpClientConfig(B, Q)
        },
        httpHandlerConfigs() {
          return A.httpHandler.httpHandlerConfigs()
        }
      }
    }, "getHttpHandlerExtensionConfiguration"),
    m64 = $L((A) => {
      return {
        httpHandler: A.httpHandler()
      }
    }, "resolveHttpHandlerRuntimeConfig"),
    DcA = GcA(),
    d64 = class {
      static {
        $L(this, "Field")
      }
      constructor({
        name: A,
        kind: B = DcA.FieldPosition.HEADER,
        values: Q = []
      }) {
        this.name = A, this.kind = B, this.values = Q
      }
      add(A) {
        this.values.push(A)
      }
      set(A) {
        this.values = A
      }
      remove(A) {
        this.values = this.values.filter((B) => B !== A)
      }
      toString() {
        return this.values.map((A) => A.includes(",") || A.includes(" ") ? `"${A}"` : A).join(", ")
      }
      get() {
        return this.values
      }
    },
    u64 = class {
      constructor({
        fields: A = [],
        encoding: B = "utf-8"
      }) {
        this.entries = {}, A.forEach(this.setField.bind(this)), this.encoding = B
      }
      static {
        $L(this, "Fields")
      }
      setField(A) {
        this.entries[A.name.toLowerCase()] = A
      }
      getField(A) {
        return this.entries[A.toLowerCase()]
      }
      removeField(A) {
        delete this.entries[A.toLowerCase()]
      }
      getByType(A) {
        return Object.values(this.entries).filter((B) => B.kind === A)
      }
    },
    p64 = class A {
      static {
        $L(this, "HttpRequest")
      }
      constructor(B) {
        this.method = B.method || "GET", this.hostname = B.hostname || "localhost", this.port = B.port, this.query = B.query || {}, this.headers = B.headers || {}, this.body = B.body, this.protocol = B.protocol ? B.protocol.slice(-1) !== ":" ? `${B.protocol}:` : B.protocol : "https:", this.path = B.path ? B.path.charAt(0) !== "/" ? `/${B.path}` : B.path : "/", this.username = B.username, this.password = B.password, this.fragment = B.fragment
      }
      static clone(B) {
        let Q = new A({
          ...B,
          headers: {
            ...B.headers
          }
        });
        if (Q.query) Q.query = YcA(Q.query);
        return Q
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return "method" in Q && "protocol" in Q && "hostname" in Q && "path" in Q && typeof Q.query === "object" && typeof Q.headers === "object"
      }
      clone() {
        return A.clone(this)
      }
    };

  function YcA(A) {
    return Object.keys(A).reduce((B, Q) => {
      let I = A[Q];
      return {
        ...B,
        [Q]: Array.isArray(I) ? [...I] : I
      }
    }, {})
  }
  $L(YcA, "cloneQuery");
  var c64 = class {
    static {
      $L(this, "HttpResponse")
    }
    constructor(A) {
      this.statusCode = A.statusCode, this.reason = A.reason, this.headers = A.headers || {}, this.body = A.body
    }
    static isInstance(A) {
      if (!A) return !1;
      let B = A;
      return typeof B.statusCode === "number" && typeof B.headers === "object"
    }
  };

  function WcA(A) {
    return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(A)
  }
  $L(WcA, "isValidHostname")
})
// @from(Start 3091124, End 3092177)
KcA = z((ZQ8, CcA) => {
  var {
    defineProperty: CQ1,
    getOwnPropertyDescriptor: l64,
    getOwnPropertyNames: i64
  } = Object, n64 = Object.prototype.hasOwnProperty, q_1 = (A, B) => CQ1(A, "name", {
    value: B,
    configurable: !0
  }), a64 = (A, B) => {
    for (var Q in B) CQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, s64 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of i64(B))
        if (!n64.call(A, G) && G !== Q) CQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = l64(B, G)) || I.enumerable
        })
    }
    return A
  }, r64 = (A) => s64(CQ1({}, "__esModule", {
    value: !0
  }), A), XcA = {};
  a64(XcA, {
    escapeUri: () => VcA,
    escapeUriPath: () => t64
  });
  CcA.exports = r64(XcA);
  var VcA = q_1((A) => encodeURIComponent(A).replace(/[!'()*]/g, o64), "escapeUri"),
    o64 = q_1((A) => `%${A.charCodeAt(0).toString(16).toUpperCase()}`, "hexEncode"),
    t64 = q_1((A) => A.split("/").map(VcA).join("/"), "escapeUriPath")
})
// @from(Start 3092183, End 3093421)
EcA = z((DQ8, wcA) => {
  var {
    defineProperty: KQ1,
    getOwnPropertyDescriptor: e64,
    getOwnPropertyNames: A54
  } = Object, B54 = Object.prototype.hasOwnProperty, Q54 = (A, B) => KQ1(A, "name", {
    value: B,
    configurable: !0
  }), I54 = (A, B) => {
    for (var Q in B) KQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, G54 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of A54(B))
        if (!B54.call(A, G) && G !== Q) KQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = e64(B, G)) || I.enumerable
        })
    }
    return A
  }, Z54 = (A) => G54(KQ1({}, "__esModule", {
    value: !0
  }), A), HcA = {};
  I54(HcA, {
    buildQueryString: () => zcA
  });
  wcA.exports = Z54(HcA);
  var M_1 = KcA();

  function zcA(A) {
    let B = [];
    for (let Q of Object.keys(A).sort()) {
      let I = A[Q];
      if (Q = M_1.escapeUri(Q), Array.isArray(I))
        for (let G = 0, Z = I.length; G < Z; G++) B.push(`${Q}=${M_1.escapeUri(I[G])}`);
      else {
        let G = Q;
        if (I || typeof I === "string") G += `=${M_1.escapeUri(I)}`;
        B.push(G)
      }
    }
    return B.join("&")
  }
  Q54(zcA, "buildQueryString")
})
// @from(Start 3093427, End 3112413)
DN = z((YQ8, ycA) => {
  var {
    create: D54,
    defineProperty: cn,
    getOwnPropertyDescriptor: Y54,
    getOwnPropertyNames: W54,
    getPrototypeOf: J54
  } = Object, F54 = Object.prototype.hasOwnProperty, d8 = (A, B) => cn(A, "name", {
    value: B,
    configurable: !0
  }), X54 = (A, B) => {
    for (var Q in B) cn(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, McA = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of W54(B))
        if (!F54.call(A, G) && G !== Q) cn(A, G, {
          get: () => B[G],
          enumerable: !(I = Y54(B, G)) || I.enumerable
        })
    }
    return A
  }, V54 = (A, B, Q) => (Q = A != null ? D54(J54(A)) : {}, McA(B || !A || !A.__esModule ? cn(Q, "default", {
    value: A,
    enumerable: !0
  }) : Q, A)), C54 = (A) => McA(cn({}, "__esModule", {
    value: !0
  }), A), LcA = {};
  X54(LcA, {
    DEFAULT_REQUEST_TIMEOUT: () => _cA,
    NodeHttp2Handler: () => M54,
    NodeHttpHandler: () => U54,
    streamCollector: () => R54
  });
  ycA.exports = C54(LcA);
  var RcA = FcA(),
    OcA = EcA(),
    L_1 = Z1("http"),
    R_1 = Z1("https"),
    K54 = ["ECONNRESET", "EPIPE", "ETIMEDOUT"],
    TcA = d8((A) => {
      let B = {};
      for (let Q of Object.keys(A)) {
        let I = A[Q];
        B[Q] = Array.isArray(I) ? I.join(",") : I
      }
      return B
    }, "getTransformedHeaders"),
    kY = {
      setTimeout: (A, B) => setTimeout(A, B),
      clearTimeout: (A) => clearTimeout(A)
    },
    UcA = 1000,
    H54 = d8((A, B, Q = 0) => {
      if (!Q) return -1;
      let I = d8((G) => {
        let Z = kY.setTimeout(() => {
            A.destroy(), B(Object.assign(new Error(`Socket timed out without establishing a connection within ${Q} ms`), {
              name: "TimeoutError"
            }))
          }, Q - G),
          D = d8((Y) => {
            if (Y?.connecting) Y.on("connect", () => {
              kY.clearTimeout(Z)
            });
            else kY.clearTimeout(Z)
          }, "doWithSocket");
        if (A.socket) D(A.socket);
        else A.on("socket", D)
      }, "registerTimeout");
      if (Q < 2000) return I(0), 0;
      return kY.setTimeout(I.bind(null, UcA), UcA)
    }, "setConnectionTimeout"),
    z54 = 3000,
    w54 = d8((A, {
      keepAlive: B,
      keepAliveMsecs: Q
    }, I = z54) => {
      if (B !== !0) return -1;
      let G = d8(() => {
        if (A.socket) A.socket.setKeepAlive(B, Q || 0);
        else A.on("socket", (Z) => {
          Z.setKeepAlive(B, Q || 0)
        })
      }, "registerListener");
      if (I === 0) return G(), 0;
      return kY.setTimeout(G, I)
    }, "setSocketKeepAlive"),
    NcA = 3000,
    E54 = d8((A, B, Q = _cA) => {
      let I = d8((G) => {
        let Z = Q - G,
          D = d8(() => {
            A.destroy(), B(Object.assign(new Error(`Connection timed out after ${Q} ms`), {
              name: "TimeoutError"
            }))
          }, "onTimeout");
        if (A.socket) A.socket.setTimeout(Z, D), A.on("close", () => A.socket?.removeListener("timeout", D));
        else A.setTimeout(Z, D)
      }, "registerTimeout");
      if (0 < Q && Q < 6000) return I(0), 0;
      return kY.setTimeout(I.bind(null, Q === 0 ? 0 : NcA), NcA)
    }, "setSocketTimeout"),
    PcA = Z1("stream"),
    $cA = 6000;
  async function O_1(A, B, Q = $cA) {
    let I = B.headers ?? {},
      G = I.Expect || I.expect,
      Z = -1,
      D = !0;
    if (G === "100-continue") D = await Promise.race([new Promise((Y) => {
      Z = Number(kY.setTimeout(() => Y(!0), Math.max($cA, Q)))
    }), new Promise((Y) => {
      A.on("continue", () => {
        kY.clearTimeout(Z), Y(!0)
      }), A.on("response", () => {
        kY.clearTimeout(Z), Y(!1)
      }), A.on("error", () => {
        kY.clearTimeout(Z), Y(!1)
      })
    })]);
    if (D) ScA(A, B.body)
  }
  d8(O_1, "writeRequestBody");

  function ScA(A, B) {
    if (B instanceof PcA.Readable) {
      B.pipe(A);
      return
    }
    if (B) {
      if (Buffer.isBuffer(B) || typeof B === "string") {
        A.end(B);
        return
      }
      let Q = B;
      if (typeof Q === "object" && Q.buffer && typeof Q.byteOffset === "number" && typeof Q.byteLength === "number") {
        A.end(Buffer.from(Q.buffer, Q.byteOffset, Q.byteLength));
        return
      }
      A.end(Buffer.from(B));
      return
    }
    A.end()
  }
  d8(ScA, "writeBody");
  var _cA = 0,
    U54 = class A {
      constructor(B) {
        this.socketWarningTimestamp = 0, this.metadata = {
          handlerProtocol: "http/1.1"
        }, this.configProvider = new Promise((Q, I) => {
          if (typeof B === "function") B().then((G) => {
            Q(this.resolveDefaultConfig(G))
          }).catch(I);
          else Q(this.resolveDefaultConfig(B))
        })
      }
      static {
        d8(this, "NodeHttpHandler")
      }
      static create(B) {
        if (typeof B?.handle === "function") return B;
        return new A(B)
      }
      static checkSocketUsage(B, Q, I = console) {
        let {
          sockets: G,
          requests: Z,
          maxSockets: D
        } = B;
        if (typeof D !== "number" || D === 1 / 0) return Q;
        let Y = 15000;
        if (Date.now() - Y < Q) return Q;
        if (G && Z)
          for (let W in G) {
            let J = G[W]?.length ?? 0,
              F = Z[W]?.length ?? 0;
            if (J >= D && F >= 2 * D) return I?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${J} and ${F} additional requests are enqueued.
See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html
or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`), Date.now()
          }
        return Q
      }
      resolveDefaultConfig(B) {
        let {
          requestTimeout: Q,
          connectionTimeout: I,
          socketTimeout: G,
          socketAcquisitionWarningTimeout: Z,
          httpAgent: D,
          httpsAgent: Y
        } = B || {}, W = !0, J = 50;
        return {
          connectionTimeout: I,
          requestTimeout: Q ?? G,
          socketAcquisitionWarningTimeout: Z,
          httpAgent: (() => {
            if (D instanceof L_1.Agent || typeof D?.destroy === "function") return D;
            return new L_1.Agent({
              keepAlive: !0,
              maxSockets: 50,
              ...D
            })
          })(),
          httpsAgent: (() => {
            if (Y instanceof R_1.Agent || typeof Y?.destroy === "function") return Y;
            return new R_1.Agent({
              keepAlive: !0,
              maxSockets: 50,
              ...Y
            })
          })(),
          logger: console
        }
      }
      destroy() {
        this.config?.httpAgent?.destroy(), this.config?.httpsAgent?.destroy()
      }
      async handle(B, {
        abortSignal: Q
      } = {}) {
        if (!this.config) this.config = await this.configProvider;
        return new Promise((I, G) => {
          let Z = void 0,
            D = [],
            Y = d8(async (R) => {
              await Z, D.forEach(kY.clearTimeout), I(R)
            }, "resolve"),
            W = d8(async (R) => {
              await Z, D.forEach(kY.clearTimeout), G(R)
            }, "reject");
          if (!this.config) throw new Error("Node HTTP request handler config is not resolved");
          if (Q?.aborted) {
            let R = new Error("Request aborted");
            R.name = "AbortError", W(R);
            return
          }
          let J = B.protocol === "https:",
            F = J ? this.config.httpsAgent : this.config.httpAgent;
          D.push(kY.setTimeout(() => {
            this.socketWarningTimestamp = A.checkSocketUsage(F, this.socketWarningTimestamp, this.config.logger)
          }, this.config.socketAcquisitionWarningTimeout ?? (this.config.requestTimeout ?? 2000) + (this.config.connectionTimeout ?? 1000)));
          let X = OcA.buildQueryString(B.query || {}),
            V = void 0;
          if (B.username != null || B.password != null) {
            let R = B.username ?? "",
              T = B.password ?? "";
            V = `${R}:${T}`
          }
          let C = B.path;
          if (X) C += `?${X}`;
          if (B.fragment) C += `#${B.fragment}`;
          let K = B.hostname ?? "";
          if (K[0] === "[" && K.endsWith("]")) K = B.hostname.slice(1, -1);
          else K = B.hostname;
          let E = {
              headers: B.headers,
              host: K,
              method: B.method,
              path: C,
              port: B.port,
              agent: F,
              auth: V
            },
            q = (J ? R_1.request : L_1.request)(E, (R) => {
              let T = new RcA.HttpResponse({
                statusCode: R.statusCode || -1,
                reason: R.statusMessage,
                headers: TcA(R.headers),
                body: R
              });
              Y({
                response: T
              })
            });
          if (q.on("error", (R) => {
              if (K54.includes(R.code)) W(Object.assign(R, {
                name: "TimeoutError"
              }));
              else W(R)
            }), Q) {
            let R = d8(() => {
              q.destroy();
              let T = new Error("Request aborted");
              T.name = "AbortError", W(T)
            }, "onAbort");
            if (typeof Q.addEventListener === "function") {
              let T = Q;
              T.addEventListener("abort", R, {
                once: !0
              }), q.once("close", () => T.removeEventListener("abort", R))
            } else Q.onabort = R
          }
          D.push(H54(q, W, this.config.connectionTimeout)), D.push(E54(q, W, this.config.requestTimeout));
          let O = E.agent;
          if (typeof O === "object" && "keepAlive" in O) D.push(w54(q, {
            keepAlive: O.keepAlive,
            keepAliveMsecs: O.keepAliveMsecs
          }));
          Z = O_1(q, B, this.config.requestTimeout).catch((R) => {
            return D.forEach(kY.clearTimeout), G(R)
          })
        })
      }
      updateHttpClientConfig(B, Q) {
        this.config = void 0, this.configProvider = this.configProvider.then((I) => {
          return {
            ...I,
            [B]: Q
          }
        })
      }
      httpHandlerConfigs() {
        return this.config ?? {}
      }
    },
    qcA = Z1("http2"),
    N54 = V54(Z1("http2")),
    $54 = class {
      constructor(A) {
        this.sessions = [], this.sessions = A ?? []
      }
      static {
        d8(this, "NodeHttp2ConnectionPool")
      }
      poll() {
        if (this.sessions.length > 0) return this.sessions.shift()
      }
      offerLast(A) {
        this.sessions.push(A)
      }
      contains(A) {
        return this.sessions.includes(A)
      }
      remove(A) {
        this.sessions = this.sessions.filter((B) => B !== A)
      } [Symbol.iterator]() {
        return this.sessions[Symbol.iterator]()
      }
      destroy(A) {
        for (let B of this.sessions)
          if (B === A) {
            if (!B.destroyed) B.destroy()
          }
      }
    },
    q54 = class {
      constructor(A) {
        if (this.sessionCache = new Map, this.config = A, this.config.maxConcurrency && this.config.maxConcurrency <= 0) throw new RangeError("maxConcurrency must be greater than zero.")
      }
      static {
        d8(this, "NodeHttp2ConnectionManager")
      }
      lease(A, B) {
        let Q = this.getUrlString(A),
          I = this.sessionCache.get(Q);
        if (I) {
          let Y = I.poll();
          if (Y && !this.config.disableConcurrency) return Y
        }
        let G = N54.default.connect(Q);
        if (this.config.maxConcurrency) G.settings({
          maxConcurrentStreams: this.config.maxConcurrency
        }, (Y) => {
          if (Y) throw new Error("Fail to set maxConcurrentStreams to " + this.config.maxConcurrency + "when creating new session for " + A.destination.toString())
        });
        G.unref();
        let Z = d8(() => {
          G.destroy(), this.deleteSession(Q, G)
        }, "destroySessionCb");
        if (G.on("goaway", Z), G.on("error", Z), G.on("frameError", Z), G.on("close", () => this.deleteSession(Q, G)), B.requestTimeout) G.setTimeout(B.requestTimeout, Z);
        let D = this.sessionCache.get(Q) || new $54;
        return D.offerLast(G), this.sessionCache.set(Q, D), G
      }
      deleteSession(A, B) {
        let Q = this.sessionCache.get(A);
        if (!Q) return;
        if (!Q.contains(B)) return;
        Q.remove(B), this.sessionCache.set(A, Q)
      }
      release(A, B) {
        let Q = this.getUrlString(A);
        this.sessionCache.get(Q)?.offerLast(B)
      }
      destroy() {
        for (let [A, B] of this.sessionCache) {
          for (let Q of B) {
            if (!Q.destroyed) Q.destroy();
            B.remove(Q)
          }
          this.sessionCache.delete(A)
        }
      }
      setMaxConcurrentStreams(A) {
        if (A && A <= 0) throw new RangeError("maxConcurrentStreams must be greater than zero.");
        this.config.maxConcurrency = A
      }
      setDisableConcurrentStreams(A) {
        this.config.disableConcurrency = A
      }
      getUrlString(A) {
        return A.destination.toString()
      }
    },
    M54 = class A {
      constructor(B) {
        this.metadata = {
          handlerProtocol: "h2"
        }, this.connectionManager = new q54({}), this.configProvider = new Promise((Q, I) => {
          if (typeof B === "function") B().then((G) => {
            Q(G || {})
          }).catch(I);
          else Q(B || {})
        })
      }
      static {
        d8(this, "NodeHttp2Handler")
      }
      static create(B) {
        if (typeof B?.handle === "function") return B;
        return new A(B)
      }
      destroy() {
        this.connectionManager.destroy()
      }
      async handle(B, {
        abortSignal: Q
      } = {}) {
        if (!this.config) {
          if (this.config = await this.configProvider, this.connectionManager.setDisableConcurrentStreams(this.config.disableConcurrentStreams || !1), this.config.maxConcurrentStreams) this.connectionManager.setMaxConcurrentStreams(this.config.maxConcurrentStreams)
        }
        let {
          requestTimeout: I,
          disableConcurrentStreams: G
        } = this.config;
        return new Promise((Z, D) => {
          let Y = !1,
            W = void 0,
            J = d8(async (i) => {
              await W, Z(i)
            }, "resolve"),
            F = d8(async (i) => {
              await W, D(i)
            }, "reject");
          if (Q?.aborted) {
            Y = !0;
            let i = new Error("Request aborted");
            i.name = "AbortError", F(i);
            return
          }
          let {
            hostname: X,
            method: V,
            port: C,
            protocol: K,
            query: E
          } = B, N = "";
          if (B.username != null || B.password != null) {
            let i = B.username ?? "",
              x = B.password ?? "";
            N = `${i}:${x}@`
          }
          let q = `${K}//${N}${X}${C?`:${C}`:""}`,
            O = {
              destination: new URL(q)
            },
            R = this.connectionManager.lease(O, {
              requestTimeout: this.config?.sessionTimeout,
              disableConcurrentStreams: G || !1
            }),
            T = d8((i) => {
              if (G) this.destroySession(R);
              Y = !0, F(i)
            }, "rejectWithDestroy"),
            L = OcA.buildQueryString(E || {}),
            _ = B.path;
          if (L) _ += `?${L}`;
          if (B.fragment) _ += `#${B.fragment}`;
          let k = R.request({
            ...B.headers,
            [qcA.constants.HTTP2_HEADER_PATH]: _,
            [qcA.constants.HTTP2_HEADER_METHOD]: V
          });
          if (R.ref(), k.on("response", (i) => {
              let x = new RcA.HttpResponse({
                statusCode: i[":status"] || -1,
                headers: TcA(i),
                body: k
              });
              if (Y = !0, J({
                  response: x
                }), G) R.close(), this.connectionManager.deleteSession(q, R)
            }), I) k.setTimeout(I, () => {
            k.close();
            let i = new Error(`Stream timed out because of no activity for ${I} ms`);
            i.name = "TimeoutError", T(i)
          });
          if (Q) {
            let i = d8(() => {
              k.close();
              let x = new Error("Request aborted");
              x.name = "AbortError", T(x)
            }, "onAbort");
            if (typeof Q.addEventListener === "function") {
              let x = Q;
              x.addEventListener("abort", i, {
                once: !0
              }), k.once("close", () => x.removeEventListener("abort", i))
            } else Q.onabort = i
          }
          k.on("frameError", (i, x, s) => {
            T(new Error(`Frame type id ${i} in stream id ${s} has failed with code ${x}.`))
          }), k.on("error", T), k.on("aborted", () => {
            T(new Error(`HTTP/2 stream is abnormally aborted in mid-communication with result code ${k.rstCode}.`))
          }), k.on("close", () => {
            if (R.unref(), G) R.destroy();
            if (!Y) T(new Error("Unexpected error: http2 request did not get a response"))
          }), W = O_1(k, B, I)
        })
      }
      updateHttpClientConfig(B, Q) {
        this.config = void 0, this.configProvider = this.configProvider.then((I) => {
          return {
            ...I,
            [B]: Q
          }
        })
      }
      httpHandlerConfigs() {
        return this.config ?? {}
      }
      destroySession(B) {
        if (!B.destroyed) B.destroy()
      }
    },
    L54 = class extends PcA.Writable {
      constructor() {
        super(...arguments);
        this.bufferedBytes = []
      }
      static {
        d8(this, "Collector")
      }
      _write(A, B, Q) {
        this.bufferedBytes.push(A), Q()
      }
    },
    R54 = d8((A) => {
      if (O54(A)) return jcA(A);
      return new Promise((B, Q) => {
        let I = new L54;
        A.pipe(I), A.on("error", (G) => {
          I.end(), Q(G)
        }), I.on("error", Q), I.on("finish", function() {
          let G = new Uint8Array(Buffer.concat(this.bufferedBytes));
          B(G)
        })
      })
    }, "streamCollector"),
    O54 = d8((A) => typeof ReadableStream === "function" && A instanceof ReadableStream, "isReadableStreamInstance");
  async function jcA(A) {
    let B = [],
      Q = A.getReader(),
      I = !1,
      G = 0;
    while (!I) {
      let {
        done: Y,
        value: W
      } = await Q.read();
      if (W) B.push(W), G += W.length;
      I = Y
    }
    let Z = new Uint8Array(G),
      D = 0;
    for (let Y of B) Z.set(Y, D), D += Y.length;
    return Z
  }
  d8(jcA, "collectReadableStream")
})
// @from(Start 3112419, End 3115202)
ucA = z((XQ8, dcA) => {
  var {
    defineProperty: HQ1,
    getOwnPropertyDescriptor: T54,
    getOwnPropertyNames: P54
  } = Object, S54 = Object.prototype.hasOwnProperty, zQ1 = (A, B) => HQ1(A, "name", {
    value: B,
    configurable: !0
  }), _54 = (A, B) => {
    for (var Q in B) HQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, j54 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of P54(B))
        if (!S54.call(A, G) && G !== Q) HQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = T54(B, G)) || I.enumerable
        })
    }
    return A
  }, y54 = (A) => j54(HQ1({}, "__esModule", {
    value: !0
  }), A), kcA = {};
  _54(kcA, {
    AlgorithmId: () => bcA,
    EndpointURLScheme: () => vcA,
    FieldPosition: () => gcA,
    HttpApiKeyAuthLocation: () => fcA,
    HttpAuthLocation: () => xcA,
    IniSectionType: () => hcA,
    RequestHandlerProtocol: () => mcA,
    SMITHY_CONTEXT_KEY: () => b54,
    getDefaultClientConfiguration: () => f54,
    resolveDefaultRuntimeConfig: () => v54
  });
  dcA.exports = y54(kcA);
  var xcA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(xcA || {}),
    fcA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(fcA || {}),
    vcA = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(vcA || {}),
    bcA = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(bcA || {}),
    k54 = zQ1((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    x54 = zQ1((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    f54 = zQ1((A) => {
      return k54(A)
    }, "getDefaultClientConfiguration"),
    v54 = zQ1((A) => {
      return x54(A)
    }, "resolveDefaultRuntimeConfig"),
    gcA = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(gcA || {}),
    b54 = "__smithy_context",
    hcA = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(hcA || {}),
    mcA = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(mcA || {})
})
// @from(Start 3115208, End 3119715)
acA = z((VQ8, ncA) => {
  var {
    defineProperty: wQ1,
    getOwnPropertyDescriptor: g54,
    getOwnPropertyNames: h54
  } = Object, m54 = Object.prototype.hasOwnProperty, qL = (A, B) => wQ1(A, "name", {
    value: B,
    configurable: !0
  }), d54 = (A, B) => {
    for (var Q in B) wQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, u54 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of h54(B))
        if (!m54.call(A, G) && G !== Q) wQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = g54(B, G)) || I.enumerable
        })
    }
    return A
  }, p54 = (A) => u54(wQ1({}, "__esModule", {
    value: !0
  }), A), pcA = {};
  d54(pcA, {
    Field: () => i54,
    Fields: () => n54,
    HttpRequest: () => a54,
    HttpResponse: () => s54,
    IHttpRequest: () => ccA.HttpRequest,
    getHttpHandlerExtensionConfiguration: () => c54,
    isValidHostname: () => icA,
    resolveHttpHandlerRuntimeConfig: () => l54
  });
  ncA.exports = p54(pcA);
  var c54 = qL((A) => {
      return {
        setHttpHandler(B) {
          A.httpHandler = B
        },
        httpHandler() {
          return A.httpHandler
        },
        updateHttpClientConfig(B, Q) {
          A.httpHandler?.updateHttpClientConfig(B, Q)
        },
        httpHandlerConfigs() {
          return A.httpHandler.httpHandlerConfigs()
        }
      }
    }, "getHttpHandlerExtensionConfiguration"),
    l54 = qL((A) => {
      return {
        httpHandler: A.httpHandler()
      }
    }, "resolveHttpHandlerRuntimeConfig"),
    ccA = ucA(),
    i54 = class {
      static {
        qL(this, "Field")
      }
      constructor({
        name: A,
        kind: B = ccA.FieldPosition.HEADER,
        values: Q = []
      }) {
        this.name = A, this.kind = B, this.values = Q
      }
      add(A) {
        this.values.push(A)
      }
      set(A) {
        this.values = A
      }
      remove(A) {
        this.values = this.values.filter((B) => B !== A)
      }
      toString() {
        return this.values.map((A) => A.includes(",") || A.includes(" ") ? `"${A}"` : A).join(", ")
      }
      get() {
        return this.values
      }
    },
    n54 = class {
      constructor({
        fields: A = [],
        encoding: B = "utf-8"
      }) {
        this.entries = {}, A.forEach(this.setField.bind(this)), this.encoding = B
      }
      static {
        qL(this, "Fields")
      }
      setField(A) {
        this.entries[A.name.toLowerCase()] = A
      }
      getField(A) {
        return this.entries[A.toLowerCase()]
      }
      removeField(A) {
        delete this.entries[A.toLowerCase()]
      }
      getByType(A) {
        return Object.values(this.entries).filter((B) => B.kind === A)
      }
    },
    a54 = class A {
      static {
        qL(this, "HttpRequest")
      }
      constructor(B) {
        this.method = B.method || "GET", this.hostname = B.hostname || "localhost", this.port = B.port, this.query = B.query || {}, this.headers = B.headers || {}, this.body = B.body, this.protocol = B.protocol ? B.protocol.slice(-1) !== ":" ? `${B.protocol}:` : B.protocol : "https:", this.path = B.path ? B.path.charAt(0) !== "/" ? `/${B.path}` : B.path : "/", this.username = B.username, this.password = B.password, this.fragment = B.fragment
      }
      static clone(B) {
        let Q = new A({
          ...B,
          headers: {
            ...B.headers
          }
        });
        if (Q.query) Q.query = lcA(Q.query);
        return Q
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return "method" in Q && "protocol" in Q && "hostname" in Q && "path" in Q && typeof Q.query === "object" && typeof Q.headers === "object"
      }
      clone() {
        return A.clone(this)
      }
    };

  function lcA(A) {
    return Object.keys(A).reduce((B, Q) => {
      let I = A[Q];
      return {
        ...B,
        [Q]: Array.isArray(I) ? [...I] : I
      }
    }, {})
  }
  qL(lcA, "cloneQuery");
  var s54 = class {
    static {
      qL(this, "HttpResponse")
    }
    constructor(A) {
      this.statusCode = A.statusCode, this.reason = A.reason, this.headers = A.headers || {}, this.body = A.body
    }
    static isInstance(A) {
      if (!A) return !1;
      let B = A;
      return typeof B.statusCode === "number" && typeof B.headers === "object"
    }
  };

  function icA(A) {
    return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(A)
  }
  qL(icA, "isValidHostname")
})
// @from(Start 3119721, End 3120774)
tcA = z((zQ8, ocA) => {
  var {
    defineProperty: EQ1,
    getOwnPropertyDescriptor: r54,
    getOwnPropertyNames: o54
  } = Object, t54 = Object.prototype.hasOwnProperty, T_1 = (A, B) => EQ1(A, "name", {
    value: B,
    configurable: !0
  }), e54 = (A, B) => {
    for (var Q in B) EQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, A84 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of o54(B))
        if (!t54.call(A, G) && G !== Q) EQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = r54(B, G)) || I.enumerable
        })
    }
    return A
  }, B84 = (A) => A84(EQ1({}, "__esModule", {
    value: !0
  }), A), scA = {};
  e54(scA, {
    escapeUri: () => rcA,
    escapeUriPath: () => I84
  });
  ocA.exports = B84(scA);
  var rcA = T_1((A) => encodeURIComponent(A).replace(/[!'()*]/g, Q84), "escapeUri"),
    Q84 = T_1((A) => `%${A.charCodeAt(0).toString(16).toUpperCase()}`, "hexEncode"),
    I84 = T_1((A) => A.split("/").map(rcA).join("/"), "escapeUriPath")
})
// @from(Start 3120780, End 3122018)
QlA = z((wQ8, BlA) => {
  var {
    defineProperty: UQ1,
    getOwnPropertyDescriptor: G84,
    getOwnPropertyNames: Z84
  } = Object, D84 = Object.prototype.hasOwnProperty, Y84 = (A, B) => UQ1(A, "name", {
    value: B,
    configurable: !0
  }), W84 = (A, B) => {
    for (var Q in B) UQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, J84 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of Z84(B))
        if (!D84.call(A, G) && G !== Q) UQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = G84(B, G)) || I.enumerable
        })
    }
    return A
  }, F84 = (A) => J84(UQ1({}, "__esModule", {
    value: !0
  }), A), ecA = {};
  W84(ecA, {
    buildQueryString: () => AlA
  });
  BlA.exports = F84(ecA);
  var P_1 = tcA();

  function AlA(A) {
    let B = [];
    for (let Q of Object.keys(A).sort()) {
      let I = A[Q];
      if (Q = P_1.escapeUri(Q), Array.isArray(I))
        for (let G = 0, Z = I.length; G < Z; G++) B.push(`${Q}=${P_1.escapeUri(I[G])}`);
      else {
        let G = Q;
        if (I || typeof I === "string") G += `=${P_1.escapeUri(I)}`;
        B.push(G)
      }
    }
    return B.join("&")
  }
  Y84(AlA, "buildQueryString")
})
// @from(Start 3122024, End 3128018)
FlA = z((EQ8, JlA) => {
  var {
    defineProperty: $Q1,
    getOwnPropertyDescriptor: X84,
    getOwnPropertyNames: V84
  } = Object, C84 = Object.prototype.hasOwnProperty, kz = (A, B) => $Q1(A, "name", {
    value: B,
    configurable: !0
  }), K84 = (A, B) => {
    for (var Q in B) $Q1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, H84 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of V84(B))
        if (!C84.call(A, G) && G !== Q) $Q1(A, G, {
          get: () => B[G],
          enumerable: !(I = X84(B, G)) || I.enumerable
        })
    }
    return A
  }, z84 = (A) => H84($Q1({}, "__esModule", {
    value: !0
  }), A), GlA = {};
  K84(GlA, {
    FetchHttpHandler: () => E84,
    keepAliveSupport: () => NQ1,
    streamCollector: () => N84
  });
  JlA.exports = z84(GlA);
  var IlA = acA(),
    w84 = QlA();

  function S_1(A, B) {
    return new Request(A, B)
  }
  kz(S_1, "createRequest");

  function ZlA(A = 0) {
    return new Promise((B, Q) => {
      if (A) setTimeout(() => {
        let I = new Error(`Request did not complete within ${A} ms`);
        I.name = "TimeoutError", Q(I)
      }, A)
    })
  }
  kz(ZlA, "requestTimeout");
  var NQ1 = {
      supported: void 0
    },
    E84 = class A {
      static {
        kz(this, "FetchHttpHandler")
      }
      static create(B) {
        if (typeof B?.handle === "function") return B;
        return new A(B)
      }
      constructor(B) {
        if (typeof B === "function") this.configProvider = B().then((Q) => Q || {});
        else this.config = B ?? {}, this.configProvider = Promise.resolve(this.config);
        if (NQ1.supported === void 0) NQ1.supported = Boolean(typeof Request !== "undefined" && "keepalive" in S_1("https://[::1]"))
      }
      destroy() {}
      async handle(B, {
        abortSignal: Q
      } = {}) {
        if (!this.config) this.config = await this.configProvider;
        let I = this.config.requestTimeout,
          G = this.config.keepAlive === !0,
          Z = this.config.credentials;
        if (Q?.aborted) {
          let q = new Error("Request aborted");
          return q.name = "AbortError", Promise.reject(q)
        }
        let D = B.path,
          Y = w84.buildQueryString(B.query || {});
        if (Y) D += `?${Y}`;
        if (B.fragment) D += `#${B.fragment}`;
        let W = "";
        if (B.username != null || B.password != null) {
          let q = B.username ?? "",
            O = B.password ?? "";
          W = `${q}:${O}@`
        }
        let {
          port: J,
          method: F
        } = B, X = `${B.protocol}//${W}${B.hostname}${J?`:${J}`:""}${D}`, V = F === "GET" || F === "HEAD" ? void 0 : B.body, C = {
          body: V,
          headers: new Headers(B.headers),
          method: F,
          credentials: Z
        };
        if (this.config?.cache) C.cache = this.config.cache;
        if (V) C.duplex = "half";
        if (typeof AbortController !== "undefined") C.signal = Q;
        if (NQ1.supported) C.keepalive = G;
        if (typeof this.config.requestInit === "function") Object.assign(C, this.config.requestInit(B));
        let K = kz(() => {}, "removeSignalEventListener"),
          E = S_1(X, C),
          N = [fetch(E).then((q) => {
            let O = q.headers,
              R = {};
            for (let L of O.entries()) R[L[0]] = L[1];
            if (q.body == null) return q.blob().then((L) => ({
              response: new IlA.HttpResponse({
                headers: R,
                reason: q.statusText,
                statusCode: q.status,
                body: L
              })
            }));
            return {
              response: new IlA.HttpResponse({
                headers: R,
                reason: q.statusText,
                statusCode: q.status,
                body: q.body
              })
            }
          }), ZlA(I)];
        if (Q) N.push(new Promise((q, O) => {
          let R = kz(() => {
            let T = new Error("Request aborted");
            T.name = "AbortError", O(T)
          }, "onAbort");
          if (typeof Q.addEventListener === "function") {
            let T = Q;
            T.addEventListener("abort", R, {
              once: !0
            }), K = kz(() => T.removeEventListener("abort", R), "removeSignalEventListener")
          } else Q.onabort = R
        }));
        return Promise.race(N).finally(K)
      }
      updateHttpClientConfig(B, Q) {
        this.config = void 0, this.configProvider = this.configProvider.then((I) => {
          return I[B] = Q, I
        })
      }
      httpHandlerConfigs() {
        return this.config ?? {}
      }
    },
    U84 = Wb(),
    N84 = kz(async (A) => {
      if (typeof Blob === "function" && A instanceof Blob || A.constructor?.name === "Blob") {
        if (Blob.prototype.arrayBuffer !== void 0) return new Uint8Array(await A.arrayBuffer());
        return DlA(A)
      }
      return YlA(A)
    }, "streamCollector");
  async function DlA(A) {
    let B = await WlA(A),
      Q = U84.fromBase64(B);
    return new Uint8Array(Q)
  }
  kz(DlA, "collectBlob");
  async function YlA(A) {
    let B = [],
      Q = A.getReader(),
      I = !1,
      G = 0;
    while (!I) {
      let {
        done: Y,
        value: W
      } = await Q.read();
      if (W) B.push(W), G += W.length;
      I = Y
    }
    let Z = new Uint8Array(G),
      D = 0;
    for (let Y of B) Z.set(Y, D), D += Y.length;
    return Z
  }
  kz(YlA, "collectStream");

  function WlA(A) {
    return new Promise((B, Q) => {
      let I = new FileReader;
      I.onloadend = () => {
        if (I.readyState !== 2) return Q(new Error("Reader aborted too early"));
        let G = I.result ?? "",
          Z = G.indexOf(","),
          D = Z > -1 ? Z + 1 : G.length;
        B(G.substring(D))
      }, I.onabort = () => Q(new Error("Read aborted")), I.onerror = () => Q(I.error), I.readAsDataURL(A)
    })
  }
  kz(WlA, "readToBase64")
})
// @from(Start 3128024, End 3129558)
MQ1 = z((UQ8, zlA) => {
  var {
    defineProperty: qQ1,
    getOwnPropertyDescriptor: $84,
    getOwnPropertyNames: q84
  } = Object, M84 = Object.prototype.hasOwnProperty, XlA = (A, B) => qQ1(A, "name", {
    value: B,
    configurable: !0
  }), L84 = (A, B) => {
    for (var Q in B) qQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, R84 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of q84(B))
        if (!M84.call(A, G) && G !== Q) qQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = $84(B, G)) || I.enumerable
        })
    }
    return A
  }, O84 = (A) => R84(qQ1({}, "__esModule", {
    value: !0
  }), A), VlA = {};
  L84(VlA, {
    fromHex: () => KlA,
    toHex: () => HlA
  });
  zlA.exports = O84(VlA);
  var ClA = {},
    __1 = {};
  for (let A = 0; A < 256; A++) {
    let B = A.toString(16).toLowerCase();
    if (B.length === 1) B = `0${B}`;
    ClA[A] = B, __1[B] = A
  }

  function KlA(A) {
    if (A.length % 2 !== 0) throw new Error("Hex encoded strings must have an even number length");
    let B = new Uint8Array(A.length / 2);
    for (let Q = 0; Q < A.length; Q += 2) {
      let I = A.slice(Q, Q + 2).toLowerCase();
      if (I in __1) B[Q / 2] = __1[I];
      else throw new Error(`Cannot decode unrecognized sequence ${I} as hexadecimal`)
    }
    return B
  }
  XlA(KlA, "fromHex");

  function HlA(A) {
    let B = "";
    for (let Q = 0; Q < A.byteLength; Q++) B += ClA[A[Q]];
    return B
  }
  XlA(HlA, "toHex")
})
// @from(Start 3129564, End 3131603)
qlA = z((NlA) => {
  Object.defineProperty(NlA, "__esModule", {
    value: !0
  });
  NlA.sdkStreamMixin = void 0;
  var T84 = FlA(),
    P84 = Wb(),
    S84 = MQ1(),
    _84 = RQ(),
    wlA = NL(),
    ElA = "The stream has already been transformed.",
    j84 = (A) => {
      var B, Q;
      if (!UlA(A) && !wlA.isReadableStream(A)) {
        let D = ((Q = (B = A === null || A === void 0 ? void 0 : A.__proto__) === null || B === void 0 ? void 0 : B.constructor) === null || Q === void 0 ? void 0 : Q.name) || A;
        throw new Error(`Unexpected stream implementation, expect Blob or ReadableStream, got ${D}`)
      }
      let I = !1,
        G = async () => {
          if (I) throw new Error(ElA);
          return I = !0, await T84.streamCollector(A)
        }, Z = (D) => {
          if (typeof D.stream !== "function") throw new Error(`Cannot transform payload Blob to web stream. Please make sure the Blob.stream() is polyfilled.
If you are using React Native, this API is not yet supported, see: https://react-native.canny.io/feature-requests/p/fetch-streaming-body`);
          return D.stream()
        };
      return Object.assign(A, {
        transformToByteArray: G,
        transformToString: async (D) => {
          let Y = await G();
          if (D === "base64") return P84.toBase64(Y);
          else if (D === "hex") return S84.toHex(Y);
          else if (D === void 0 || D === "utf8" || D === "utf-8") return _84.toUtf8(Y);
          else if (typeof TextDecoder === "function") return new TextDecoder(D).decode(Y);
          else throw new Error("TextDecoder is not available, please make sure polyfill is provided.")
        },
        transformToWebStream: () => {
          if (I) throw new Error(ElA);
          if (I = !0, UlA(A)) return Z(A);
          else if (wlA.isReadableStream(A)) return A;
          else throw new Error(`Cannot transform payload to web stream, got ${A}`)
        }
      })
    };
  NlA.sdkStreamMixin = j84;
  var UlA = (A) => typeof Blob === "function" && A instanceof Blob
})
// @from(Start 3131609, End 3133197)
OlA = z((LlA) => {
  Object.defineProperty(LlA, "__esModule", {
    value: !0
  });
  LlA.sdkStreamMixin = void 0;
  var y84 = DN(),
    k84 = MZ(),
    j_1 = Z1("stream"),
    x84 = qlA(),
    MlA = "The stream has already been transformed.",
    f84 = (A) => {
      var B, Q;
      if (!(A instanceof j_1.Readable)) try {
        return x84.sdkStreamMixin(A)
      } catch (Z) {
        let D = ((Q = (B = A === null || A === void 0 ? void 0 : A.__proto__) === null || B === void 0 ? void 0 : B.constructor) === null || Q === void 0 ? void 0 : Q.name) || A;
        throw new Error(`Unexpected stream implementation, expect Stream.Readable instance, got ${D}`)
      }
      let I = !1,
        G = async () => {
          if (I) throw new Error(MlA);
          return I = !0, await y84.streamCollector(A)
        };
      return Object.assign(A, {
        transformToByteArray: G,
        transformToString: async (Z) => {
          let D = await G();
          if (Z === void 0 || Buffer.isEncoding(Z)) return k84.fromArrayBuffer(D.buffer, D.byteOffset, D.byteLength).toString(Z);
          else return new TextDecoder(Z).decode(D)
        },
        transformToWebStream: () => {
          if (I) throw new Error(MlA);
          if (A.readableFlowing !== null) throw new Error("The stream has been consumed by other callbacks.");
          if (typeof j_1.Readable.toWeb !== "function") throw new Error("Readable.toWeb() is not supported. Please ensure a polyfill is available.");
          return I = !0, j_1.Readable.toWeb(A)
        }
      })
    };
  LlA.sdkStreamMixin = f84
})
// @from(Start 3133203, End 3133446)
SlA = z((TlA) => {
  Object.defineProperty(TlA, "__esModule", {
    value: !0
  });
  TlA.splitStream = void 0;
  async function v84(A) {
    if (typeof A.stream === "function") A = A.stream();
    return A.tee()
  }
  TlA.splitStream = v84
})
// @from(Start 3133452, End 3133860)
xlA = z((ylA) => {
  Object.defineProperty(ylA, "__esModule", {
    value: !0
  });
  ylA.splitStream = void 0;
  var _lA = Z1("stream"),
    b84 = SlA(),
    jlA = NL();
  async function g84(A) {
    if (jlA.isReadableStream(A) || jlA.isBlob(A)) return b84.splitStream(A);
    let B = new _lA.PassThrough,
      Q = new _lA.PassThrough;
    return A.pipe(B), A.pipe(Q), [B, Q]
  }
  ylA.splitStream = g84
})
// @from(Start 3133866, End 3135797)
f_1 = z((LQ8, fz) => {
  var {
    defineProperty: LQ1,
    getOwnPropertyDescriptor: h84,
    getOwnPropertyNames: m84
  } = Object, d84 = Object.prototype.hasOwnProperty, x_1 = (A, B) => LQ1(A, "name", {
    value: B,
    configurable: !0
  }), u84 = (A, B) => {
    for (var Q in B) LQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, y_1 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of m84(B))
        if (!d84.call(A, G) && G !== Q) LQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = h84(B, G)) || I.enumerable
        })
    }
    return A
  }, ML = (A, B, Q) => (y_1(A, B, "default"), Q && y_1(Q, B, "default")), p84 = (A) => y_1(LQ1({}, "__esModule", {
    value: !0
  }), A), xz = {};
  u84(xz, {
    Uint8ArrayBlobAdapter: () => k_1
  });
  fz.exports = p84(xz);
  var flA = Wb(),
    vlA = RQ();

  function blA(A, B = "utf-8") {
    if (B === "base64") return flA.toBase64(A);
    return vlA.toUtf8(A)
  }
  x_1(blA, "transformToString");

  function glA(A, B) {
    if (B === "base64") return k_1.mutate(flA.fromBase64(A));
    return k_1.mutate(vlA.fromUtf8(A))
  }
  x_1(glA, "transformFromString");
  var k_1 = class A extends Uint8Array {
    static {
      x_1(this, "Uint8ArrayBlobAdapter")
    }
    static fromString(B, Q = "utf-8") {
      switch (typeof B) {
        case "string":
          return glA(B, Q);
        default:
          throw new Error(`Unsupported conversion from ${typeof B} to Uint8ArrayBlobAdapter.`)
      }
    }
    static mutate(B) {
      return Object.setPrototypeOf(B, A.prototype), B
    }
    transformToString(B = "utf-8") {
      return blA(this, B)
    }
  };
  ML(xz, N_1(), fz.exports);
  ML(xz, RpA(), fz.exports);
  ML(xz, gpA(), fz.exports);
  ML(xz, dpA(), fz.exports);
  ML(xz, apA(), fz.exports);
  ML(xz, OlA(), fz.exports);
  ML(xz, xlA(), fz.exports);
  ML(xz, NL(), fz.exports)
})
// @from(Start 3135803, End 3138853)
vz = z((RQ8, ulA) => {
  var {
    defineProperty: g_1,
    getOwnPropertyDescriptor: c84,
    getOwnPropertyNames: l84
  } = Object, i84 = Object.prototype.hasOwnProperty, n84 = (A, B) => {
    for (var Q in B) g_1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, a84 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of l84(B))
        if (!i84.call(A, G) && G !== Q) g_1(A, G, {
          get: () => B[G],
          enumerable: !(I = c84(B, G)) || I.enumerable
        })
    }
    return A
  }, s84 = (A) => a84(g_1({}, "__esModule", {
    value: !0
  }), A), hlA = {};
  n84(hlA, {
    RequestBuilder: () => dlA,
    collectBody: () => r84,
    extendedEncodeURIComponent: () => b_1,
    requestBuilder: () => t84,
    resolvedPath: () => mlA
  });
  ulA.exports = s84(hlA);
  var v_1 = f_1(),
    r84 = async (A = new Uint8Array, B) => {
      if (A instanceof Uint8Array) return v_1.Uint8ArrayBlobAdapter.mutate(A);
      if (!A) return v_1.Uint8ArrayBlobAdapter.mutate(new Uint8Array);
      let Q = B.streamCollector(A);
      return v_1.Uint8ArrayBlobAdapter.mutate(await Q)
    };

  function b_1(A) {
    return encodeURIComponent(A).replace(/[!'()*]/g, function(B) {
      return "%" + B.charCodeAt(0).toString(16).toUpperCase()
    })
  }
  var o84 = H_1(),
    mlA = (A, B, Q, I, G, Z) => {
      if (B != null && B[Q] !== void 0) {
        let D = I();
        if (D.length <= 0) throw new Error("Empty value provided for input HTTP label: " + Q + ".");
        A = A.replace(G, Z ? D.split("/").map((Y) => b_1(Y)).join("/") : b_1(D))
      } else throw new Error("No value provided for input HTTP label: " + Q + ".");
      return A
    };

  function t84(A, B) {
    return new dlA(A, B)
  }
  var dlA = class {
    constructor(A, B) {
      this.input = A, this.context = B, this.query = {}, this.method = "", this.headers = {}, this.path = "", this.body = null, this.hostname = "", this.resolvePathStack = []
    }
    async build() {
      let {
        hostname: A,
        protocol: B = "https",
        port: Q,
        path: I
      } = await this.context.endpoint();
      this.path = I;
      for (let G of this.resolvePathStack) G(this.path);
      return new o84.HttpRequest({
        protocol: B,
        hostname: this.hostname || A,
        port: Q,
        method: this.method,
        path: this.path,
        query: this.query,
        body: this.body,
        headers: this.headers
      })
    }
    hn(A) {
      return this.hostname = A, this
    }
    bp(A) {
      return this.resolvePathStack.push((B) => {
        this.path = `${B?.endsWith("/")?B.slice(0,-1):B||""}` + A
      }), this
    }
    p(A, B, Q, I) {
      return this.resolvePathStack.push((G) => {
        this.path = mlA(G, this.input, A, B, Q, I)
      }), this
    }
    h(A) {
      return this.headers = A, this
    }
    q(A) {
      return this.query = A, this
    }
    b(A) {
      return this.body = A, this
    }
    m(A) {
      return this.method = A, this
    }
  }
})
// @from(Start 3138859, End 3148887)
NI = z((TQ8, BiA) => {
  var {
    defineProperty: OQ1,
    getOwnPropertyDescriptor: e84,
    getOwnPropertyNames: AB4
  } = Object, BB4 = Object.prototype.hasOwnProperty, rB = (A, B) => OQ1(A, "name", {
    value: B,
    configurable: !0
  }), QB4 = (A, B) => {
    for (var Q in B) OQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, IB4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of AB4(B))
        if (!BB4.call(A, G) && G !== Q) OQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = e84(B, G)) || I.enumerable
        })
    }
    return A
  }, GB4 = (A) => IB4(OQ1({}, "__esModule", {
    value: !0
  }), A), plA = {};
  QB4(plA, {
    DefaultIdentityProviderConfig: () => wB4,
    EXPIRATION_MS: () => elA,
    HttpApiKeyAuthSigner: () => EB4,
    HttpBearerAuthSigner: () => UB4,
    NoAuthSigner: () => NB4,
    createIsIdentityExpiredFunction: () => tlA,
    createPaginator: () => rlA,
    doesIdentityRequireRefresh: () => AiA,
    getHttpAuthSchemeEndpointRuleSetPlugin: () => YB4,
    getHttpAuthSchemePlugin: () => JB4,
    getHttpSigningPlugin: () => VB4,
    getSmithyContext: () => ZB4,
    httpAuthSchemeEndpointRuleSetMiddlewareOptions: () => ilA,
    httpAuthSchemeMiddleware: () => h_1,
    httpAuthSchemeMiddlewareOptions: () => nlA,
    httpSigningMiddleware: () => alA,
    httpSigningMiddlewareOptions: () => slA,
    isIdentityExpired: () => $B4,
    memoizeIdentityProvider: () => qB4,
    normalizeProvider: () => CB4,
    requestBuilder: () => zB4.requestBuilder,
    setFeature: () => olA
  });
  BiA.exports = GB4(plA);
  var RQ1 = C_1(),
    ZB4 = rB((A) => A[RQ1.SMITHY_CONTEXT_KEY] || (A[RQ1.SMITHY_CONTEXT_KEY] = {}), "getSmithyContext"),
    clA = ZX(),
    DB4 = rB((A, B) => {
      if (!B || B.length === 0) return A;
      let Q = [];
      for (let I of B)
        for (let G of A)
          if (G.schemeId.split("#")[1] === I) Q.push(G);
      for (let I of A)
        if (!Q.find(({
            schemeId: G
          }) => G === I.schemeId)) Q.push(I);
      return Q
    }, "resolveAuthOptions");

  function llA(A) {
    let B = new Map;
    for (let Q of A) B.set(Q.schemeId, Q);
    return B
  }
  rB(llA, "convertHttpAuthSchemesToMap");
  var h_1 = rB((A, B) => (Q, I) => async (G) => {
      let Z = A.httpAuthSchemeProvider(await B.httpAuthSchemeParametersProvider(A, I, G.input)),
        D = A.authSchemePreference ? await A.authSchemePreference() : [],
        Y = DB4(Z, D),
        W = llA(A.httpAuthSchemes),
        J = clA.getSmithyContext(I),
        F = [];
      for (let X of Y) {
        let V = W.get(X.schemeId);
        if (!V) {
          F.push(`HttpAuthScheme \`${X.schemeId}\` was not enabled for this service.`);
          continue
        }
        let C = V.identityProvider(await B.identityProviderConfigProvider(A));
        if (!C) {
          F.push(`HttpAuthScheme \`${X.schemeId}\` did not have an IdentityProvider configured.`);
          continue
        }
        let {
          identityProperties: K = {},
          signingProperties: E = {}
        } = X.propertiesExtractor?.(A, I) || {};
        X.identityProperties = Object.assign(X.identityProperties || {}, K), X.signingProperties = Object.assign(X.signingProperties || {}, E), J.selectedHttpAuthScheme = {
          httpAuthOption: X,
          identity: await C(X.identityProperties),
          signer: V.signer
        };
        break
      }
      if (!J.selectedHttpAuthScheme) throw new Error(F.join(`
`));
      return Q(G)
    }, "httpAuthSchemeMiddleware"),
    ilA = {
      step: "serialize",
      tags: ["HTTP_AUTH_SCHEME"],
      name: "httpAuthSchemeMiddleware",
      override: !0,
      relation: "before",
      toMiddleware: "endpointV2Middleware"
    },
    YB4 = rB((A, {
      httpAuthSchemeParametersProvider: B,
      identityProviderConfigProvider: Q
    }) => ({
      applyToStack: (I) => {
        I.addRelativeTo(h_1(A, {
          httpAuthSchemeParametersProvider: B,
          identityProviderConfigProvider: Q
        }), ilA)
      }
    }), "getHttpAuthSchemeEndpointRuleSetPlugin"),
    WB4 = yz(),
    nlA = {
      step: "serialize",
      tags: ["HTTP_AUTH_SCHEME"],
      name: "httpAuthSchemeMiddleware",
      override: !0,
      relation: "before",
      toMiddleware: WB4.serializerMiddlewareOption.name
    },
    JB4 = rB((A, {
      httpAuthSchemeParametersProvider: B,
      identityProviderConfigProvider: Q
    }) => ({
      applyToStack: (I) => {
        I.addRelativeTo(h_1(A, {
          httpAuthSchemeParametersProvider: B,
          identityProviderConfigProvider: Q
        }), nlA)
      }
    }), "getHttpAuthSchemePlugin"),
    m_1 = H_1(),
    FB4 = rB((A) => (B) => {
      throw B
    }, "defaultErrorHandler"),
    XB4 = rB((A, B) => {}, "defaultSuccessHandler"),
    alA = rB((A) => (B, Q) => async (I) => {
      if (!m_1.HttpRequest.isInstance(I.request)) return B(I);
      let Z = clA.getSmithyContext(Q).selectedHttpAuthScheme;
      if (!Z) throw new Error("No HttpAuthScheme was selected: unable to sign request");
      let {
        httpAuthOption: {
          signingProperties: D = {}
        },
        identity: Y,
        signer: W
      } = Z, J = await B({
        ...I,
        request: await W.sign(I.request, Y, D)
      }).catch((W.errorHandler || FB4)(D));
      return (W.successHandler || XB4)(J.response, D), J
    }, "httpSigningMiddleware"),
    slA = {
      step: "finalizeRequest",
      tags: ["HTTP_SIGNING"],
      name: "httpSigningMiddleware",
      aliases: ["apiKeyMiddleware", "tokenMiddleware", "awsAuthMiddleware"],
      override: !0,
      relation: "after",
      toMiddleware: "retryMiddleware"
    },
    VB4 = rB((A) => ({
      applyToStack: (B) => {
        B.addRelativeTo(alA(A), slA)
      }
    }), "getHttpSigningPlugin"),
    CB4 = rB((A) => {
      if (typeof A === "function") return A;
      let B = Promise.resolve(A);
      return () => B
    }, "normalizeProvider"),
    KB4 = rB(async (A, B, Q, I = (Z) => Z, ...G) => {
      let Z = new A(Q);
      return Z = I(Z) ?? Z, await B.send(Z, ...G)
    }, "makePagedClientRequest");

  function rlA(A, B, Q, I, G) {
    return rB(async function* Z(D, Y, ...W) {
      let J = Y,
        F = D.startingToken ?? J[Q],
        X = !0,
        V;
      while (X) {
        if (J[Q] = F, G) J[G] = J[G] ?? D.pageSize;
        if (D.client instanceof A) V = await KB4(B, D.client, Y, D.withCommand, ...W);
        else throw new Error(`Invalid client, expected instance of ${A.name}`);
        yield V;
        let C = F;
        F = HB4(V, I), X = !!(F && (!D.stopOnSameToken || F !== C))
      }
      return
    }, "paginateOperation")
  }
  rB(rlA, "createPaginator");
  var HB4 = rB((A, B) => {
      let Q = A,
        I = B.split(".");
      for (let G of I) {
        if (!Q || typeof Q !== "object") return;
        Q = Q[G]
      }
      return Q
    }, "get"),
    zB4 = vz();

  function olA(A, B, Q) {
    if (!A.__smithy_context) A.__smithy_context = {
      features: {}
    };
    else if (!A.__smithy_context.features) A.__smithy_context.features = {};
    A.__smithy_context.features[B] = Q
  }
  rB(olA, "setFeature");
  var wB4 = class {
      constructor(A) {
        this.authSchemes = new Map;
        for (let [B, Q] of Object.entries(A))
          if (Q !== void 0) this.authSchemes.set(B, Q)
      }
      static {
        rB(this, "DefaultIdentityProviderConfig")
      }
      getIdentityProvider(A) {
        return this.authSchemes.get(A)
      }
    },
    EB4 = class {
      static {
        rB(this, "HttpApiKeyAuthSigner")
      }
      async sign(A, B, Q) {
        if (!Q) throw new Error("request could not be signed with `apiKey` since the `name` and `in` signer properties are missing");
        if (!Q.name) throw new Error("request could not be signed with `apiKey` since the `name` signer property is missing");
        if (!Q.in) throw new Error("request could not be signed with `apiKey` since the `in` signer property is missing");
        if (!B.apiKey) throw new Error("request could not be signed with `apiKey` since the `apiKey` is not defined");
        let I = m_1.HttpRequest.clone(A);
        if (Q.in === RQ1.HttpApiKeyAuthLocation.QUERY) I.query[Q.name] = B.apiKey;
        else if (Q.in === RQ1.HttpApiKeyAuthLocation.HEADER) I.headers[Q.name] = Q.scheme ? `${Q.scheme} ${B.apiKey}` : B.apiKey;
        else throw new Error("request can only be signed with `apiKey` locations `query` or `header`, but found: `" + Q.in + "`");
        return I
      }
    },
    UB4 = class {
      static {
        rB(this, "HttpBearerAuthSigner")
      }
      async sign(A, B, Q) {
        let I = m_1.HttpRequest.clone(A);
        if (!B.token) throw new Error("request could not be signed with `token` since the `token` is not defined");
        return I.headers.Authorization = `Bearer ${B.token}`, I
      }
    },
    NB4 = class {
      static {
        rB(this, "NoAuthSigner")
      }
      async sign(A, B, Q) {
        return A
      }
    },
    tlA = rB((A) => (B) => AiA(B) && B.expiration.getTime() - Date.now() < A, "createIsIdentityExpiredFunction"),
    elA = 300000,
    $B4 = tlA(elA),
    AiA = rB((A) => A.expiration !== void 0, "doesIdentityRequireRefresh"),
    qB4 = rB((A, B, Q) => {
      if (A === void 0) return;
      let I = typeof A !== "function" ? async () => Promise.resolve(A): A, G, Z, D, Y = !1, W = rB(async (J) => {
        if (!Z) Z = I(J);
        try {
          G = await Z, D = !0, Y = !1
        } finally {
          Z = void 0
        }
        return G
      }, "coalesceProvider");
      if (B === void 0) return async (J) => {
        if (!D || J?.forceRefresh) G = await W(J);
        return G
      };
      return async (J) => {
        if (!D || J?.forceRefresh) G = await W(J);
        if (Y) return G;
        if (!Q(G)) return Y = !0, G;
        if (B(G)) return await W(J), G;
        return G
      }
    }, "memoizeIdentityProvider")
})
// @from(Start 3148893, End 3151676)
XiA = z((yQ8, FiA) => {
  var {
    defineProperty: TQ1,
    getOwnPropertyDescriptor: MB4,
    getOwnPropertyNames: LB4
  } = Object, RB4 = Object.prototype.hasOwnProperty, PQ1 = (A, B) => TQ1(A, "name", {
    value: B,
    configurable: !0
  }), OB4 = (A, B) => {
    for (var Q in B) TQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, TB4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of LB4(B))
        if (!RB4.call(A, G) && G !== Q) TQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = MB4(B, G)) || I.enumerable
        })
    }
    return A
  }, PB4 = (A) => TB4(TQ1({}, "__esModule", {
    value: !0
  }), A), QiA = {};
  OB4(QiA, {
    AlgorithmId: () => DiA,
    EndpointURLScheme: () => ZiA,
    FieldPosition: () => YiA,
    HttpApiKeyAuthLocation: () => GiA,
    HttpAuthLocation: () => IiA,
    IniSectionType: () => WiA,
    RequestHandlerProtocol: () => JiA,
    SMITHY_CONTEXT_KEY: () => kB4,
    getDefaultClientConfiguration: () => jB4,
    resolveDefaultRuntimeConfig: () => yB4
  });
  FiA.exports = PB4(QiA);
  var IiA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(IiA || {}),
    GiA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(GiA || {}),
    ZiA = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(ZiA || {}),
    DiA = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(DiA || {}),
    SB4 = PQ1((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    _B4 = PQ1((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    jB4 = PQ1((A) => {
      return SB4(A)
    }, "getDefaultClientConfiguration"),
    yB4 = PQ1((A) => {
      return _B4(A)
    }, "resolveDefaultRuntimeConfig"),
    YiA = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(YiA || {}),
    kB4 = "__smithy_context",
    WiA = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(WiA || {}),
    JiA = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(JiA || {})
})
// @from(Start 3151682, End 3163891)
LL = z((kQ8, NiA) => {
  var {
    defineProperty: SQ1,
    getOwnPropertyDescriptor: xB4,
    getOwnPropertyNames: fB4
  } = Object, vB4 = Object.prototype.hasOwnProperty, D8 = (A, B) => SQ1(A, "name", {
    value: B,
    configurable: !0
  }), bB4 = (A, B) => {
    for (var Q in B) SQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, gB4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of fB4(B))
        if (!vB4.call(A, G) && G !== Q) SQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = xB4(B, G)) || I.enumerable
        })
    }
    return A
  }, hB4 = (A) => gB4(SQ1({}, "__esModule", {
    value: !0
  }), A), ViA = {};
  bB4(ViA, {
    EndpointCache: () => mB4,
    EndpointError: () => xY,
    customEndpointFunctions: () => u_1,
    isIpAddress: () => CiA,
    isValidHostLabel: () => c_1,
    resolveEndpoint: () => Z34
  });
  NiA.exports = hB4(ViA);
  var mB4 = class {
      constructor({
        size: A,
        params: B
      }) {
        if (this.data = new Map, this.parameters = [], this.capacity = A ?? 50, B) this.parameters = B
      }
      static {
        D8(this, "EndpointCache")
      }
      get(A, B) {
        let Q = this.hash(A);
        if (Q === !1) return B();
        if (!this.data.has(Q)) {
          if (this.data.size > this.capacity + 10) {
            let I = this.data.keys(),
              G = 0;
            while (!0) {
              let {
                value: Z,
                done: D
              } = I.next();
              if (this.data.delete(Z), D || ++G > 10) break
            }
          }
          this.data.set(Q, B())
        }
        return this.data.get(Q)
      }
      size() {
        return this.data.size
      }
      hash(A) {
        let B = "",
          {
            parameters: Q
          } = this;
        if (Q.length === 0) return !1;
        for (let I of Q) {
          let G = String(A[I] ?? "");
          if (G.includes("|;")) return !1;
          B += G + "|;"
        }
        return B
      }
    },
    dB4 = new RegExp("^(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}$"),
    CiA = D8((A) => dB4.test(A) || A.startsWith("[") && A.endsWith("]"), "isIpAddress"),
    uB4 = new RegExp("^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$"),
    c_1 = D8((A, B = !1) => {
      if (!B) return uB4.test(A);
      let Q = A.split(".");
      for (let I of Q)
        if (!c_1(I)) return !1;
      return !0
    }, "isValidHostLabel"),
    u_1 = {},
    ln = "endpoints";

  function YN(A) {
    if (typeof A !== "object" || A == null) return A;
    if ("ref" in A) return `$${YN(A.ref)}`;
    if ("fn" in A) return `${A.fn}(${(A.argv||[]).map(YN).join(", ")})`;
    return JSON.stringify(A, null, 2)
  }
  D8(YN, "toDebugString");
  var xY = class extends Error {
      static {
        D8(this, "EndpointError")
      }
      constructor(A) {
        super(A);
        this.name = "EndpointError"
      }
    },
    pB4 = D8((A, B) => A === B, "booleanEquals"),
    cB4 = D8((A) => {
      let B = A.split("."),
        Q = [];
      for (let I of B) {
        let G = I.indexOf("[");
        if (G !== -1) {
          if (I.indexOf("]") !== I.length - 1) throw new xY(`Path: '${A}' does not end with ']'`);
          let Z = I.slice(G + 1, -1);
          if (Number.isNaN(parseInt(Z))) throw new xY(`Invalid array index: '${Z}' in path: '${A}'`);
          if (G !== 0) Q.push(I.slice(0, G));
          Q.push(Z)
        } else Q.push(I)
      }
      return Q
    }, "getAttrPathList"),
    KiA = D8((A, B) => cB4(B).reduce((Q, I) => {
      if (typeof Q !== "object") throw new xY(`Index '${I}' in '${B}' not found in '${JSON.stringify(A)}'`);
      else if (Array.isArray(Q)) return Q[parseInt(I)];
      return Q[I]
    }, A), "getAttr"),
    lB4 = D8((A) => A != null, "isSet"),
    iB4 = D8((A) => !A, "not"),
    p_1 = XiA(),
    d_1 = {
      [p_1.EndpointURLScheme.HTTP]: 80,
      [p_1.EndpointURLScheme.HTTPS]: 443
    },
    nB4 = D8((A) => {
      let B = (() => {
        try {
          if (A instanceof URL) return A;
          if (typeof A === "object" && "hostname" in A) {
            let {
              hostname: V,
              port: C,
              protocol: K = "",
              path: E = "",
              query: N = {}
            } = A, q = new URL(`${K}//${V}${C?`:${C}`:""}${E}`);
            return q.search = Object.entries(N).map(([O, R]) => `${O}=${R}`).join("&"), q
          }
          return new URL(A)
        } catch (V) {
          return null
        }
      })();
      if (!B) return console.error(`Unable to parse ${JSON.stringify(A)} as a whatwg URL.`), null;
      let Q = B.href,
        {
          host: I,
          hostname: G,
          pathname: Z,
          protocol: D,
          search: Y
        } = B;
      if (Y) return null;
      let W = D.slice(0, -1);
      if (!Object.values(p_1.EndpointURLScheme).includes(W)) return null;
      let J = CiA(G),
        F = Q.includes(`${I}:${d_1[W]}`) || typeof A === "string" && A.includes(`${I}:${d_1[W]}`),
        X = `${I}${F?`:${d_1[W]}`:""}`;
      return {
        scheme: W,
        authority: X,
        path: Z,
        normalizedPath: Z.endsWith("/") ? Z : `${Z}/`,
        isIp: J
      }
    }, "parseURL"),
    aB4 = D8((A, B) => A === B, "stringEquals"),
    sB4 = D8((A, B, Q, I) => {
      if (B >= Q || A.length < Q) return null;
      if (!I) return A.substring(B, Q);
      return A.substring(A.length - Q, A.length - B)
    }, "substring"),
    rB4 = D8((A) => encodeURIComponent(A).replace(/[!*'()]/g, (B) => `%${B.charCodeAt(0).toString(16).toUpperCase()}`), "uriEncode"),
    oB4 = {
      booleanEquals: pB4,
      getAttr: KiA,
      isSet: lB4,
      isValidHostLabel: c_1,
      not: iB4,
      parseURL: nB4,
      stringEquals: aB4,
      substring: sB4,
      uriEncode: rB4
    },
    HiA = D8((A, B) => {
      let Q = [],
        I = {
          ...B.endpointParams,
          ...B.referenceRecord
        },
        G = 0;
      while (G < A.length) {
        let Z = A.indexOf("{", G);
        if (Z === -1) {
          Q.push(A.slice(G));
          break
        }
        Q.push(A.slice(G, Z));
        let D = A.indexOf("}", Z);
        if (D === -1) {
          Q.push(A.slice(Z));
          break
        }
        if (A[Z + 1] === "{" && A[D + 1] === "}") Q.push(A.slice(Z + 1, D)), G = D + 2;
        let Y = A.substring(Z + 1, D);
        if (Y.includes("#")) {
          let [W, J] = Y.split("#");
          Q.push(KiA(I[W], J))
        } else Q.push(I[Y]);
        G = D + 1
      }
      return Q.join("")
    }, "evaluateTemplate"),
    tB4 = D8(({
      ref: A
    }, B) => {
      return {
        ...B.endpointParams,
        ...B.referenceRecord
      } [A]
    }, "getReferenceValue"),
    _Q1 = D8((A, B, Q) => {
      if (typeof A === "string") return HiA(A, Q);
      else if (A.fn) return ziA(A, Q);
      else if (A.ref) return tB4(A, Q);
      throw new xY(`'${B}': ${String(A)} is not a string, function or reference.`)
    }, "evaluateExpression"),
    ziA = D8(({
      fn: A,
      argv: B
    }, Q) => {
      let I = B.map((Z) => ["boolean", "number"].includes(typeof Z) ? Z : _Q1(Z, "arg", Q)),
        G = A.split(".");
      if (G[0] in u_1 && G[1] != null) return u_1[G[0]][G[1]](...I);
      return oB4[A](...I)
    }, "callFunction"),
    eB4 = D8(({
      assign: A,
      ...B
    }, Q) => {
      if (A && A in Q.referenceRecord) throw new xY(`'${A}' is already defined in Reference Record.`);
      let I = ziA(B, Q);
      return Q.logger?.debug?.(`${ln} evaluateCondition: ${YN(B)} = ${YN(I)}`), {
        result: I === "" ? !0 : !!I,
        ...A != null && {
          toAssign: {
            name: A,
            value: I
          }
        }
      }
    }, "evaluateCondition"),
    l_1 = D8((A = [], B) => {
      let Q = {};
      for (let I of A) {
        let {
          result: G,
          toAssign: Z
        } = eB4(I, {
          ...B,
          referenceRecord: {
            ...B.referenceRecord,
            ...Q
          }
        });
        if (!G) return {
          result: G
        };
        if (Z) Q[Z.name] = Z.value, B.logger?.debug?.(`${ln} assign: ${Z.name} := ${YN(Z.value)}`)
      }
      return {
        result: !0,
        referenceRecord: Q
      }
    }, "evaluateConditions"),
    A34 = D8((A, B) => Object.entries(A).reduce((Q, [I, G]) => ({
      ...Q,
      [I]: G.map((Z) => {
        let D = _Q1(Z, "Header value entry", B);
        if (typeof D !== "string") throw new xY(`Header '${I}' value '${D}' is not a string`);
        return D
      })
    }), {}), "getEndpointHeaders"),
    wiA = D8((A, B) => {
      if (Array.isArray(A)) return A.map((Q) => wiA(Q, B));
      switch (typeof A) {
        case "string":
          return HiA(A, B);
        case "object":
          if (A === null) throw new xY(`Unexpected endpoint property: ${A}`);
          return EiA(A, B);
        case "boolean":
          return A;
        default:
          throw new xY(`Unexpected endpoint property type: ${typeof A}`)
      }
    }, "getEndpointProperty"),
    EiA = D8((A, B) => Object.entries(A).reduce((Q, [I, G]) => ({
      ...Q,
      [I]: wiA(G, B)
    }), {}), "getEndpointProperties"),
    B34 = D8((A, B) => {
      let Q = _Q1(A, "Endpoint URL", B);
      if (typeof Q === "string") try {
        return new URL(Q)
      } catch (I) {
        throw console.error(`Failed to construct URL with ${Q}`, I), I
      }
      throw new xY(`Endpoint URL must be a string, got ${typeof Q}`)
    }, "getEndpointUrl"),
    Q34 = D8((A, B) => {
      let {
        conditions: Q,
        endpoint: I
      } = A, {
        result: G,
        referenceRecord: Z
      } = l_1(Q, B);
      if (!G) return;
      let D = {
          ...B,
          referenceRecord: {
            ...B.referenceRecord,
            ...Z
          }
        },
        {
          url: Y,
          properties: W,
          headers: J
        } = I;
      return B.logger?.debug?.(`${ln} Resolving endpoint from template: ${YN(I)}`), {
        ...J != null && {
          headers: A34(J, D)
        },
        ...W != null && {
          properties: EiA(W, D)
        },
        url: B34(Y, D)
      }
    }, "evaluateEndpointRule"),
    I34 = D8((A, B) => {
      let {
        conditions: Q,
        error: I
      } = A, {
        result: G,
        referenceRecord: Z
      } = l_1(Q, B);
      if (!G) return;
      throw new xY(_Q1(I, "Error", {
        ...B,
        referenceRecord: {
          ...B.referenceRecord,
          ...Z
        }
      }))
    }, "evaluateErrorRule"),
    G34 = D8((A, B) => {
      let {
        conditions: Q,
        rules: I
      } = A, {
        result: G,
        referenceRecord: Z
      } = l_1(Q, B);
      if (!G) return;
      return UiA(I, {
        ...B,
        referenceRecord: {
          ...B.referenceRecord,
          ...Z
        }
      })
    }, "evaluateTreeRule"),
    UiA = D8((A, B) => {
      for (let Q of A)
        if (Q.type === "endpoint") {
          let I = Q34(Q, B);
          if (I) return I
        } else if (Q.type === "error") I34(Q, B);
      else if (Q.type === "tree") {
        let I = G34(Q, B);
        if (I) return I
      } else throw new xY(`Unknown endpoint rule: ${Q}`);
      throw new xY("Rules evaluation failed")
    }, "evaluateRules"),
    Z34 = D8((A, B) => {
      let {
        endpointParams: Q,
        logger: I
      } = B, {
        parameters: G,
        rules: Z
      } = A;
      B.logger?.debug?.(`${ln} Initial EndpointParams: ${YN(Q)}`);
      let D = Object.entries(G).filter(([, J]) => J.default != null).map(([J, F]) => [J, F.default]);
      if (D.length > 0)
        for (let [J, F] of D) Q[J] = Q[J] ?? F;
      let Y = Object.entries(G).filter(([, J]) => J.required).map(([J]) => J);
      for (let J of Y)
        if (Q[J] == null) throw new xY(`Missing required parameter: '${J}'`);
      let W = UiA(Z, {
        endpointParams: Q,
        logger: I,
        referenceRecord: {}
      });
      return B.logger?.debug?.(`${ln} Resolved endpoint: ${YN(W)}`), W
    }, "resolveEndpoint")
})
// @from(Start 3163897, End 3175254)
RL = z((vQ8, _iA) => {
  var {
    defineProperty: jQ1,
    getOwnPropertyDescriptor: D34,
    getOwnPropertyNames: Y34
  } = Object, W34 = Object.prototype.hasOwnProperty, Fb = (A, B) => jQ1(A, "name", {
    value: B,
    configurable: !0
  }), J34 = (A, B) => {
    for (var Q in B) jQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, F34 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of Y34(B))
        if (!W34.call(A, G) && G !== Q) jQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = D34(B, G)) || I.enumerable
        })
    }
    return A
  }, X34 = (A) => F34(jQ1({}, "__esModule", {
    value: !0
  }), A), qiA = {};
  J34(qiA, {
    ConditionObject: () => QB.ConditionObject,
    DeprecatedObject: () => QB.DeprecatedObject,
    EndpointError: () => QB.EndpointError,
    EndpointObject: () => QB.EndpointObject,
    EndpointObjectHeaders: () => QB.EndpointObjectHeaders,
    EndpointObjectProperties: () => QB.EndpointObjectProperties,
    EndpointParams: () => QB.EndpointParams,
    EndpointResolverOptions: () => QB.EndpointResolverOptions,
    EndpointRuleObject: () => QB.EndpointRuleObject,
    ErrorRuleObject: () => QB.ErrorRuleObject,
    EvaluateOptions: () => QB.EvaluateOptions,
    Expression: () => QB.Expression,
    FunctionArgv: () => QB.FunctionArgv,
    FunctionObject: () => QB.FunctionObject,
    FunctionReturn: () => QB.FunctionReturn,
    ParameterObject: () => QB.ParameterObject,
    ReferenceObject: () => QB.ReferenceObject,
    ReferenceRecord: () => QB.ReferenceRecord,
    RuleSetObject: () => QB.RuleSetObject,
    RuleSetRules: () => QB.RuleSetRules,
    TreeRuleObject: () => QB.TreeRuleObject,
    awsEndpointFunctions: () => SiA,
    getUserAgentPrefix: () => H34,
    isIpAddress: () => QB.isIpAddress,
    partition: () => TiA,
    resolveEndpoint: () => QB.resolveEndpoint,
    setPartitionInfo: () => PiA,
    useDefaultPartitionInfo: () => K34
  });
  _iA.exports = X34(qiA);
  var QB = LL(),
    MiA = Fb((A, B = !1) => {
      if (B) {
        for (let Q of A.split("."))
          if (!MiA(Q)) return !1;
        return !0
      }
      if (!QB.isValidHostLabel(A)) return !1;
      if (A.length < 3 || A.length > 63) return !1;
      if (A !== A.toLowerCase()) return !1;
      if (QB.isIpAddress(A)) return !1;
      return !0
    }, "isVirtualHostableS3Bucket"),
    $iA = ":",
    V34 = "/",
    C34 = Fb((A) => {
      let B = A.split($iA);
      if (B.length < 6) return null;
      let [Q, I, G, Z, D, ...Y] = B;
      if (Q !== "arn" || I === "" || G === "" || Y.join($iA) === "") return null;
      let W = Y.map((J) => J.split(V34)).flat();
      return {
        partition: I,
        service: G,
        region: Z,
        accountId: D,
        resourceId: W
      }
    }, "parseArn"),
    LiA = {
      partitions: [{
        id: "aws",
        outputs: {
          dnsSuffix: "amazonaws.com",
          dualStackDnsSuffix: "api.aws",
          implicitGlobalRegion: "us-east-1",
          name: "aws",
          supportsDualStack: !0,
          supportsFIPS: !0
        },
        regionRegex: "^(us|eu|ap|sa|ca|me|af|il|mx)\\-\\w+\\-\\d+$",
        regions: {
          "af-south-1": {
            description: "Africa (Cape Town)"
          },
          "ap-east-1": {
            description: "Asia Pacific (Hong Kong)"
          },
          "ap-northeast-1": {
            description: "Asia Pacific (Tokyo)"
          },
          "ap-northeast-2": {
            description: "Asia Pacific (Seoul)"
          },
          "ap-northeast-3": {
            description: "Asia Pacific (Osaka)"
          },
          "ap-south-1": {
            description: "Asia Pacific (Mumbai)"
          },
          "ap-south-2": {
            description: "Asia Pacific (Hyderabad)"
          },
          "ap-southeast-1": {
            description: "Asia Pacific (Singapore)"
          },
          "ap-southeast-2": {
            description: "Asia Pacific (Sydney)"
          },
          "ap-southeast-3": {
            description: "Asia Pacific (Jakarta)"
          },
          "ap-southeast-4": {
            description: "Asia Pacific (Melbourne)"
          },
          "ap-southeast-5": {
            description: "Asia Pacific (Malaysia)"
          },
          "ap-southeast-7": {
            description: "Asia Pacific (Thailand)"
          },
          "aws-global": {
            description: "AWS Standard global region"
          },
          "ca-central-1": {
            description: "Canada (Central)"
          },
          "ca-west-1": {
            description: "Canada West (Calgary)"
          },
          "eu-central-1": {
            description: "Europe (Frankfurt)"
          },
          "eu-central-2": {
            description: "Europe (Zurich)"
          },
          "eu-north-1": {
            description: "Europe (Stockholm)"
          },
          "eu-south-1": {
            description: "Europe (Milan)"
          },
          "eu-south-2": {
            description: "Europe (Spain)"
          },
          "eu-west-1": {
            description: "Europe (Ireland)"
          },
          "eu-west-2": {
            description: "Europe (London)"
          },
          "eu-west-3": {
            description: "Europe (Paris)"
          },
          "il-central-1": {
            description: "Israel (Tel Aviv)"
          },
          "me-central-1": {
            description: "Middle East (UAE)"
          },
          "me-south-1": {
            description: "Middle East (Bahrain)"
          },
          "mx-central-1": {
            description: "Mexico (Central)"
          },
          "sa-east-1": {
            description: "South America (Sao Paulo)"
          },
          "us-east-1": {
            description: "US East (N. Virginia)"
          },
          "us-east-2": {
            description: "US East (Ohio)"
          },
          "us-west-1": {
            description: "US West (N. California)"
          },
          "us-west-2": {
            description: "US West (Oregon)"
          }
        }
      }, {
        id: "aws-cn",
        outputs: {
          dnsSuffix: "amazonaws.com.cn",
          dualStackDnsSuffix: "api.amazonwebservices.com.cn",
          implicitGlobalRegion: "cn-northwest-1",
          name: "aws-cn",
          supportsDualStack: !0,
          supportsFIPS: !0
        },
        regionRegex: "^cn\\-\\w+\\-\\d+$",
        regions: {
          "aws-cn-global": {
            description: "AWS China global region"
          },
          "cn-north-1": {
            description: "China (Beijing)"
          },
          "cn-northwest-1": {
            description: "China (Ningxia)"
          }
        }
      }, {
        id: "aws-us-gov",
        outputs: {
          dnsSuffix: "amazonaws.com",
          dualStackDnsSuffix: "api.aws",
          implicitGlobalRegion: "us-gov-west-1",
          name: "aws-us-gov",
          supportsDualStack: !0,
          supportsFIPS: !0
        },
        regionRegex: "^us\\-gov\\-\\w+\\-\\d+$",
        regions: {
          "aws-us-gov-global": {
            description: "AWS GovCloud (US) global region"
          },
          "us-gov-east-1": {
            description: "AWS GovCloud (US-East)"
          },
          "us-gov-west-1": {
            description: "AWS GovCloud (US-West)"
          }
        }
      }, {
        id: "aws-iso",
        outputs: {
          dnsSuffix: "c2s.ic.gov",
          dualStackDnsSuffix: "c2s.ic.gov",
          implicitGlobalRegion: "us-iso-east-1",
          name: "aws-iso",
          supportsDualStack: !1,
          supportsFIPS: !0
        },
        regionRegex: "^us\\-iso\\-\\w+\\-\\d+$",
        regions: {
          "aws-iso-global": {
            description: "AWS ISO (US) global region"
          },
          "us-iso-east-1": {
            description: "US ISO East"
          },
          "us-iso-west-1": {
            description: "US ISO WEST"
          }
        }
      }, {
        id: "aws-iso-b",
        outputs: {
          dnsSuffix: "sc2s.sgov.gov",
          dualStackDnsSuffix: "sc2s.sgov.gov",
          implicitGlobalRegion: "us-isob-east-1",
          name: "aws-iso-b",
          supportsDualStack: !1,
          supportsFIPS: !0
        },
        regionRegex: "^us\\-isob\\-\\w+\\-\\d+$",
        regions: {
          "aws-iso-b-global": {
            description: "AWS ISOB (US) global region"
          },
          "us-isob-east-1": {
            description: "US ISOB East (Ohio)"
          }
        }
      }, {
        id: "aws-iso-e",
        outputs: {
          dnsSuffix: "cloud.adc-e.uk",
          dualStackDnsSuffix: "cloud.adc-e.uk",
          implicitGlobalRegion: "eu-isoe-west-1",
          name: "aws-iso-e",
          supportsDualStack: !1,
          supportsFIPS: !0
        },
        regionRegex: "^eu\\-isoe\\-\\w+\\-\\d+$",
        regions: {
          "aws-iso-e-global": {
            description: "AWS ISOE (Europe) global region"
          },
          "eu-isoe-west-1": {
            description: "EU ISOE West"
          }
        }
      }, {
        id: "aws-iso-f",
        outputs: {
          dnsSuffix: "csp.hci.ic.gov",
          dualStackDnsSuffix: "csp.hci.ic.gov",
          implicitGlobalRegion: "us-isof-south-1",
          name: "aws-iso-f",
          supportsDualStack: !1,
          supportsFIPS: !0
        },
        regionRegex: "^us\\-isof\\-\\w+\\-\\d+$",
        regions: {
          "aws-iso-f-global": {
            description: "AWS ISOF global region"
          },
          "us-isof-east-1": {
            description: "US ISOF EAST"
          },
          "us-isof-south-1": {
            description: "US ISOF SOUTH"
          }
        }
      }, {
        id: "aws-eusc",
        outputs: {
          dnsSuffix: "amazonaws.eu",
          dualStackDnsSuffix: "amazonaws.eu",
          implicitGlobalRegion: "eusc-de-east-1",
          name: "aws-eusc",
          supportsDualStack: !1,
          supportsFIPS: !0
        },
        regionRegex: "^eusc\\-(de)\\-\\w+\\-\\d+$",
        regions: {
          "eusc-de-east-1": {
            description: "EU (Germany)"
          }
        }
      }],
      version: "1.1"
    },
    RiA = LiA,
    OiA = "",
    TiA = Fb((A) => {
      let {
        partitions: B
      } = RiA;
      for (let I of B) {
        let {
          regions: G,
          outputs: Z
        } = I;
        for (let [D, Y] of Object.entries(G))
          if (D === A) return {
            ...Z,
            ...Y
          }
      }
      for (let I of B) {
        let {
          regionRegex: G,
          outputs: Z
        } = I;
        if (new RegExp(G).test(A)) return {
          ...Z
        }
      }
      let Q = B.find((I) => I.id === "aws");
      if (!Q) throw new Error("Provided region was not found in the partition array or regex, and default partition with id 'aws' doesn't exist.");
      return {
        ...Q.outputs
      }
    }, "partition"),
    PiA = Fb((A, B = "") => {
      RiA = A, OiA = B
    }, "setPartitionInfo"),
    K34 = Fb(() => {
      PiA(LiA, "")
    }, "useDefaultPartitionInfo"),
    H34 = Fb(() => OiA, "getUserAgentPrefix"),
    SiA = {
      isVirtualHostableS3Bucket: MiA,
      parseArn: C34,
      partition: TiA
    };
  QB.customEndpointFunctions.aws = SiA
})
// @from(Start 3175260, End 3178043)
miA = z((bQ8, hiA) => {
  var {
    defineProperty: yQ1,
    getOwnPropertyDescriptor: z34,
    getOwnPropertyNames: w34
  } = Object, E34 = Object.prototype.hasOwnProperty, kQ1 = (A, B) => yQ1(A, "name", {
    value: B,
    configurable: !0
  }), U34 = (A, B) => {
    for (var Q in B) yQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, N34 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of w34(B))
        if (!E34.call(A, G) && G !== Q) yQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = z34(B, G)) || I.enumerable
        })
    }
    return A
  }, $34 = (A) => N34(yQ1({}, "__esModule", {
    value: !0
  }), A), jiA = {};
  U34(jiA, {
    AlgorithmId: () => fiA,
    EndpointURLScheme: () => xiA,
    FieldPosition: () => viA,
    HttpApiKeyAuthLocation: () => kiA,
    HttpAuthLocation: () => yiA,
    IniSectionType: () => biA,
    RequestHandlerProtocol: () => giA,
    SMITHY_CONTEXT_KEY: () => O34,
    getDefaultClientConfiguration: () => L34,
    resolveDefaultRuntimeConfig: () => R34
  });
  hiA.exports = $34(jiA);
  var yiA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(yiA || {}),
    kiA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(kiA || {}),
    xiA = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(xiA || {}),
    fiA = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(fiA || {}),
    q34 = kQ1((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    M34 = kQ1((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    L34 = kQ1((A) => {
      return q34(A)
    }, "getDefaultClientConfiguration"),
    R34 = kQ1((A) => {
      return M34(A)
    }, "resolveDefaultRuntimeConfig"),
    viA = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(viA || {}),
    O34 = "__smithy_context",
    biA = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(biA || {}),
    giA = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(giA || {})
})
// @from(Start 3178049, End 3182556)
iiA = z((gQ8, liA) => {
  var {
    defineProperty: xQ1,
    getOwnPropertyDescriptor: T34,
    getOwnPropertyNames: P34
  } = Object, S34 = Object.prototype.hasOwnProperty, OL = (A, B) => xQ1(A, "name", {
    value: B,
    configurable: !0
  }), _34 = (A, B) => {
    for (var Q in B) xQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, j34 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of P34(B))
        if (!S34.call(A, G) && G !== Q) xQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = T34(B, G)) || I.enumerable
        })
    }
    return A
  }, y34 = (A) => j34(xQ1({}, "__esModule", {
    value: !0
  }), A), diA = {};
  _34(diA, {
    Field: () => f34,
    Fields: () => v34,
    HttpRequest: () => b34,
    HttpResponse: () => g34,
    IHttpRequest: () => uiA.HttpRequest,
    getHttpHandlerExtensionConfiguration: () => k34,
    isValidHostname: () => ciA,
    resolveHttpHandlerRuntimeConfig: () => x34
  });
  liA.exports = y34(diA);
  var k34 = OL((A) => {
      return {
        setHttpHandler(B) {
          A.httpHandler = B
        },
        httpHandler() {
          return A.httpHandler
        },
        updateHttpClientConfig(B, Q) {
          A.httpHandler?.updateHttpClientConfig(B, Q)
        },
        httpHandlerConfigs() {
          return A.httpHandler.httpHandlerConfigs()
        }
      }
    }, "getHttpHandlerExtensionConfiguration"),
    x34 = OL((A) => {
      return {
        httpHandler: A.httpHandler()
      }
    }, "resolveHttpHandlerRuntimeConfig"),
    uiA = miA(),
    f34 = class {
      static {
        OL(this, "Field")
      }
      constructor({
        name: A,
        kind: B = uiA.FieldPosition.HEADER,
        values: Q = []
      }) {
        this.name = A, this.kind = B, this.values = Q
      }
      add(A) {
        this.values.push(A)
      }
      set(A) {
        this.values = A
      }
      remove(A) {
        this.values = this.values.filter((B) => B !== A)
      }
      toString() {
        return this.values.map((A) => A.includes(",") || A.includes(" ") ? `"${A}"` : A).join(", ")
      }
      get() {
        return this.values
      }
    },
    v34 = class {
      constructor({
        fields: A = [],
        encoding: B = "utf-8"
      }) {
        this.entries = {}, A.forEach(this.setField.bind(this)), this.encoding = B
      }
      static {
        OL(this, "Fields")
      }
      setField(A) {
        this.entries[A.name.toLowerCase()] = A
      }
      getField(A) {
        return this.entries[A.toLowerCase()]
      }
      removeField(A) {
        delete this.entries[A.toLowerCase()]
      }
      getByType(A) {
        return Object.values(this.entries).filter((B) => B.kind === A)
      }
    },
    b34 = class A {
      static {
        OL(this, "HttpRequest")
      }
      constructor(B) {
        this.method = B.method || "GET", this.hostname = B.hostname || "localhost", this.port = B.port, this.query = B.query || {}, this.headers = B.headers || {}, this.body = B.body, this.protocol = B.protocol ? B.protocol.slice(-1) !== ":" ? `${B.protocol}:` : B.protocol : "https:", this.path = B.path ? B.path.charAt(0) !== "/" ? `/${B.path}` : B.path : "/", this.username = B.username, this.password = B.password, this.fragment = B.fragment
      }
      static clone(B) {
        let Q = new A({
          ...B,
          headers: {
            ...B.headers
          }
        });
        if (Q.query) Q.query = piA(Q.query);
        return Q
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return "method" in Q && "protocol" in Q && "hostname" in Q && "path" in Q && typeof Q.query === "object" && typeof Q.headers === "object"
      }
      clone() {
        return A.clone(this)
      }
    };

  function piA(A) {
    return Object.keys(A).reduce((B, Q) => {
      let I = A[Q];
      return {
        ...B,
        [Q]: Array.isArray(I) ? [...I] : I
      }
    }, {})
  }
  OL(piA, "cloneQuery");
  var g34 = class {
    static {
      OL(this, "HttpResponse")
    }
    constructor(A) {
      this.statusCode = A.statusCode, this.reason = A.reason, this.headers = A.headers || {}, this.body = A.body
    }
    static isInstance(A) {
      if (!A) return !1;
      let B = A;
      return typeof B.statusCode === "number" && typeof B.headers === "object"
    }
  };

  function ciA(A) {
    return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(A)
  }
  OL(ciA, "isValidHostname")
})
// @from(Start 3182562, End 3199882)
$nA = z((uQ8, bQ1) => {
  var niA, aiA, siA, riA, oiA, tiA, eiA, AnA, BnA, QnA, InA, GnA, ZnA, fQ1, i_1, DnA, YnA, WnA, Xb, JnA, FnA, XnA, VnA, CnA, KnA, HnA, znA, wnA, vQ1, EnA, UnA, NnA;
  (function(A) {
    var B = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
    if (typeof define === "function" && define.amd) define("tslib", ["exports"], function(I) {
      A(Q(B, Q(I)))
    });
    else if (typeof bQ1 === "object" && typeof uQ8 === "object") A(Q(B, Q(uQ8)));
    else A(Q(B));

    function Q(I, G) {
      if (I !== B)
        if (typeof Object.create === "function") Object.defineProperty(I, "__esModule", {
          value: !0
        });
        else I.__esModule = !0;
      return function(Z, D) {
        return I[Z] = G ? G(Z, D) : D
      }
    }
  })(function(A) {
    var B = Object.setPrototypeOf || {
      __proto__: []
    }
    instanceof Array && function(Z, D) {
      Z.__proto__ = D
    } || function(Z, D) {
      for (var Y in D)
        if (Object.prototype.hasOwnProperty.call(D, Y)) Z[Y] = D[Y]
    };
    niA = function(Z, D) {
      if (typeof D !== "function" && D !== null) throw new TypeError("Class extends value " + String(D) + " is not a constructor or null");
      B(Z, D);

      function Y() {
        this.constructor = Z
      }
      Z.prototype = D === null ? Object.create(D) : (Y.prototype = D.prototype, new Y)
    }, aiA = Object.assign || function(Z) {
      for (var D, Y = 1, W = arguments.length; Y < W; Y++) {
        D = arguments[Y];
        for (var J in D)
          if (Object.prototype.hasOwnProperty.call(D, J)) Z[J] = D[J]
      }
      return Z
    }, siA = function(Z, D) {
      var Y = {};
      for (var W in Z)
        if (Object.prototype.hasOwnProperty.call(Z, W) && D.indexOf(W) < 0) Y[W] = Z[W];
      if (Z != null && typeof Object.getOwnPropertySymbols === "function") {
        for (var J = 0, W = Object.getOwnPropertySymbols(Z); J < W.length; J++)
          if (D.indexOf(W[J]) < 0 && Object.prototype.propertyIsEnumerable.call(Z, W[J])) Y[W[J]] = Z[W[J]]
      }
      return Y
    }, riA = function(Z, D, Y, W) {
      var J = arguments.length,
        F = J < 3 ? D : W === null ? W = Object.getOwnPropertyDescriptor(D, Y) : W,
        X;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") F = Reflect.decorate(Z, D, Y, W);
      else
        for (var V = Z.length - 1; V >= 0; V--)
          if (X = Z[V]) F = (J < 3 ? X(F) : J > 3 ? X(D, Y, F) : X(D, Y)) || F;
      return J > 3 && F && Object.defineProperty(D, Y, F), F
    }, oiA = function(Z, D) {
      return function(Y, W) {
        D(Y, W, Z)
      }
    }, tiA = function(Z, D, Y, W, J, F) {
      function X(_) {
        if (_ !== void 0 && typeof _ !== "function") throw new TypeError("Function expected");
        return _
      }
      var V = W.kind,
        C = V === "getter" ? "get" : V === "setter" ? "set" : "value",
        K = !D && Z ? W.static ? Z : Z.prototype : null,
        E = D || (K ? Object.getOwnPropertyDescriptor(K, W.name) : {}),
        N, q = !1;
      for (var O = Y.length - 1; O >= 0; O--) {
        var R = {};
        for (var T in W) R[T] = T === "access" ? {} : W[T];
        for (var T in W.access) R.access[T] = W.access[T];
        R.addInitializer = function(_) {
          if (q) throw new TypeError("Cannot add initializers after decoration has completed");
          F.push(X(_ || null))
        };
        var L = Y[O](V === "accessor" ? {
          get: E.get,
          set: E.set
        } : E[C], R);
        if (V === "accessor") {
          if (L === void 0) continue;
          if (L === null || typeof L !== "object") throw new TypeError("Object expected");
          if (N = X(L.get)) E.get = N;
          if (N = X(L.set)) E.set = N;
          if (N = X(L.init)) J.unshift(N)
        } else if (N = X(L))
          if (V === "field") J.unshift(N);
          else E[C] = N
      }
      if (K) Object.defineProperty(K, W.name, E);
      q = !0
    }, eiA = function(Z, D, Y) {
      var W = arguments.length > 2;
      for (var J = 0; J < D.length; J++) Y = W ? D[J].call(Z, Y) : D[J].call(Z);
      return W ? Y : void 0
    }, AnA = function(Z) {
      return typeof Z === "symbol" ? Z : "".concat(Z)
    }, BnA = function(Z, D, Y) {
      if (typeof D === "symbol") D = D.description ? "[".concat(D.description, "]") : "";
      return Object.defineProperty(Z, "name", {
        configurable: !0,
        value: Y ? "".concat(Y, " ", D) : D
      })
    }, QnA = function(Z, D) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(Z, D)
    }, InA = function(Z, D, Y, W) {
      function J(F) {
        return F instanceof Y ? F : new Y(function(X) {
          X(F)
        })
      }
      return new(Y || (Y = Promise))(function(F, X) {
        function V(E) {
          try {
            K(W.next(E))
          } catch (N) {
            X(N)
          }
        }

        function C(E) {
          try {
            K(W.throw(E))
          } catch (N) {
            X(N)
          }
        }

        function K(E) {
          E.done ? F(E.value) : J(E.value).then(V, C)
        }
        K((W = W.apply(Z, D || [])).next())
      })
    }, GnA = function(Z, D) {
      var Y = {
          label: 0,
          sent: function() {
            if (F[0] & 1) throw F[1];
            return F[1]
          },
          trys: [],
          ops: []
        },
        W, J, F, X = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
      return X.next = V(0), X.throw = V(1), X.return = V(2), typeof Symbol === "function" && (X[Symbol.iterator] = function() {
        return this
      }), X;

      function V(K) {
        return function(E) {
          return C([K, E])
        }
      }

      function C(K) {
        if (W) throw new TypeError("Generator is already executing.");
        while (X && (X = 0, K[0] && (Y = 0)), Y) try {
          if (W = 1, J && (F = K[0] & 2 ? J.return : K[0] ? J.throw || ((F = J.return) && F.call(J), 0) : J.next) && !(F = F.call(J, K[1])).done) return F;
          if (J = 0, F) K = [K[0] & 2, F.value];
          switch (K[0]) {
            case 0:
            case 1:
              F = K;
              break;
            case 4:
              return Y.label++, {
                value: K[1],
                done: !1
              };
            case 5:
              Y.label++, J = K[1], K = [0];
              continue;
            case 7:
              K = Y.ops.pop(), Y.trys.pop();
              continue;
            default:
              if ((F = Y.trys, !(F = F.length > 0 && F[F.length - 1])) && (K[0] === 6 || K[0] === 2)) {
                Y = 0;
                continue
              }
              if (K[0] === 3 && (!F || K[1] > F[0] && K[1] < F[3])) {
                Y.label = K[1];
                break
              }
              if (K[0] === 6 && Y.label < F[1]) {
                Y.label = F[1], F = K;
                break
              }
              if (F && Y.label < F[2]) {
                Y.label = F[2], Y.ops.push(K);
                break
              }
              if (F[2]) Y.ops.pop();
              Y.trys.pop();
              continue
          }
          K = D.call(Z, Y)
        } catch (E) {
          K = [6, E], J = 0
        } finally {
          W = F = 0
        }
        if (K[0] & 5) throw K[1];
        return {
          value: K[0] ? K[1] : void 0,
          done: !0
        }
      }
    }, ZnA = function(Z, D) {
      for (var Y in Z)
        if (Y !== "default" && !Object.prototype.hasOwnProperty.call(D, Y)) vQ1(D, Z, Y)
    }, vQ1 = Object.create ? function(Z, D, Y, W) {
      if (W === void 0) W = Y;
      var J = Object.getOwnPropertyDescriptor(D, Y);
      if (!J || ("get" in J ? !D.__esModule : J.writable || J.configurable)) J = {
        enumerable: !0,
        get: function() {
          return D[Y]
        }
      };
      Object.defineProperty(Z, W, J)
    } : function(Z, D, Y, W) {
      if (W === void 0) W = Y;
      Z[W] = D[Y]
    }, fQ1 = function(Z) {
      var D = typeof Symbol === "function" && Symbol.iterator,
        Y = D && Z[D],
        W = 0;
      if (Y) return Y.call(Z);
      if (Z && typeof Z.length === "number") return {
        next: function() {
          if (Z && W >= Z.length) Z = void 0;
          return {
            value: Z && Z[W++],
            done: !Z
          }
        }
      };
      throw new TypeError(D ? "Object is not iterable." : "Symbol.iterator is not defined.")
    }, i_1 = function(Z, D) {
      var Y = typeof Symbol === "function" && Z[Symbol.iterator];
      if (!Y) return Z;
      var W = Y.call(Z),
        J, F = [],
        X;
      try {
        while ((D === void 0 || D-- > 0) && !(J = W.next()).done) F.push(J.value)
      } catch (V) {
        X = {
          error: V
        }
      } finally {
        try {
          if (J && !J.done && (Y = W.return)) Y.call(W)
        } finally {
          if (X) throw X.error
        }
      }
      return F
    }, DnA = function() {
      for (var Z = [], D = 0; D < arguments.length; D++) Z = Z.concat(i_1(arguments[D]));
      return Z
    }, YnA = function() {
      for (var Z = 0, D = 0, Y = arguments.length; D < Y; D++) Z += arguments[D].length;
      for (var W = Array(Z), J = 0, D = 0; D < Y; D++)
        for (var F = arguments[D], X = 0, V = F.length; X < V; X++, J++) W[J] = F[X];
      return W
    }, WnA = function(Z, D, Y) {
      if (Y || arguments.length === 2) {
        for (var W = 0, J = D.length, F; W < J; W++)
          if (F || !(W in D)) {
            if (!F) F = Array.prototype.slice.call(D, 0, W);
            F[W] = D[W]
          }
      }
      return Z.concat(F || Array.prototype.slice.call(D))
    }, Xb = function(Z) {
      return this instanceof Xb ? (this.v = Z, this) : new Xb(Z)
    }, JnA = function(Z, D, Y) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var W = Y.apply(Z, D || []),
        J, F = [];
      return J = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), V("next"), V("throw"), V("return", X), J[Symbol.asyncIterator] = function() {
        return this
      }, J;

      function X(O) {
        return function(R) {
          return Promise.resolve(R).then(O, N)
        }
      }

      function V(O, R) {
        if (W[O]) {
          if (J[O] = function(T) {
              return new Promise(function(L, _) {
                F.push([O, T, L, _]) > 1 || C(O, T)
              })
            }, R) J[O] = R(J[O])
        }
      }

      function C(O, R) {
        try {
          K(W[O](R))
        } catch (T) {
          q(F[0][3], T)
        }
      }

      function K(O) {
        O.value instanceof Xb ? Promise.resolve(O.value.v).then(E, N) : q(F[0][2], O)
      }

      function E(O) {
        C("next", O)
      }

      function N(O) {
        C("throw", O)
      }

      function q(O, R) {
        if (O(R), F.shift(), F.length) C(F[0][0], F[0][1])
      }
    }, FnA = function(Z) {
      var D, Y;
      return D = {}, W("next"), W("throw", function(J) {
        throw J
      }), W("return"), D[Symbol.iterator] = function() {
        return this
      }, D;

      function W(J, F) {
        D[J] = Z[J] ? function(X) {
          return (Y = !Y) ? {
            value: Xb(Z[J](X)),
            done: !1
          } : F ? F(X) : X
        } : F
      }
    }, XnA = function(Z) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var D = Z[Symbol.asyncIterator],
        Y;
      return D ? D.call(Z) : (Z = typeof fQ1 === "function" ? fQ1(Z) : Z[Symbol.iterator](), Y = {}, W("next"), W("throw"), W("return"), Y[Symbol.asyncIterator] = function() {
        return this
      }, Y);

      function W(F) {
        Y[F] = Z[F] && function(X) {
          return new Promise(function(V, C) {
            X = Z[F](X), J(V, C, X.done, X.value)
          })
        }
      }

      function J(F, X, V, C) {
        Promise.resolve(C).then(function(K) {
          F({
            value: K,
            done: V
          })
        }, X)
      }
    }, VnA = function(Z, D) {
      if (Object.defineProperty) Object.defineProperty(Z, "raw", {
        value: D
      });
      else Z.raw = D;
      return Z
    };
    var Q = Object.create ? function(Z, D) {
        Object.defineProperty(Z, "default", {
          enumerable: !0,
          value: D
        })
      } : function(Z, D) {
        Z.default = D
      },
      I = function(Z) {
        return I = Object.getOwnPropertyNames || function(D) {
          var Y = [];
          for (var W in D)
            if (Object.prototype.hasOwnProperty.call(D, W)) Y[Y.length] = W;
          return Y
        }, I(Z)
      };
    CnA = function(Z) {
      if (Z && Z.__esModule) return Z;
      var D = {};
      if (Z != null) {
        for (var Y = I(Z), W = 0; W < Y.length; W++)
          if (Y[W] !== "default") vQ1(D, Z, Y[W])
      }
      return Q(D, Z), D
    }, KnA = function(Z) {
      return Z && Z.__esModule ? Z : {
        default: Z
      }
    }, HnA = function(Z, D, Y, W) {
      if (Y === "a" && !W) throw new TypeError("Private accessor was defined without a getter");
      if (typeof D === "function" ? Z !== D || !W : !D.has(Z)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
      return Y === "m" ? W : Y === "a" ? W.call(Z) : W ? W.value : D.get(Z)
    }, znA = function(Z, D, Y, W, J) {
      if (W === "m") throw new TypeError("Private method is not writable");
      if (W === "a" && !J) throw new TypeError("Private accessor was defined without a setter");
      if (typeof D === "function" ? Z !== D || !J : !D.has(Z)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
      return W === "a" ? J.call(Z, Y) : J ? J.value = Y : D.set(Z, Y), Y
    }, wnA = function(Z, D) {
      if (D === null || typeof D !== "object" && typeof D !== "function") throw new TypeError("Cannot use 'in' operator on non-object");
      return typeof Z === "function" ? D === Z : Z.has(D)
    }, EnA = function(Z, D, Y) {
      if (D !== null && D !== void 0) {
        if (typeof D !== "object" && typeof D !== "function") throw new TypeError("Object expected.");
        var W, J;
        if (Y) {
          if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
          W = D[Symbol.asyncDispose]
        }
        if (W === void 0) {
          if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
          if (W = D[Symbol.dispose], Y) J = W
        }
        if (typeof W !== "function") throw new TypeError("Object not disposable.");
        if (J) W = function() {
          try {
            J.call(this)
          } catch (F) {
            return Promise.reject(F)
          }
        };
        Z.stack.push({
          value: D,
          dispose: W,
          async: Y
        })
      } else if (Y) Z.stack.push({
        async: !0
      });
      return D
    };
    var G = typeof SuppressedError === "function" ? SuppressedError : function(Z, D, Y) {
      var W = new Error(Y);
      return W.name = "SuppressedError", W.error = Z, W.suppressed = D, W
    };
    UnA = function(Z) {
      function D(F) {
        Z.error = Z.hasError ? new G(F, Z.error, "An error was suppressed during disposal.") : F, Z.hasError = !0
      }
      var Y, W = 0;

      function J() {
        while (Y = Z.stack.pop()) try {
          if (!Y.async && W === 1) return W = 0, Z.stack.push(Y), Promise.resolve().then(J);
          if (Y.dispose) {
            var F = Y.dispose.call(Y.value);
            if (Y.async) return W |= 2, Promise.resolve(F).then(J, function(X) {
              return D(X), J()
            })
          } else W |= 1
        } catch (X) {
          D(X)
        }
        if (W === 1) return Z.hasError ? Promise.reject(Z.error) : Promise.resolve();
        if (Z.hasError) throw Z.error
      }
      return J()
    }, NnA = function(Z, D) {
      if (typeof Z === "string" && /^\.\.?\//.test(Z)) return Z.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(Y, W, J, F, X) {
        return W ? D ? ".jsx" : ".js" : J && (!F || !X) ? Y : J + F + "." + X.toLowerCase() + "js"
      });
      return Z
    }, A("__extends", niA), A("__assign", aiA), A("__rest", siA), A("__decorate", riA), A("__param", oiA), A("__esDecorate", tiA), A("__runInitializers", eiA), A("__propKey", AnA), A("__setFunctionName", BnA), A("__metadata", QnA), A("__awaiter", InA), A("__generator", GnA), A("__exportStar", ZnA), A("__createBinding", vQ1), A("__values", fQ1), A("__read", i_1), A("__spread", DnA), A("__spreadArrays", YnA), A("__spreadArray", WnA), A("__await", Xb), A("__asyncGenerator", JnA), A("__asyncDelegator", FnA), A("__asyncValues", XnA), A("__makeTemplateObject", VnA), A("__importStar", CnA), A("__importDefault", KnA), A("__classPrivateFieldGet", HnA), A("__classPrivateFieldSet", znA), A("__classPrivateFieldIn", wnA), A("__addDisposableResource", EnA), A("__disposeResources", UnA), A("__rewriteRelativeImportExtension", NnA)
  })
})
// @from(Start 3199888, End 3201710)
NC = z((pQ8, RnA) => {
  var {
    defineProperty: gQ1,
    getOwnPropertyDescriptor: h34,
    getOwnPropertyNames: m34
  } = Object, d34 = Object.prototype.hasOwnProperty, a_1 = (A, B) => gQ1(A, "name", {
    value: B,
    configurable: !0
  }), u34 = (A, B) => {
    for (var Q in B) gQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, p34 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of m34(B))
        if (!d34.call(A, G) && G !== Q) gQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = h34(B, G)) || I.enumerable
        })
    }
    return A
  }, c34 = (A) => p34(gQ1({}, "__esModule", {
    value: !0
  }), A), qnA = {};
  u34(qnA, {
    emitWarningIfUnsupportedVersion: () => l34,
    setCredentialFeature: () => MnA,
    setFeature: () => LnA,
    state: () => n_1
  });
  RnA.exports = c34(qnA);
  var n_1 = {
      warningEmitted: !1
    },
    l34 = a_1((A) => {
      if (A && !n_1.warningEmitted && parseInt(A.substring(1, A.indexOf("."))) < 18) n_1.warningEmitted = !0, process.emitWarning(`NodeDeprecationWarning: The AWS SDK for JavaScript (v3) will
no longer support Node.js 16.x on January 6, 2025.

To continue receiving updates to AWS services, bug fixes, and security
updates please upgrade to a supported Node.js LTS version.

More information can be found at: https://a.co/74kJMmI`)
    }, "emitWarningIfUnsupportedVersion");

  function MnA(A, B, Q) {
    if (!A.$source) A.$source = {};
    return A.$source[B] = Q, A
  }
  a_1(MnA, "setCredentialFeature");

  function LnA(A, B, Q) {
    if (!A.__aws_sdk_context) A.__aws_sdk_context = {
      features: {}
    };
    else if (!A.__aws_sdk_context.features) A.__aws_sdk_context.features = {};
    A.__aws_sdk_context.features[B] = Q
  }
  a_1(LnA, "setFeature")
})
// @from(Start 3201716, End 3204499)
s_1 = z((cQ8, xnA) => {
  var {
    defineProperty: hQ1,
    getOwnPropertyDescriptor: i34,
    getOwnPropertyNames: n34
  } = Object, a34 = Object.prototype.hasOwnProperty, mQ1 = (A, B) => hQ1(A, "name", {
    value: B,
    configurable: !0
  }), s34 = (A, B) => {
    for (var Q in B) hQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, r34 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of n34(B))
        if (!a34.call(A, G) && G !== Q) hQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = i34(B, G)) || I.enumerable
        })
    }
    return A
  }, o34 = (A) => r34(hQ1({}, "__esModule", {
    value: !0
  }), A), OnA = {};
  s34(OnA, {
    AlgorithmId: () => _nA,
    EndpointURLScheme: () => SnA,
    FieldPosition: () => jnA,
    HttpApiKeyAuthLocation: () => PnA,
    HttpAuthLocation: () => TnA,
    IniSectionType: () => ynA,
    RequestHandlerProtocol: () => knA,
    SMITHY_CONTEXT_KEY: () => QQ4,
    getDefaultClientConfiguration: () => AQ4,
    resolveDefaultRuntimeConfig: () => BQ4
  });
  xnA.exports = o34(OnA);
  var TnA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(TnA || {}),
    PnA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(PnA || {}),
    SnA = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(SnA || {}),
    _nA = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(_nA || {}),
    t34 = mQ1((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    e34 = mQ1((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    AQ4 = mQ1((A) => {
      return t34(A)
    }, "getDefaultClientConfiguration"),
    BQ4 = mQ1((A) => {
      return e34(A)
    }, "resolveDefaultRuntimeConfig"),
    jnA = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(jnA || {}),
    QQ4 = "__smithy_context",
    ynA = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(ynA || {}),
    knA = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(knA || {})
})
// @from(Start 3204505, End 3209011)
nn = z((lQ8, hnA) => {
  var {
    defineProperty: dQ1,
    getOwnPropertyDescriptor: IQ4,
    getOwnPropertyNames: GQ4
  } = Object, ZQ4 = Object.prototype.hasOwnProperty, TL = (A, B) => dQ1(A, "name", {
    value: B,
    configurable: !0
  }), DQ4 = (A, B) => {
    for (var Q in B) dQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, YQ4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of GQ4(B))
        if (!ZQ4.call(A, G) && G !== Q) dQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = IQ4(B, G)) || I.enumerable
        })
    }
    return A
  }, WQ4 = (A) => YQ4(dQ1({}, "__esModule", {
    value: !0
  }), A), fnA = {};
  DQ4(fnA, {
    Field: () => XQ4,
    Fields: () => VQ4,
    HttpRequest: () => CQ4,
    HttpResponse: () => KQ4,
    IHttpRequest: () => vnA.HttpRequest,
    getHttpHandlerExtensionConfiguration: () => JQ4,
    isValidHostname: () => gnA,
    resolveHttpHandlerRuntimeConfig: () => FQ4
  });
  hnA.exports = WQ4(fnA);
  var JQ4 = TL((A) => {
      return {
        setHttpHandler(B) {
          A.httpHandler = B
        },
        httpHandler() {
          return A.httpHandler
        },
        updateHttpClientConfig(B, Q) {
          A.httpHandler?.updateHttpClientConfig(B, Q)
        },
        httpHandlerConfigs() {
          return A.httpHandler.httpHandlerConfigs()
        }
      }
    }, "getHttpHandlerExtensionConfiguration"),
    FQ4 = TL((A) => {
      return {
        httpHandler: A.httpHandler()
      }
    }, "resolveHttpHandlerRuntimeConfig"),
    vnA = s_1(),
    XQ4 = class {
      static {
        TL(this, "Field")
      }
      constructor({
        name: A,
        kind: B = vnA.FieldPosition.HEADER,
        values: Q = []
      }) {
        this.name = A, this.kind = B, this.values = Q
      }
      add(A) {
        this.values.push(A)
      }
      set(A) {
        this.values = A
      }
      remove(A) {
        this.values = this.values.filter((B) => B !== A)
      }
      toString() {
        return this.values.map((A) => A.includes(",") || A.includes(" ") ? `"${A}"` : A).join(", ")
      }
      get() {
        return this.values
      }
    },
    VQ4 = class {
      constructor({
        fields: A = [],
        encoding: B = "utf-8"
      }) {
        this.entries = {}, A.forEach(this.setField.bind(this)), this.encoding = B
      }
      static {
        TL(this, "Fields")
      }
      setField(A) {
        this.entries[A.name.toLowerCase()] = A
      }
      getField(A) {
        return this.entries[A.toLowerCase()]
      }
      removeField(A) {
        delete this.entries[A.toLowerCase()]
      }
      getByType(A) {
        return Object.values(this.entries).filter((B) => B.kind === A)
      }
    },
    CQ4 = class A {
      static {
        TL(this, "HttpRequest")
      }
      constructor(B) {
        this.method = B.method || "GET", this.hostname = B.hostname || "localhost", this.port = B.port, this.query = B.query || {}, this.headers = B.headers || {}, this.body = B.body, this.protocol = B.protocol ? B.protocol.slice(-1) !== ":" ? `${B.protocol}:` : B.protocol : "https:", this.path = B.path ? B.path.charAt(0) !== "/" ? `/${B.path}` : B.path : "/", this.username = B.username, this.password = B.password, this.fragment = B.fragment
      }
      static clone(B) {
        let Q = new A({
          ...B,
          headers: {
            ...B.headers
          }
        });
        if (Q.query) Q.query = bnA(Q.query);
        return Q
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return "method" in Q && "protocol" in Q && "hostname" in Q && "path" in Q && typeof Q.query === "object" && typeof Q.headers === "object"
      }
      clone() {
        return A.clone(this)
      }
    };

  function bnA(A) {
    return Object.keys(A).reduce((B, Q) => {
      let I = A[Q];
      return {
        ...B,
        [Q]: Array.isArray(I) ? [...I] : I
      }
    }, {})
  }
  TL(bnA, "cloneQuery");
  var KQ4 = class {
    static {
      TL(this, "HttpResponse")
    }
    constructor(A) {
      this.statusCode = A.statusCode, this.reason = A.reason, this.headers = A.headers || {}, this.body = A.body
    }
    static isInstance(A) {
      if (!A) return !1;
      let B = A;
      return typeof B.statusCode === "number" && typeof B.headers === "object"
    }
  };

  function gnA(A) {
    return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(A)
  }
  TL(gnA, "isValidHostname")
})
// @from(Start 3209017, End 3212009)
$I = z((sQ8, dnA) => {
  var {
    defineProperty: uQ1,
    getOwnPropertyDescriptor: HQ4,
    getOwnPropertyNames: zQ4
  } = Object, wQ4 = Object.prototype.hasOwnProperty, nS = (A, B) => uQ1(A, "name", {
    value: B,
    configurable: !0
  }), EQ4 = (A, B) => {
    for (var Q in B) uQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, UQ4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of zQ4(B))
        if (!wQ4.call(A, G) && G !== Q) uQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = HQ4(B, G)) || I.enumerable
        })
    }
    return A
  }, NQ4 = (A) => UQ4(uQ1({}, "__esModule", {
    value: !0
  }), A), mnA = {};
  EQ4(mnA, {
    CredentialsProviderError: () => $Q4,
    ProviderError: () => pQ1,
    TokenProviderError: () => qQ4,
    chain: () => MQ4,
    fromStatic: () => LQ4,
    memoize: () => RQ4
  });
  dnA.exports = NQ4(mnA);
  var pQ1 = class A extends Error {
      constructor(B, Q = !0) {
        let I, G = !0;
        if (typeof Q === "boolean") I = void 0, G = Q;
        else if (Q != null && typeof Q === "object") I = Q.logger, G = Q.tryNextLink ?? !0;
        super(B);
        this.name = "ProviderError", this.tryNextLink = G, Object.setPrototypeOf(this, A.prototype), I?.debug?.(`@smithy/property-provider ${G?"->":"(!)"} ${B}`)
      }
      static {
        nS(this, "ProviderError")
      }
      static from(B, Q = !0) {
        return Object.assign(new this(B.message, Q), B)
      }
    },
    $Q4 = class A extends pQ1 {
      constructor(B, Q = !0) {
        super(B, Q);
        this.name = "CredentialsProviderError", Object.setPrototypeOf(this, A.prototype)
      }
      static {
        nS(this, "CredentialsProviderError")
      }
    },
    qQ4 = class A extends pQ1 {
      constructor(B, Q = !0) {
        super(B, Q);
        this.name = "TokenProviderError", Object.setPrototypeOf(this, A.prototype)
      }
      static {
        nS(this, "TokenProviderError")
      }
    },
    MQ4 = nS((...A) => async () => {
      if (A.length === 0) throw new pQ1("No providers in chain");
      let B;
      for (let Q of A) try {
        return await Q()
      } catch (I) {
        if (B = I, I?.tryNextLink) continue;
        throw I
      }
      throw B
    }, "chain"),
    LQ4 = nS((A) => () => Promise.resolve(A), "fromStatic"),
    RQ4 = nS((A, B, Q) => {
      let I, G, Z, D = !1,
        Y = nS(async () => {
          if (!G) G = A();
          try {
            I = await G, Z = !0, D = !1
          } finally {
            G = void 0
          }
          return I
        }, "coalesceProvider");
      if (B === void 0) return async (W) => {
        if (!Z || W?.forceRefresh) I = await Y();
        return I
      };
      return async (W) => {
        if (!Z || W?.forceRefresh) I = await Y();
        if (D) return I;
        if (Q && !Q(I)) return D = !0, I;
        if (B(I)) return await Y(), I;
        return I
      }
    }, "memoize")
})
// @from(Start 3212015, End 3212968)
cnA = z((rQ8, pnA) => {
  var {
    defineProperty: cQ1,
    getOwnPropertyDescriptor: OQ4,
    getOwnPropertyNames: TQ4
  } = Object, PQ4 = Object.prototype.hasOwnProperty, SQ4 = (A, B) => cQ1(A, "name", {
    value: B,
    configurable: !0
  }), _Q4 = (A, B) => {
    for (var Q in B) cQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, jQ4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of TQ4(B))
        if (!PQ4.call(A, G) && G !== Q) cQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = OQ4(B, G)) || I.enumerable
        })
    }
    return A
  }, yQ4 = (A) => jQ4(cQ1({}, "__esModule", {
    value: !0
  }), A), unA = {};
  _Q4(unA, {
    isArrayBuffer: () => kQ4
  });
  pnA.exports = yQ4(unA);
  var kQ4 = SQ4((A) => typeof ArrayBuffer === "function" && A instanceof ArrayBuffer || Object.prototype.toString.call(A) === "[object ArrayBuffer]", "isArrayBuffer")
})
// @from(Start 3212974, End 3214027)
anA = z((oQ8, nnA) => {
  var {
    defineProperty: lQ1,
    getOwnPropertyDescriptor: xQ4,
    getOwnPropertyNames: fQ4
  } = Object, vQ4 = Object.prototype.hasOwnProperty, r_1 = (A, B) => lQ1(A, "name", {
    value: B,
    configurable: !0
  }), bQ4 = (A, B) => {
    for (var Q in B) lQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, gQ4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of fQ4(B))
        if (!vQ4.call(A, G) && G !== Q) lQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = xQ4(B, G)) || I.enumerable
        })
    }
    return A
  }, hQ4 = (A) => gQ4(lQ1({}, "__esModule", {
    value: !0
  }), A), lnA = {};
  bQ4(lnA, {
    escapeUri: () => inA,
    escapeUriPath: () => dQ4
  });
  nnA.exports = hQ4(lnA);
  var inA = r_1((A) => encodeURIComponent(A).replace(/[!'()*]/g, mQ4), "escapeUri"),
    mQ4 = r_1((A) => `%${A.charCodeAt(0).toString(16).toUpperCase()}`, "hexEncode"),
    dQ4 = r_1((A) => A.split("/").map(inA).join("/"), "escapeUriPath")
})
// @from(Start 3214033, End 3230850)
qaA = z((tQ8, $aA) => {
  var {
    defineProperty: tQ1,
    getOwnPropertyDescriptor: uQ4,
    getOwnPropertyNames: pQ4
  } = Object, cQ4 = Object.prototype.hasOwnProperty, LG = (A, B) => tQ1(A, "name", {
    value: B,
    configurable: !0
  }), lQ4 = (A, B) => {
    for (var Q in B) tQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, iQ4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of pQ4(B))
        if (!cQ4.call(A, G) && G !== Q) tQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = uQ4(B, G)) || I.enumerable
        })
    }
    return A
  }, nQ4 = (A) => iQ4(tQ1({}, "__esModule", {
    value: !0
  }), A), enA = {};
  lQ4(enA, {
    ALGORITHM_IDENTIFIER: () => iQ1,
    ALGORITHM_IDENTIFIER_V4A: () => oQ4,
    ALGORITHM_QUERY_PARAM: () => AaA,
    ALWAYS_UNSIGNABLE_HEADERS: () => WaA,
    AMZ_DATE_HEADER: () => Gj1,
    AMZ_DATE_QUERY_PARAM: () => Aj1,
    AUTH_HEADER: () => Ij1,
    CREDENTIAL_QUERY_PARAM: () => BaA,
    DATE_HEADER: () => GaA,
    EVENT_ALGORITHM_IDENTIFIER: () => XaA,
    EXPIRES_QUERY_PARAM: () => IaA,
    GENERATED_HEADERS: () => ZaA,
    HOST_HEADER: () => sQ4,
    KEY_TYPE_IDENTIFIER: () => Zj1,
    MAX_CACHE_SIZE: () => CaA,
    MAX_PRESIGNED_TTL: () => KaA,
    PROXY_HEADER_PATTERN: () => JaA,
    REGION_SET_PARAM: () => aQ4,
    SEC_HEADER_PATTERN: () => FaA,
    SHA256_HEADER: () => oQ1,
    SIGNATURE_HEADER: () => DaA,
    SIGNATURE_QUERY_PARAM: () => Bj1,
    SIGNED_HEADERS_QUERY_PARAM: () => QaA,
    SignatureV4: () => W74,
    SignatureV4Base: () => NaA,
    TOKEN_HEADER: () => YaA,
    TOKEN_QUERY_PARAM: () => Qj1,
    UNSIGNABLE_PATTERNS: () => rQ4,
    UNSIGNED_PAYLOAD: () => VaA,
    clearCredentialCache: () => eQ4,
    createScope: () => aQ1,
    getCanonicalHeaders: () => o_1,
    getCanonicalQuery: () => UaA,
    getPayloadHash: () => sQ1,
    getSigningKey: () => HaA,
    hasHeader: () => zaA,
    moveHeadersToQuery: () => EaA,
    prepareRequest: () => e_1,
    signatureV4aContainer: () => J74
  });
  $aA.exports = nQ4(enA);
  var snA = RQ(),
    AaA = "X-Amz-Algorithm",
    BaA = "X-Amz-Credential",
    Aj1 = "X-Amz-Date",
    QaA = "X-Amz-SignedHeaders",
    IaA = "X-Amz-Expires",
    Bj1 = "X-Amz-Signature",
    Qj1 = "X-Amz-Security-Token",
    aQ4 = "X-Amz-Region-Set",
    Ij1 = "authorization",
    Gj1 = Aj1.toLowerCase(),
    GaA = "date",
    ZaA = [Ij1, Gj1, GaA],
    DaA = Bj1.toLowerCase(),
    oQ1 = "x-amz-content-sha256",
    YaA = Qj1.toLowerCase(),
    sQ4 = "host",
    WaA = {
      authorization: !0,
      "cache-control": !0,
      connection: !0,
      expect: !0,
      from: !0,
      "keep-alive": !0,
      "max-forwards": !0,
      pragma: !0,
      referer: !0,
      te: !0,
      trailer: !0,
      "transfer-encoding": !0,
      upgrade: !0,
      "user-agent": !0,
      "x-amzn-trace-id": !0
    },
    JaA = /^proxy-/,
    FaA = /^sec-/,
    rQ4 = [/^proxy-/i, /^sec-/i],
    iQ1 = "AWS4-HMAC-SHA256",
    oQ4 = "AWS4-ECDSA-P256-SHA256",
    XaA = "AWS4-HMAC-SHA256-PAYLOAD",
    VaA = "UNSIGNED-PAYLOAD",
    CaA = 50,
    Zj1 = "aws4_request",
    KaA = 604800,
    PL = MQ1(),
    tQ4 = RQ(),
    Vb = {},
    nQ1 = [],
    aQ1 = LG((A, B, Q) => `${A}/${B}/${Q}/${Zj1}`, "createScope"),
    HaA = LG(async (A, B, Q, I, G) => {
      let Z = await rnA(A, B.secretAccessKey, B.accessKeyId),
        D = `${Q}:${I}:${G}:${PL.toHex(Z)}:${B.sessionToken}`;
      if (D in Vb) return Vb[D];
      nQ1.push(D);
      while (nQ1.length > CaA) delete Vb[nQ1.shift()];
      let Y = `AWS4${B.secretAccessKey}`;
      for (let W of [Q, I, G, Zj1]) Y = await rnA(A, Y, W);
      return Vb[D] = Y
    }, "getSigningKey"),
    eQ4 = LG(() => {
      nQ1.length = 0, Object.keys(Vb).forEach((A) => {
        delete Vb[A]
      })
    }, "clearCredentialCache"),
    rnA = LG((A, B, Q) => {
      let I = new A(B);
      return I.update(tQ4.toUint8Array(Q)), I.digest()
    }, "hmac"),
    o_1 = LG(({
      headers: A
    }, B, Q) => {
      let I = {};
      for (let G of Object.keys(A).sort()) {
        if (A[G] == null) continue;
        let Z = G.toLowerCase();
        if (Z in WaA || B?.has(Z) || JaA.test(Z) || FaA.test(Z)) {
          if (!Q || Q && !Q.has(Z)) continue
        }
        I[Z] = A[G].trim().replace(/\s+/g, " ")
      }
      return I
    }, "getCanonicalHeaders"),
    A74 = cnA(),
    B74 = RQ(),
    sQ1 = LG(async ({
      headers: A,
      body: B
    }, Q) => {
      for (let I of Object.keys(A))
        if (I.toLowerCase() === oQ1) return A[I];
      if (B == null) return "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
      else if (typeof B === "string" || ArrayBuffer.isView(B) || A74.isArrayBuffer(B)) {
        let I = new Q;
        return I.update(B74.toUint8Array(B)), PL.toHex(await I.digest())
      }
      return VaA
    }, "getPayloadHash"),
    onA = RQ(),
    Q74 = class {
      static {
        LG(this, "HeaderFormatter")
      }
      format(A) {
        let B = [];
        for (let G of Object.keys(A)) {
          let Z = onA.fromUtf8(G);
          B.push(Uint8Array.from([Z.byteLength]), Z, this.formatHeaderValue(A[G]))
        }
        let Q = new Uint8Array(B.reduce((G, Z) => G + Z.byteLength, 0)),
          I = 0;
        for (let G of B) Q.set(G, I), I += G.byteLength;
        return Q
      }
      formatHeaderValue(A) {
        switch (A.type) {
          case "boolean":
            return Uint8Array.from([A.value ? 0 : 1]);
          case "byte":
            return Uint8Array.from([2, A.value]);
          case "short":
            let B = new DataView(new ArrayBuffer(3));
            return B.setUint8(0, 3), B.setInt16(1, A.value, !1), new Uint8Array(B.buffer);
          case "integer":
            let Q = new DataView(new ArrayBuffer(5));
            return Q.setUint8(0, 4), Q.setInt32(1, A.value, !1), new Uint8Array(Q.buffer);
          case "long":
            let I = new Uint8Array(9);
            return I[0] = 5, I.set(A.value.bytes, 1), I;
          case "binary":
            let G = new DataView(new ArrayBuffer(3 + A.value.byteLength));
            G.setUint8(0, 6), G.setUint16(1, A.value.byteLength, !1);
            let Z = new Uint8Array(G.buffer);
            return Z.set(A.value, 3), Z;
          case "string":
            let D = onA.fromUtf8(A.value),
              Y = new DataView(new ArrayBuffer(3 + D.byteLength));
            Y.setUint8(0, 7), Y.setUint16(1, D.byteLength, !1);
            let W = new Uint8Array(Y.buffer);
            return W.set(D, 3), W;
          case "timestamp":
            let J = new Uint8Array(9);
            return J[0] = 8, J.set(G74.fromNumber(A.value.valueOf()).bytes, 1), J;
          case "uuid":
            if (!I74.test(A.value)) throw new Error(`Invalid UUID received: ${A.value}`);
            let F = new Uint8Array(17);
            return F[0] = 9, F.set(PL.fromHex(A.value.replace(/\-/g, "")), 1), F
        }
      }
    },
    I74 = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/,
    G74 = class A {
      constructor(B) {
        if (this.bytes = B, B.byteLength !== 8) throw new Error("Int64 buffers must be exactly 8 bytes")
      }
      static {
        LG(this, "Int64")
      }
      static fromNumber(B) {
        if (B > 9223372036854776000 || B < -9223372036854776000) throw new Error(`${B} is too large (or, if negative, too small) to represent as an Int64`);
        let Q = new Uint8Array(8);
        for (let I = 7, G = Math.abs(Math.round(B)); I > -1 && G > 0; I--, G /= 256) Q[I] = G;
        if (B < 0) t_1(Q);
        return new A(Q)
      }
      valueOf() {
        let B = this.bytes.slice(0),
          Q = B[0] & 128;
        if (Q) t_1(B);
        return parseInt(PL.toHex(B), 16) * (Q ? -1 : 1)
      }
      toString() {
        return String(this.valueOf())
      }
    };

  function t_1(A) {
    for (let B = 0; B < 8; B++) A[B] ^= 255;
    for (let B = 7; B > -1; B--)
      if (A[B]++, A[B] !== 0) break
  }
  LG(t_1, "negate");
  var zaA = LG((A, B) => {
      A = A.toLowerCase();
      for (let Q of Object.keys(B))
        if (A === Q.toLowerCase()) return !0;
      return !1
    }, "hasHeader"),
    waA = nn(),
    EaA = LG((A, B = {}) => {
      let {
        headers: Q,
        query: I = {}
      } = waA.HttpRequest.clone(A);
      for (let G of Object.keys(Q)) {
        let Z = G.toLowerCase();
        if (Z.slice(0, 6) === "x-amz-" && !B.unhoistableHeaders?.has(Z) || B.hoistableHeaders?.has(Z)) I[G] = Q[G], delete Q[G]
      }
      return {
        ...A,
        headers: Q,
        query: I
      }
    }, "moveHeadersToQuery"),
    e_1 = LG((A) => {
      A = waA.HttpRequest.clone(A);
      for (let B of Object.keys(A.headers))
        if (ZaA.indexOf(B.toLowerCase()) > -1) delete A.headers[B];
      return A
    }, "prepareRequest"),
    tnA = ZX(),
    Z74 = RQ(),
    rQ1 = anA(),
    UaA = LG(({
      query: A = {}
    }) => {
      let B = [],
        Q = {};
      for (let I of Object.keys(A)) {
        if (I.toLowerCase() === DaA) continue;
        let G = rQ1.escapeUri(I);
        B.push(G);
        let Z = A[I];
        if (typeof Z === "string") Q[G] = `${G}=${rQ1.escapeUri(Z)}`;
        else if (Array.isArray(Z)) Q[G] = Z.slice(0).reduce((D, Y) => D.concat([`${G}=${rQ1.escapeUri(Y)}`]), []).sort().join("&")
      }
      return B.sort().map((I) => Q[I]).filter((I) => I).join("&")
    }, "getCanonicalQuery"),
    D74 = LG((A) => Y74(A).toISOString().replace(/\.\d{3}Z$/, "Z"), "iso8601"),
    Y74 = LG((A) => {
      if (typeof A === "number") return new Date(A * 1000);
      if (typeof A === "string") {
        if (Number(A)) return new Date(Number(A) * 1000);
        return new Date(A)
      }
      return A
    }, "toDate"),
    NaA = class {
      static {
        LG(this, "SignatureV4Base")
      }
      constructor({
        applyChecksum: A,
        credentials: B,
        region: Q,
        service: I,
        sha256: G,
        uriEscapePath: Z = !0
      }) {
        this.service = I, this.sha256 = G, this.uriEscapePath = Z, this.applyChecksum = typeof A === "boolean" ? A : !0, this.regionProvider = tnA.normalizeProvider(Q), this.credentialProvider = tnA.normalizeProvider(B)
      }
      createCanonicalRequest(A, B, Q) {
        let I = Object.keys(B).sort();
        return `${A.method}
${this.getCanonicalPath(A)}
${UaA(A)}
${I.map((G)=>`${G}:${B[G]}`).join(`
`)}

${I.join(";")}
${Q}`
      }
      async createStringToSign(A, B, Q, I) {
        let G = new this.sha256;
        G.update(Z74.toUint8Array(Q));
        let Z = await G.digest();
        return `${I}
${A}
${B}
${PL.toHex(Z)}`
      }
      getCanonicalPath({
        path: A
      }) {
        if (this.uriEscapePath) {
          let B = [];
          for (let G of A.split("/")) {
            if (G?.length === 0) continue;
            if (G === ".") continue;
            if (G === "..") B.pop();
            else B.push(G)
          }
          let Q = `${A?.startsWith("/")?"/":""}${B.join("/")}${B.length>0&&A?.endsWith("/")?"/":""}`;
          return rQ1.escapeUri(Q).replace(/%2F/g, "/")
        }
        return A
      }
      validateResolvedCredentials(A) {
        if (typeof A !== "object" || typeof A.accessKeyId !== "string" || typeof A.secretAccessKey !== "string") throw new Error("Resolved credential object is not valid")
      }
      formatDate(A) {
        let B = D74(A).replace(/[\-:]/g, "");
        return {
          longDate: B,
          shortDate: B.slice(0, 8)
        }
      }
      getCanonicalHeaderList(A) {
        return Object.keys(A).sort().join(";")
      }
    },
    W74 = class extends NaA {
      constructor({
        applyChecksum: A,
        credentials: B,
        region: Q,
        service: I,
        sha256: G,
        uriEscapePath: Z = !0
      }) {
        super({
          applyChecksum: A,
          credentials: B,
          region: Q,
          service: I,
          sha256: G,
          uriEscapePath: Z
        });
        this.headerFormatter = new Q74
      }
      static {
        LG(this, "SignatureV4")
      }
      async presign(A, B = {}) {
        let {
          signingDate: Q = new Date,
          expiresIn: I = 3600,
          unsignableHeaders: G,
          unhoistableHeaders: Z,
          signableHeaders: D,
          hoistableHeaders: Y,
          signingRegion: W,
          signingService: J
        } = B, F = await this.credentialProvider();
        this.validateResolvedCredentials(F);
        let X = W ?? await this.regionProvider(),
          {
            longDate: V,
            shortDate: C
          } = this.formatDate(Q);
        if (I > KaA) return Promise.reject("Signature version 4 presigned URLs must have an expiration date less than one week in the future");
        let K = aQ1(C, X, J ?? this.service),
          E = EaA(e_1(A), {
            unhoistableHeaders: Z,
            hoistableHeaders: Y
          });
        if (F.sessionToken) E.query[Qj1] = F.sessionToken;
        E.query[AaA] = iQ1, E.query[BaA] = `${F.accessKeyId}/${K}`, E.query[Aj1] = V, E.query[IaA] = I.toString(10);
        let N = o_1(E, G, D);
        return E.query[QaA] = this.getCanonicalHeaderList(N), E.query[Bj1] = await this.getSignature(V, K, this.getSigningKey(F, X, C, J), this.createCanonicalRequest(E, N, await sQ1(A, this.sha256))), E
      }
      async sign(A, B) {
        if (typeof A === "string") return this.signString(A, B);
        else if (A.headers && A.payload) return this.signEvent(A, B);
        else if (A.message) return this.signMessage(A, B);
        else return this.signRequest(A, B)
      }
      async signEvent({
        headers: A,
        payload: B
      }, {
        signingDate: Q = new Date,
        priorSignature: I,
        signingRegion: G,
        signingService: Z
      }) {
        let D = G ?? await this.regionProvider(),
          {
            shortDate: Y,
            longDate: W
          } = this.formatDate(Q),
          J = aQ1(Y, D, Z ?? this.service),
          F = await sQ1({
            headers: {},
            body: B
          }, this.sha256),
          X = new this.sha256;
        X.update(A);
        let V = PL.toHex(await X.digest()),
          C = [XaA, W, J, I, V, F].join(`
`);
        return this.signString(C, {
          signingDate: Q,
          signingRegion: D,
          signingService: Z
        })
      }
      async signMessage(A, {
        signingDate: B = new Date,
        signingRegion: Q,
        signingService: I
      }) {
        return this.signEvent({
          headers: this.headerFormatter.format(A.message.headers),
          payload: A.message.body
        }, {
          signingDate: B,
          signingRegion: Q,
          signingService: I,
          priorSignature: A.priorSignature
        }).then((Z) => {
          return {
            message: A.message,
            signature: Z
          }
        })
      }
      async signString(A, {
        signingDate: B = new Date,
        signingRegion: Q,
        signingService: I
      } = {}) {
        let G = await this.credentialProvider();
        this.validateResolvedCredentials(G);
        let Z = Q ?? await this.regionProvider(),
          {
            shortDate: D
          } = this.formatDate(B),
          Y = new this.sha256(await this.getSigningKey(G, Z, D, I));
        return Y.update(snA.toUint8Array(A)), PL.toHex(await Y.digest())
      }
      async signRequest(A, {
        signingDate: B = new Date,
        signableHeaders: Q,
        unsignableHeaders: I,
        signingRegion: G,
        signingService: Z
      } = {}) {
        let D = await this.credentialProvider();
        this.validateResolvedCredentials(D);
        let Y = G ?? await this.regionProvider(),
          W = e_1(A),
          {
            longDate: J,
            shortDate: F
          } = this.formatDate(B),
          X = aQ1(F, Y, Z ?? this.service);
        if (W.headers[Gj1] = J, D.sessionToken) W.headers[YaA] = D.sessionToken;
        let V = await sQ1(W, this.sha256);
        if (!zaA(oQ1, W.headers) && this.applyChecksum) W.headers[oQ1] = V;
        let C = o_1(W, I, Q),
          K = await this.getSignature(J, X, this.getSigningKey(D, Y, F, Z), this.createCanonicalRequest(W, C, V));
        return W.headers[Ij1] = `${iQ1} Credential=${D.accessKeyId}/${X}, SignedHeaders=${this.getCanonicalHeaderList(C)}, Signature=${K}`, W
      }
      async getSignature(A, B, Q, I) {
        let G = await this.createStringToSign(A, B, I, iQ1),
          Z = new this.sha256(await Q);
        return Z.update(snA.toUint8Array(G)), PL.toHex(await Z.digest())
      }
      getSigningKey(A, B, Q, I) {
        return HaA(this.sha256, A, Q, B, I || this.service)
      }
    },
    J74 = {
      SignatureV4a: null
    }
})
// @from(Start 3230856, End 3239418)
yaA = z((Q78, jaA) => {
  var {
    defineProperty: eQ1,
    getOwnPropertyDescriptor: F74,
    getOwnPropertyNames: X74
  } = Object, V74 = Object.prototype.hasOwnProperty, RG = (A, B) => eQ1(A, "name", {
    value: B,
    configurable: !0
  }), C74 = (A, B) => {
    for (var Q in B) eQ1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, K74 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of X74(B))
        if (!V74.call(A, G) && G !== Q) eQ1(A, G, {
          get: () => B[G],
          enumerable: !(I = F74(B, G)) || I.enumerable
        })
    }
    return A
  }, H74 = (A) => K74(eQ1({}, "__esModule", {
    value: !0
  }), A), TaA = {};
  C74(TaA, {
    AWSSDKSigV4Signer: () => U74,
    AwsSdkSigV4ASigner: () => $74,
    AwsSdkSigV4Signer: () => Wj1,
    NODE_SIGV4A_CONFIG_OPTIONS: () => L74,
    resolveAWSSDKSigV4Config: () => O74,
    resolveAwsSdkSigV4AConfig: () => M74,
    resolveAwsSdkSigV4Config: () => PaA,
    validateSigningProperties: () => Yj1
  });
  jaA.exports = H74(TaA);
  var z74 = nn(),
    w74 = nn(),
    MaA = RG((A) => w74.HttpResponse.isInstance(A) ? A.headers?.date ?? A.headers?.Date : void 0, "getDateHeader"),
    Dj1 = RG((A) => new Date(Date.now() + A), "getSkewCorrectedDate"),
    E74 = RG((A, B) => Math.abs(Dj1(B).getTime() - A) >= 300000, "isClockSkewed"),
    LaA = RG((A, B) => {
      let Q = Date.parse(A);
      if (E74(Q, B)) return Q - Date.now();
      return B
    }, "getUpdatedSystemClockOffset"),
    an = RG((A, B) => {
      if (!B) throw new Error(`Property \`${A}\` is not resolved for AWS SDK SigV4Auth`);
      return B
    }, "throwSigningPropertyError"),
    Yj1 = RG(async (A) => {
      let B = an("context", A.context),
        Q = an("config", A.config),
        I = B.endpointV2?.properties?.authSchemes?.[0],
        Z = await an("signer", Q.signer)(I),
        D = A?.signingRegion,
        Y = A?.signingRegionSet,
        W = A?.signingName;
      return {
        config: Q,
        signer: Z,
        signingRegion: D,
        signingRegionSet: Y,
        signingName: W
      }
    }, "validateSigningProperties"),
    Wj1 = class {
      static {
        RG(this, "AwsSdkSigV4Signer")
      }
      async sign(A, B, Q) {
        if (!z74.HttpRequest.isInstance(A)) throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
        let I = await Yj1(Q),
          {
            config: G,
            signer: Z
          } = I,
          {
            signingRegion: D,
            signingName: Y
          } = I,
          W = Q.context;
        if (W?.authSchemes?.length ?? 0 > 1) {
          let [F, X] = W.authSchemes;
          if (F?.name === "sigv4a" && X?.name === "sigv4") D = X?.signingRegion ?? D, Y = X?.signingName ?? Y
        }
        return await Z.sign(A, {
          signingDate: Dj1(G.systemClockOffset),
          signingRegion: D,
          signingService: Y
        })
      }
      errorHandler(A) {
        return (B) => {
          let Q = B.ServerTime ?? MaA(B.$response);
          if (Q) {
            let I = an("config", A.config),
              G = I.systemClockOffset;
            if (I.systemClockOffset = LaA(Q, I.systemClockOffset), I.systemClockOffset !== G && B.$metadata) B.$metadata.clockSkewCorrected = !0
          }
          throw B
        }
      }
      successHandler(A, B) {
        let Q = MaA(A);
        if (Q) {
          let I = an("config", B.config);
          I.systemClockOffset = LaA(Q, I.systemClockOffset)
        }
      }
    },
    U74 = Wj1,
    N74 = nn(),
    $74 = class extends Wj1 {
      static {
        RG(this, "AwsSdkSigV4ASigner")
      }
      async sign(A, B, Q) {
        if (!N74.HttpRequest.isInstance(A)) throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
        let {
          config: I,
          signer: G,
          signingRegion: Z,
          signingRegionSet: D,
          signingName: Y
        } = await Yj1(Q), J = (await I.sigv4aSigningRegionSet?.() ?? D ?? [Z]).join(",");
        return await G.sign(A, {
          signingDate: Dj1(I.systemClockOffset),
          signingRegion: J,
          signingService: Y
        })
      }
    },
    q74 = NI(),
    RaA = $I(),
    M74 = RG((A) => {
      return A.sigv4aSigningRegionSet = q74.normalizeProvider(A.sigv4aSigningRegionSet), A
    }, "resolveAwsSdkSigV4AConfig"),
    L74 = {
      environmentVariableSelector(A) {
        if (A.AWS_SIGV4A_SIGNING_REGION_SET) return A.AWS_SIGV4A_SIGNING_REGION_SET.split(",").map((B) => B.trim());
        throw new RaA.ProviderError("AWS_SIGV4A_SIGNING_REGION_SET not set in env.", {
          tryNextLink: !0
        })
      },
      configFileSelector(A) {
        if (A.sigv4a_signing_region_set) return (A.sigv4a_signing_region_set ?? "").split(",").map((B) => B.trim());
        throw new RaA.ProviderError("sigv4a_signing_region_set not set in profile.", {
          tryNextLink: !0
        })
      },
      default: void 0
    },
    R74 = NC(),
    aS = NI(),
    OaA = qaA(),
    PaA = RG((A) => {
      let B = A.credentials,
        Q = !!A.credentials,
        I = void 0;
      Object.defineProperty(A, "credentials", {
        set(J) {
          if (J && J !== B && J !== I) Q = !0;
          B = J;
          let F = SaA(A, {
              credentials: B,
              credentialDefaultProvider: A.credentialDefaultProvider
            }),
            X = _aA(A, F);
          if (Q && !X.attributed) I = RG(async (V) => X(V).then((C) => R74.setCredentialFeature(C, "CREDENTIALS_CODE", "e")), "resolvedCredentials"), I.memoized = X.memoized, I.configBound = X.configBound, I.attributed = !0;
          else I = X
        },
        get() {
          return I
        },
        enumerable: !0,
        configurable: !0
      }), A.credentials = B;
      let {
        signingEscapePath: G = !0,
        systemClockOffset: Z = A.systemClockOffset || 0,
        sha256: D
      } = A, Y;
      if (A.signer) Y = aS.normalizeProvider(A.signer);
      else if (A.regionInfoProvider) Y = RG(() => aS.normalizeProvider(A.region)().then(async (J) => [await A.regionInfoProvider(J, {
        useFipsEndpoint: await A.useFipsEndpoint(),
        useDualstackEndpoint: await A.useDualstackEndpoint()
      }) || {}, J]).then(([J, F]) => {
        let {
          signingRegion: X,
          signingService: V
        } = J;
        A.signingRegion = A.signingRegion || X || F, A.signingName = A.signingName || V || A.serviceId;
        let C = {
          ...A,
          credentials: A.credentials,
          region: A.signingRegion,
          service: A.signingName,
          sha256: D,
          uriEscapePath: G
        };
        return new(A.signerConstructor || OaA.SignatureV4)(C)
      }), "signer");
      else Y = RG(async (J) => {
        J = Object.assign({}, {
          name: "sigv4",
          signingName: A.signingName || A.defaultSigningName,
          signingRegion: await aS.normalizeProvider(A.region)(),
          properties: {}
        }, J);
        let {
          signingRegion: F,
          signingName: X
        } = J;
        A.signingRegion = A.signingRegion || F, A.signingName = A.signingName || X || A.serviceId;
        let V = {
          ...A,
          credentials: A.credentials,
          region: A.signingRegion,
          service: A.signingName,
          sha256: D,
          uriEscapePath: G
        };
        return new(A.signerConstructor || OaA.SignatureV4)(V)
      }, "signer");
      return Object.assign(A, {
        systemClockOffset: Z,
        signingEscapePath: G,
        signer: Y
      })
    }, "resolveAwsSdkSigV4Config"),
    O74 = PaA;

  function SaA(A, {
    credentials: B,
    credentialDefaultProvider: Q
  }) {
    let I;
    if (B)
      if (!B?.memoized) I = aS.memoizeIdentityProvider(B, aS.isIdentityExpired, aS.doesIdentityRequireRefresh);
      else I = B;
    else if (Q) I = aS.normalizeProvider(Q(Object.assign({}, A, {
      parentClientConfig: A
    })));
    else I = RG(async () => {
      throw new Error("@aws-sdk/core::resolveAwsSdkSigV4Config - `credentials` not provided and no credentialDefaultProvider was configured.")
    }, "credentialsProvider");
    return I.memoized = !0, I
  }
  RG(SaA, "normalizeCredentialProvider");

  function _aA(A, B) {
    if (B.configBound) return B;
    let Q = RG(async (I) => B({
      ...I,
      callerClientConfig: A
    }), "fn");
    return Q.memoized = B.memoized, Q.configBound = !0, Q
  }
  RG(_aA, "bindCallerConfig")
})
// @from(Start 3239424, End 3247240)
WN = z((Z78, vaA) => {
  var {
    defineProperty: A71,
    getOwnPropertyDescriptor: T74,
    getOwnPropertyNames: P74
  } = Object, S74 = Object.prototype.hasOwnProperty, DX = (A, B) => A71(A, "name", {
    value: B,
    configurable: !0
  }), _74 = (A, B) => {
    for (var Q in B) A71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, j74 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of P74(B))
        if (!S74.call(A, G) && G !== Q) A71(A, G, {
          get: () => B[G],
          enumerable: !(I = T74(B, G)) || I.enumerable
        })
    }
    return A
  }, y74 = (A) => j74(A71({}, "__esModule", {
    value: !0
  }), A), faA = {};
  _74(faA, {
    constructStack: () => Jj1
  });
  vaA.exports = y74(faA);
  var sS = DX((A, B) => {
      let Q = [];
      if (A) Q.push(A);
      if (B)
        for (let I of B) Q.push(I);
      return Q
    }, "getAllAliases"),
    SL = DX((A, B) => {
      return `${A||"anonymous"}${B&&B.length>0?` (a.k.a. ${B.join(",")})`:""}`
    }, "getMiddlewareNameWithAliases"),
    Jj1 = DX(() => {
      let A = [],
        B = [],
        Q = !1,
        I = new Set,
        G = DX((X) => X.sort((V, C) => kaA[C.step] - kaA[V.step] || xaA[C.priority || "normal"] - xaA[V.priority || "normal"]), "sort"),
        Z = DX((X) => {
          let V = !1,
            C = DX((K) => {
              let E = sS(K.name, K.aliases);
              if (E.includes(X)) {
                V = !0;
                for (let N of E) I.delete(N);
                return !1
              }
              return !0
            }, "filterCb");
          return A = A.filter(C), B = B.filter(C), V
        }, "removeByName"),
        D = DX((X) => {
          let V = !1,
            C = DX((K) => {
              if (K.middleware === X) {
                V = !0;
                for (let E of sS(K.name, K.aliases)) I.delete(E);
                return !1
              }
              return !0
            }, "filterCb");
          return A = A.filter(C), B = B.filter(C), V
        }, "removeByReference"),
        Y = DX((X) => {
          return A.forEach((V) => {
            X.add(V.middleware, {
              ...V
            })
          }), B.forEach((V) => {
            X.addRelativeTo(V.middleware, {
              ...V
            })
          }), X.identifyOnResolve?.(F.identifyOnResolve()), X
        }, "cloneTo"),
        W = DX((X) => {
          let V = [];
          return X.before.forEach((C) => {
            if (C.before.length === 0 && C.after.length === 0) V.push(C);
            else V.push(...W(C))
          }), V.push(X), X.after.reverse().forEach((C) => {
            if (C.before.length === 0 && C.after.length === 0) V.push(C);
            else V.push(...W(C))
          }), V
        }, "expandRelativeMiddlewareList"),
        J = DX((X = !1) => {
          let V = [],
            C = [],
            K = {};
          return A.forEach((N) => {
            let q = {
              ...N,
              before: [],
              after: []
            };
            for (let O of sS(q.name, q.aliases)) K[O] = q;
            V.push(q)
          }), B.forEach((N) => {
            let q = {
              ...N,
              before: [],
              after: []
            };
            for (let O of sS(q.name, q.aliases)) K[O] = q;
            C.push(q)
          }), C.forEach((N) => {
            if (N.toMiddleware) {
              let q = K[N.toMiddleware];
              if (q === void 0) {
                if (X) return;
                throw new Error(`${N.toMiddleware} is not found when adding ${SL(N.name,N.aliases)} middleware ${N.relation} ${N.toMiddleware}`)
              }
              if (N.relation === "after") q.after.push(N);
              if (N.relation === "before") q.before.push(N)
            }
          }), G(V).map(W).reduce((N, q) => {
            return N.push(...q), N
          }, [])
        }, "getMiddlewareList"),
        F = {
          add: (X, V = {}) => {
            let {
              name: C,
              override: K,
              aliases: E
            } = V, N = {
              step: "initialize",
              priority: "normal",
              middleware: X,
              ...V
            }, q = sS(C, E);
            if (q.length > 0) {
              if (q.some((O) => I.has(O))) {
                if (!K) throw new Error(`Duplicate middleware name '${SL(C,E)}'`);
                for (let O of q) {
                  let R = A.findIndex((L) => L.name === O || L.aliases?.some((_) => _ === O));
                  if (R === -1) continue;
                  let T = A[R];
                  if (T.step !== N.step || N.priority !== T.priority) throw new Error(`"${SL(T.name,T.aliases)}" middleware with ${T.priority} priority in ${T.step} step cannot be overridden by "${SL(C,E)}" middleware with ${N.priority} priority in ${N.step} step.`);
                  A.splice(R, 1)
                }
              }
              for (let O of q) I.add(O)
            }
            A.push(N)
          },
          addRelativeTo: (X, V) => {
            let {
              name: C,
              override: K,
              aliases: E
            } = V, N = {
              middleware: X,
              ...V
            }, q = sS(C, E);
            if (q.length > 0) {
              if (q.some((O) => I.has(O))) {
                if (!K) throw new Error(`Duplicate middleware name '${SL(C,E)}'`);
                for (let O of q) {
                  let R = B.findIndex((L) => L.name === O || L.aliases?.some((_) => _ === O));
                  if (R === -1) continue;
                  let T = B[R];
                  if (T.toMiddleware !== N.toMiddleware || T.relation !== N.relation) throw new Error(`"${SL(T.name,T.aliases)}" middleware ${T.relation} "${T.toMiddleware}" middleware cannot be overridden by "${SL(C,E)}" middleware ${N.relation} "${N.toMiddleware}" middleware.`);
                  B.splice(R, 1)
                }
              }
              for (let O of q) I.add(O)
            }
            B.push(N)
          },
          clone: () => Y(Jj1()),
          use: (X) => {
            X.applyToStack(F)
          },
          remove: (X) => {
            if (typeof X === "string") return Z(X);
            else return D(X)
          },
          removeByTag: (X) => {
            let V = !1,
              C = DX((K) => {
                let {
                  tags: E,
                  name: N,
                  aliases: q
                } = K;
                if (E && E.includes(X)) {
                  let O = sS(N, q);
                  for (let R of O) I.delete(R);
                  return V = !0, !1
                }
                return !0
              }, "filterCb");
            return A = A.filter(C), B = B.filter(C), V
          },
          concat: (X) => {
            let V = Y(Jj1());
            return V.use(X), V.identifyOnResolve(Q || V.identifyOnResolve() || (X.identifyOnResolve?.() ?? !1)), V
          },
          applyToStack: Y,
          identify: () => {
            return J(!0).map((X) => {
              let V = X.step ?? X.relation + " " + X.toMiddleware;
              return SL(X.name, X.aliases) + " - " + V
            })
          },
          identifyOnResolve(X) {
            if (typeof X === "boolean") Q = X;
            return Q
          },
          resolve: (X, V) => {
            for (let C of J().map((K) => K.middleware).reverse()) X = C(X, V);
            if (Q) console.log(F.identify());
            return X
          }
        };
      return F
    }, "constructStack"),
    kaA = {
      initialize: 5,
      serialize: 4,
      build: 3,
      finalizeRequest: 2,
      deserialize: 1
    },
    xaA = {
      high: 3,
      normal: 2,
      low: 1
    }
})
// @from(Start 3247246, End 3275784)
G71 = z((D78, AsA) => {
  var {
    defineProperty: I71,
    getOwnPropertyDescriptor: k74,
    getOwnPropertyNames: x74
  } = Object, f74 = Object.prototype.hasOwnProperty, r0 = (A, B) => I71(A, "name", {
    value: B,
    configurable: !0
  }), v74 = (A, B) => {
    for (var Q in B) I71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, b74 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of x74(B))
        if (!f74.call(A, G) && G !== Q) I71(A, G, {
          get: () => B[G],
          enumerable: !(I = k74(B, G)) || I.enumerable
        })
    }
    return A
  }, g74 = (A) => b74(I71({}, "__esModule", {
    value: !0
  }), A), gaA = {};
  v74(gaA, {
    Client: () => h74,
    Command: () => maA,
    LazyJsonString: () => rS,
    NoOpLogger: () => fI4,
    SENSITIVE_STRING: () => d74,
    ServiceException: () => qI4,
    _json: () => zj1,
    collectBody: () => Fj1.collectBody,
    convertMap: () => vI4,
    createAggregatedClient: () => u74,
    dateToUtcString: () => iaA,
    decorateServiceException: () => naA,
    emitWarningIfUnsupportedVersion: () => OI4,
    expectBoolean: () => c74,
    expectByte: () => Hj1,
    expectFloat32: () => B71,
    expectInt: () => i74,
    expectInt32: () => Cj1,
    expectLong: () => on,
    expectNonNull: () => a74,
    expectNumber: () => rn,
    expectObject: () => daA,
    expectShort: () => Kj1,
    expectString: () => s74,
    expectUnion: () => r74,
    extendedEncodeURIComponent: () => Fj1.extendedEncodeURIComponent,
    getArrayIfSingleItem: () => kI4,
    getDefaultClientConfiguration: () => jI4,
    getDefaultExtensionConfiguration: () => saA,
    getValueFromTextNode: () => raA,
    handleFloat: () => e74,
    isSerializableHeaderValue: () => xI4,
    limitedParseDouble: () => Uj1,
    limitedParseFloat: () => AI4,
    limitedParseFloat32: () => BI4,
    loadConfigsForDefaultMode: () => RI4,
    logger: () => tn,
    map: () => $j1,
    parseBoolean: () => p74,
    parseEpochTimestamp: () => CI4,
    parseRfc3339DateTime: () => DI4,
    parseRfc3339DateTimeWithOffset: () => WI4,
    parseRfc7231DateTime: () => VI4,
    quoteHeader: () => taA,
    resolveDefaultRuntimeConfig: () => yI4,
    resolvedPath: () => Fj1.resolvedPath,
    serializeDateTime: () => uI4,
    serializeFloat: () => dI4,
    splitEvery: () => eaA,
    splitHeader: () => pI4,
    strictParseByte: () => laA,
    strictParseDouble: () => Ej1,
    strictParseFloat: () => o74,
    strictParseFloat32: () => uaA,
    strictParseInt: () => QI4,
    strictParseInt32: () => II4,
    strictParseLong: () => caA,
    strictParseShort: () => Cb,
    take: () => bI4,
    throwDefaultError: () => aaA,
    withBaseException: () => MI4
  });
  AsA.exports = g74(gaA);
  var haA = WN(),
    h74 = class {
      constructor(A) {
        this.config = A, this.middlewareStack = haA.constructStack()
      }
      static {
        r0(this, "Client")
      }
      send(A, B, Q) {
        let I = typeof B !== "function" ? B : void 0,
          G = typeof B === "function" ? B : Q,
          Z = I === void 0 && this.config.cacheMiddleware === !0,
          D;
        if (Z) {
          if (!this.handlers) this.handlers = new WeakMap;
          let Y = this.handlers;
          if (Y.has(A.constructor)) D = Y.get(A.constructor);
          else D = A.resolveMiddleware(this.middlewareStack, this.config, I), Y.set(A.constructor, D)
        } else delete this.handlers, D = A.resolveMiddleware(this.middlewareStack, this.config, I);
        if (G) D(A).then((Y) => G(null, Y.output), (Y) => G(Y)).catch(() => {});
        else return D(A).then((Y) => Y.output)
      }
      destroy() {
        this.config?.requestHandler?.destroy?.(), delete this.handlers
      }
    },
    Fj1 = vz(),
    Vj1 = s_1(),
    maA = class {
      constructor() {
        this.middlewareStack = haA.constructStack()
      }
      static {
        r0(this, "Command")
      }
      static classBuilder() {
        return new m74
      }
      resolveMiddlewareWithContext(A, B, Q, {
        middlewareFn: I,
        clientName: G,
        commandName: Z,
        inputFilterSensitiveLog: D,
        outputFilterSensitiveLog: Y,
        smithyContext: W,
        additionalContext: J,
        CommandCtor: F
      }) {
        for (let E of I.bind(this)(F, A, B, Q)) this.middlewareStack.use(E);
        let X = A.concat(this.middlewareStack),
          {
            logger: V
          } = B,
          C = {
            logger: V,
            clientName: G,
            commandName: Z,
            inputFilterSensitiveLog: D,
            outputFilterSensitiveLog: Y,
            [Vj1.SMITHY_CONTEXT_KEY]: {
              commandInstance: this,
              ...W
            },
            ...J
          },
          {
            requestHandler: K
          } = B;
        return X.resolve((E) => K.handle(E.request, Q || {}), C)
      }
    },
    m74 = class {
      constructor() {
        this._init = () => {}, this._ep = {}, this._middlewareFn = () => [], this._commandName = "", this._clientName = "", this._additionalContext = {}, this._smithyContext = {}, this._inputFilterSensitiveLog = (A) => A, this._outputFilterSensitiveLog = (A) => A, this._serializer = null, this._deserializer = null
      }
      static {
        r0(this, "ClassBuilder")
      }
      init(A) {
        this._init = A
      }
      ep(A) {
        return this._ep = A, this
      }
      m(A) {
        return this._middlewareFn = A, this
      }
      s(A, B, Q = {}) {
        return this._smithyContext = {
          service: A,
          operation: B,
          ...Q
        }, this
      }
      c(A = {}) {
        return this._additionalContext = A, this
      }
      n(A, B) {
        return this._clientName = A, this._commandName = B, this
      }
      f(A = (Q) => Q, B = (Q) => Q) {
        return this._inputFilterSensitiveLog = A, this._outputFilterSensitiveLog = B, this
      }
      ser(A) {
        return this._serializer = A, this
      }
      de(A) {
        return this._deserializer = A, this
      }
      build() {
        let A = this,
          B;
        return B = class extends maA {
          constructor(...[Q]) {
            super();
            this.serialize = A._serializer, this.deserialize = A._deserializer, this.input = Q ?? {}, A._init(this)
          }
          static {
            r0(this, "CommandRef")
          }
          static getEndpointParameterInstructions() {
            return A._ep
          }
          resolveMiddleware(Q, I, G) {
            return this.resolveMiddlewareWithContext(Q, I, G, {
              CommandCtor: B,
              middlewareFn: A._middlewareFn,
              clientName: A._clientName,
              commandName: A._commandName,
              inputFilterSensitiveLog: A._inputFilterSensitiveLog,
              outputFilterSensitiveLog: A._outputFilterSensitiveLog,
              smithyContext: A._smithyContext,
              additionalContext: A._additionalContext
            })
          }
        }
      }
    },
    d74 = "***SensitiveInformation***",
    u74 = r0((A, B) => {
      for (let Q of Object.keys(A)) {
        let I = A[Q],
          G = r0(async function(D, Y, W) {
            let J = new I(D);
            if (typeof Y === "function") this.send(J, Y);
            else if (typeof W === "function") {
              if (typeof Y !== "object") throw new Error(`Expected http options but got ${typeof Y}`);
              this.send(J, Y || {}, W)
            } else return this.send(J, Y)
          }, "methodImpl"),
          Z = (Q[0].toLowerCase() + Q.slice(1)).replace(/Command$/, "");
        B.prototype[Z] = G
      }
    }, "createAggregatedClient"),
    p74 = r0((A) => {
      switch (A) {
        case "true":
          return !0;
        case "false":
          return !1;
        default:
          throw new Error(`Unable to parse boolean value "${A}"`)
      }
    }, "parseBoolean"),
    c74 = r0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "number") {
        if (A === 0 || A === 1) tn.warn(Q71(`Expected boolean, got ${typeof A}: ${A}`));
        if (A === 0) return !1;
        if (A === 1) return !0
      }
      if (typeof A === "string") {
        let B = A.toLowerCase();
        if (B === "false" || B === "true") tn.warn(Q71(`Expected boolean, got ${typeof A}: ${A}`));
        if (B === "false") return !1;
        if (B === "true") return !0
      }
      if (typeof A === "boolean") return A;
      throw new TypeError(`Expected boolean, got ${typeof A}: ${A}`)
    }, "expectBoolean"),
    rn = r0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "string") {
        let B = parseFloat(A);
        if (!Number.isNaN(B)) {
          if (String(B) !== String(A)) tn.warn(Q71(`Expected number but observed string: ${A}`));
          return B
        }
      }
      if (typeof A === "number") return A;
      throw new TypeError(`Expected number, got ${typeof A}: ${A}`)
    }, "expectNumber"),
    l74 = Math.ceil(340282346638528860000000000000000000000),
    B71 = r0((A) => {
      let B = rn(A);
      if (B !== void 0 && !Number.isNaN(B) && B !== 1 / 0 && B !== -1 / 0) {
        if (Math.abs(B) > l74) throw new TypeError(`Expected 32-bit float, got ${A}`)
      }
      return B
    }, "expectFloat32"),
    on = r0((A) => {
      if (A === null || A === void 0) return;
      if (Number.isInteger(A) && !Number.isNaN(A)) return A;
      throw new TypeError(`Expected integer, got ${typeof A}: ${A}`)
    }, "expectLong"),
    i74 = on,
    Cj1 = r0((A) => wj1(A, 32), "expectInt32"),
    Kj1 = r0((A) => wj1(A, 16), "expectShort"),
    Hj1 = r0((A) => wj1(A, 8), "expectByte"),
    wj1 = r0((A, B) => {
      let Q = on(A);
      if (Q !== void 0 && n74(Q, B) !== Q) throw new TypeError(`Expected ${B}-bit integer, got ${A}`);
      return Q
    }, "expectSizedInt"),
    n74 = r0((A, B) => {
      switch (B) {
        case 32:
          return Int32Array.of(A)[0];
        case 16:
          return Int16Array.of(A)[0];
        case 8:
          return Int8Array.of(A)[0]
      }
    }, "castInt"),
    a74 = r0((A, B) => {
      if (A === null || A === void 0) {
        if (B) throw new TypeError(`Expected a non-null value for ${B}`);
        throw new TypeError("Expected a non-null value")
      }
      return A
    }, "expectNonNull"),
    daA = r0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "object" && !Array.isArray(A)) return A;
      let B = Array.isArray(A) ? "array" : typeof A;
      throw new TypeError(`Expected object, got ${B}: ${A}`)
    }, "expectObject"),
    s74 = r0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "string") return A;
      if (["boolean", "number", "bigint"].includes(typeof A)) return tn.warn(Q71(`Expected string, got ${typeof A}: ${A}`)), String(A);
      throw new TypeError(`Expected string, got ${typeof A}: ${A}`)
    }, "expectString"),
    r74 = r0((A) => {
      if (A === null || A === void 0) return;
      let B = daA(A),
        Q = Object.entries(B).filter(([, I]) => I != null).map(([I]) => I);
      if (Q.length === 0) throw new TypeError("Unions must have exactly one non-null member. None were found.");
      if (Q.length > 1) throw new TypeError(`Unions must have exactly one non-null member. Keys ${Q} were not null.`);
      return B
    }, "expectUnion"),
    Ej1 = r0((A) => {
      if (typeof A == "string") return rn(Hb(A));
      return rn(A)
    }, "strictParseDouble"),
    o74 = Ej1,
    uaA = r0((A) => {
      if (typeof A == "string") return B71(Hb(A));
      return B71(A)
    }, "strictParseFloat32"),
    t74 = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g,
    Hb = r0((A) => {
      let B = A.match(t74);
      if (B === null || B[0].length !== A.length) throw new TypeError("Expected real number, got implicit NaN");
      return parseFloat(A)
    }, "parseNumber"),
    Uj1 = r0((A) => {
      if (typeof A == "string") return paA(A);
      return rn(A)
    }, "limitedParseDouble"),
    e74 = Uj1,
    AI4 = Uj1,
    BI4 = r0((A) => {
      if (typeof A == "string") return paA(A);
      return B71(A)
    }, "limitedParseFloat32"),
    paA = r0((A) => {
      switch (A) {
        case "NaN":
          return NaN;
        case "Infinity":
          return 1 / 0;
        case "-Infinity":
          return -1 / 0;
        default:
          throw new Error(`Unable to parse float value: ${A}`)
      }
    }, "parseFloatString"),
    caA = r0((A) => {
      if (typeof A === "string") return on(Hb(A));
      return on(A)
    }, "strictParseLong"),
    QI4 = caA,
    II4 = r0((A) => {
      if (typeof A === "string") return Cj1(Hb(A));
      return Cj1(A)
    }, "strictParseInt32"),
    Cb = r0((A) => {
      if (typeof A === "string") return Kj1(Hb(A));
      return Kj1(A)
    }, "strictParseShort"),
    laA = r0((A) => {
      if (typeof A === "string") return Hj1(Hb(A));
      return Hj1(A)
    }, "strictParseByte"),
    Q71 = r0((A) => {
      return String(new TypeError(A).stack || A).split(`
`).slice(0, 5).filter((B) => !B.includes("stackTraceWarning")).join(`
`)
    }, "stackTraceWarning"),
    tn = {
      warn: console.warn
    },
    GI4 = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
    Nj1 = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];

  function iaA(A) {
    let B = A.getUTCFullYear(),
      Q = A.getUTCMonth(),
      I = A.getUTCDay(),
      G = A.getUTCDate(),
      Z = A.getUTCHours(),
      D = A.getUTCMinutes(),
      Y = A.getUTCSeconds(),
      W = G < 10 ? `0${G}` : `${G}`,
      J = Z < 10 ? `0${Z}` : `${Z}`,
      F = D < 10 ? `0${D}` : `${D}`,
      X = Y < 10 ? `0${Y}` : `${Y}`;
    return `${GI4[I]}, ${W} ${Nj1[Q]} ${B} ${J}:${F}:${X} GMT`
  }
  r0(iaA, "dateToUtcString");
  var ZI4 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/),
    DI4 = r0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-3339 date-times must be expressed as strings");
      let B = ZI4.exec(A);
      if (!B) throw new TypeError("Invalid RFC-3339 date-time value");
      let [Q, I, G, Z, D, Y, W, J] = B, F = Cb(Kb(I)), X = bz(G, "month", 1, 12), V = bz(Z, "day", 1, 31);
      return sn(F, X, V, {
        hours: D,
        minutes: Y,
        seconds: W,
        fractionalMilliseconds: J
      })
    }, "parseRfc3339DateTime"),
    YI4 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/),
    WI4 = r0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-3339 date-times must be expressed as strings");
      let B = YI4.exec(A);
      if (!B) throw new TypeError("Invalid RFC-3339 date-time value");
      let [Q, I, G, Z, D, Y, W, J, F] = B, X = Cb(Kb(I)), V = bz(G, "month", 1, 12), C = bz(Z, "day", 1, 31), K = sn(X, V, C, {
        hours: D,
        minutes: Y,
        seconds: W,
        fractionalMilliseconds: J
      });
      if (F.toUpperCase() != "Z") K.setTime(K.getTime() - $I4(F));
      return K
    }, "parseRfc3339DateTimeWithOffset"),
    JI4 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/),
    FI4 = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/),
    XI4 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/),
    VI4 = r0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-7231 date-times must be expressed as strings");
      let B = JI4.exec(A);
      if (B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return sn(Cb(Kb(Z)), Xj1(G), bz(I, "day", 1, 31), {
          hours: D,
          minutes: Y,
          seconds: W,
          fractionalMilliseconds: J
        })
      }
      if (B = FI4.exec(A), B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return zI4(sn(KI4(Z), Xj1(G), bz(I, "day", 1, 31), {
          hours: D,
          minutes: Y,
          seconds: W,
          fractionalMilliseconds: J
        }))
      }
      if (B = XI4.exec(A), B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return sn(Cb(Kb(J)), Xj1(I), bz(G.trimLeft(), "day", 1, 31), {
          hours: Z,
          minutes: D,
          seconds: Y,
          fractionalMilliseconds: W
        })
      }
      throw new TypeError("Invalid RFC-7231 date-time value")
    }, "parseRfc7231DateTime"),
    CI4 = r0((A) => {
      if (A === null || A === void 0) return;
      let B;
      if (typeof A === "number") B = A;
      else if (typeof A === "string") B = Ej1(A);
      else if (typeof A === "object" && A.tag === 1) B = A.value;
      else throw new TypeError("Epoch timestamps must be expressed as floating point numbers or their string representation");
      if (Number.isNaN(B) || B === 1 / 0 || B === -1 / 0) throw new TypeError("Epoch timestamps must be valid, non-Infinite, non-NaN numerics");
      return new Date(Math.round(B * 1000))
    }, "parseEpochTimestamp"),
    sn = r0((A, B, Q, I) => {
      let G = B - 1;
      return EI4(A, G, Q), new Date(Date.UTC(A, G, Q, bz(I.hours, "hour", 0, 23), bz(I.minutes, "minute", 0, 59), bz(I.seconds, "seconds", 0, 60), NI4(I.fractionalMilliseconds)))
    }, "buildDate"),
    KI4 = r0((A) => {
      let B = new Date().getUTCFullYear(),
        Q = Math.floor(B / 100) * 100 + Cb(Kb(A));
      if (Q < B) return Q + 100;
      return Q
    }, "parseTwoDigitYear"),
    HI4 = 1576800000000,
    zI4 = r0((A) => {
      if (A.getTime() - new Date().getTime() > HI4) return new Date(Date.UTC(A.getUTCFullYear() - 100, A.getUTCMonth(), A.getUTCDate(), A.getUTCHours(), A.getUTCMinutes(), A.getUTCSeconds(), A.getUTCMilliseconds()));
      return A
    }, "adjustRfc850Year"),
    Xj1 = r0((A) => {
      let B = Nj1.indexOf(A);
      if (B < 0) throw new TypeError(`Invalid month: ${A}`);
      return B + 1
    }, "parseMonthByShortName"),
    wI4 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
    EI4 = r0((A, B, Q) => {
      let I = wI4[B];
      if (B === 1 && UI4(A)) I = 29;
      if (Q > I) throw new TypeError(`Invalid day for ${Nj1[B]} in ${A}: ${Q}`)
    }, "validateDayOfMonth"),
    UI4 = r0((A) => {
      return A % 4 === 0 && (A % 100 !== 0 || A % 400 === 0)
    }, "isLeapYear"),
    bz = r0((A, B, Q, I) => {
      let G = laA(Kb(A));
      if (G < Q || G > I) throw new TypeError(`${B} must be between ${Q} and ${I}, inclusive`);
      return G
    }, "parseDateValue"),
    NI4 = r0((A) => {
      if (A === null || A === void 0) return 0;
      return uaA("0." + A) * 1000
    }, "parseMilliseconds"),
    $I4 = r0((A) => {
      let B = A[0],
        Q = 1;
      if (B == "+") Q = 1;
      else if (B == "-") Q = -1;
      else throw new TypeError(`Offset direction, ${B}, must be "+" or "-"`);
      let I = Number(A.substring(1, 3)),
        G = Number(A.substring(4, 6));
      return Q * (I * 60 + G) * 60 * 1000
    }, "parseOffsetToMilliseconds"),
    Kb = r0((A) => {
      let B = 0;
      while (B < A.length - 1 && A.charAt(B) === "0") B++;
      if (B === 0) return A;
      return A.slice(B)
    }, "stripLeadingZeroes"),
    qI4 = class A extends Error {
      static {
        r0(this, "ServiceException")
      }
      constructor(B) {
        super(B.message);
        Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype), this.name = B.name, this.$fault = B.$fault, this.$metadata = B.$metadata
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return A.prototype.isPrototypeOf(Q) || Boolean(Q.$fault) && Boolean(Q.$metadata) && (Q.$fault === "client" || Q.$fault === "server")
      }
      static[Symbol.hasInstance](B) {
        if (!B) return !1;
        let Q = B;
        if (this === A) return A.isInstance(B);
        if (A.isInstance(B)) {
          if (Q.name && this.name) return this.prototype.isPrototypeOf(B) || Q.name === this.name;
          return this.prototype.isPrototypeOf(B)
        }
        return !1
      }
    },
    naA = r0((A, B = {}) => {
      Object.entries(B).filter(([, I]) => I !== void 0).forEach(([I, G]) => {
        if (A[I] == null || A[I] === "") A[I] = G
      });
      let Q = A.message || A.Message || "UnknownError";
      return A.message = Q, delete A.Message, A
    }, "decorateServiceException"),
    aaA = r0(({
      output: A,
      parsedBody: B,
      exceptionCtor: Q,
      errorCode: I
    }) => {
      let G = LI4(A),
        Z = G.httpStatusCode ? G.httpStatusCode + "" : void 0,
        D = new Q({
          name: B?.code || B?.Code || I || Z || "UnknownError",
          $fault: "client",
          $metadata: G
        });
      throw naA(D, B)
    }, "throwDefaultError"),
    MI4 = r0((A) => {
      return ({
        output: B,
        parsedBody: Q,
        errorCode: I
      }) => {
        aaA({
          output: B,
          parsedBody: Q,
          exceptionCtor: A,
          errorCode: I
        })
      }
    }, "withBaseException"),
    LI4 = r0((A) => ({
      httpStatusCode: A.statusCode,
      requestId: A.headers["x-amzn-requestid"] ?? A.headers["x-amzn-request-id"] ?? A.headers["x-amz-request-id"],
      extendedRequestId: A.headers["x-amz-id-2"],
      cfId: A.headers["x-amz-cf-id"]
    }), "deserializeMetadata"),
    RI4 = r0((A) => {
      switch (A) {
        case "standard":
          return {
            retryMode: "standard", connectionTimeout: 3100
          };
        case "in-region":
          return {
            retryMode: "standard", connectionTimeout: 1100
          };
        case "cross-region":
          return {
            retryMode: "standard", connectionTimeout: 3100
          };
        case "mobile":
          return {
            retryMode: "standard", connectionTimeout: 30000
          };
        default:
          return {}
      }
    }, "loadConfigsForDefaultMode"),
    baA = !1,
    OI4 = r0((A) => {
      if (A && !baA && parseInt(A.substring(1, A.indexOf("."))) < 16) baA = !0
    }, "emitWarningIfUnsupportedVersion"),
    TI4 = r0((A) => {
      let B = [];
      for (let Q in Vj1.AlgorithmId) {
        let I = Vj1.AlgorithmId[Q];
        if (A[I] === void 0) continue;
        B.push({
          algorithmId: () => I,
          checksumConstructor: () => A[I]
        })
      }
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    PI4 = r0((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    SI4 = r0((A) => {
      return {
        setRetryStrategy(B) {
          A.retryStrategy = B
        },
        retryStrategy() {
          return A.retryStrategy
        }
      }
    }, "getRetryConfiguration"),
    _I4 = r0((A) => {
      let B = {};
      return B.retryStrategy = A.retryStrategy(), B
    }, "resolveRetryRuntimeConfig"),
    saA = r0((A) => {
      return Object.assign(TI4(A), SI4(A))
    }, "getDefaultExtensionConfiguration"),
    jI4 = saA,
    yI4 = r0((A) => {
      return Object.assign(PI4(A), _I4(A))
    }, "resolveDefaultRuntimeConfig"),
    kI4 = r0((A) => Array.isArray(A) ? A : [A], "getArrayIfSingleItem"),
    raA = r0((A) => {
      for (let Q in A)
        if (A.hasOwnProperty(Q) && A[Q]["#text"] !== void 0) A[Q] = A[Q]["#text"];
        else if (typeof A[Q] === "object" && A[Q] !== null) A[Q] = raA(A[Q]);
      return A
    }, "getValueFromTextNode"),
    xI4 = r0((A) => {
      return A != null
    }, "isSerializableHeaderValue"),
    rS = r0(function A(B) {
      return Object.assign(new String(B), {
        deserializeJSON() {
          return JSON.parse(String(B))
        },
        toString() {
          return String(B)
        },
        toJSON() {
          return String(B)
        }
      })
    }, "LazyJsonString");
  rS.from = (A) => {
    if (A && typeof A === "object" && (A instanceof rS || ("deserializeJSON" in A))) return A;
    else if (typeof A === "string" || Object.getPrototypeOf(A) === String.prototype) return rS(String(A));
    return rS(JSON.stringify(A))
  };
  rS.fromObject = rS.from;
  var fI4 = class {
    static {
      r0(this, "NoOpLogger")
    }
    trace() {}
    debug() {}
    info() {}
    warn() {}
    error() {}
  };

  function $j1(A, B, Q) {
    let I, G, Z;
    if (typeof B === "undefined" && typeof Q === "undefined") I = {}, Z = A;
    else if (I = A, typeof B === "function") return G = B, Z = Q, gI4(I, G, Z);
    else Z = B;
    for (let D of Object.keys(Z)) {
      if (!Array.isArray(Z[D])) {
        I[D] = Z[D];
        continue
      }
      oaA(I, null, Z, D)
    }
    return I
  }
  r0($j1, "map");
  var vI4 = r0((A) => {
      let B = {};
      for (let [Q, I] of Object.entries(A || {})) B[Q] = [, I];
      return B
    }, "convertMap"),
    bI4 = r0((A, B) => {
      let Q = {};
      for (let I in B) oaA(Q, A, B, I);
      return Q
    }, "take"),
    gI4 = r0((A, B, Q) => {
      return $j1(A, Object.entries(Q).reduce((I, [G, Z]) => {
        if (Array.isArray(Z)) I[G] = Z;
        else if (typeof Z === "function") I[G] = [B, Z()];
        else I[G] = [B, Z];
        return I
      }, {}))
    }, "mapWithFilter"),
    oaA = r0((A, B, Q, I) => {
      if (B !== null) {
        let D = Q[I];
        if (typeof D === "function") D = [, D];
        let [Y = hI4, W = mI4, J = I] = D;
        if (typeof Y === "function" && Y(B[J]) || typeof Y !== "function" && !!Y) A[I] = W(B[J]);
        return
      }
      let [G, Z] = Q[I];
      if (typeof Z === "function") {
        let D, Y = G === void 0 && (D = Z()) != null,
          W = typeof G === "function" && !!G(void 0) || typeof G !== "function" && !!G;
        if (Y) A[I] = D;
        else if (W) A[I] = Z()
      } else {
        let D = G === void 0 && Z != null,
          Y = typeof G === "function" && !!G(Z) || typeof G !== "function" && !!G;
        if (D || Y) A[I] = Z
      }
    }, "applyInstruction"),
    hI4 = r0((A) => A != null, "nonNullish"),
    mI4 = r0((A) => A, "pass");

  function taA(A) {
    if (A.includes(",") || A.includes('"')) A = `"${A.replace(/"/g,"\\\"")}"`;
    return A
  }
  r0(taA, "quoteHeader");
  var dI4 = r0((A) => {
      if (A !== A) return "NaN";
      switch (A) {
        case 1 / 0:
          return "Infinity";
        case -1 / 0:
          return "-Infinity";
        default:
          return A
      }
    }, "serializeFloat"),
    uI4 = r0((A) => A.toISOString().replace(".000Z", "Z"), "serializeDateTime"),
    zj1 = r0((A) => {
      if (A == null) return {};
      if (Array.isArray(A)) return A.filter((B) => B != null).map(zj1);
      if (typeof A === "object") {
        let B = {};
        for (let Q of Object.keys(A)) {
          if (A[Q] == null) continue;
          B[Q] = zj1(A[Q])
        }
        return B
      }
      return A
    }, "_json");

  function eaA(A, B, Q) {
    if (Q <= 0 || !Number.isInteger(Q)) throw new Error("Invalid number of delimiters (" + Q + ") for splitEvery.");
    let I = A.split(B);
    if (Q === 1) return I;
    let G = [],
      Z = "";
    for (let D = 0; D < I.length; D++) {
      if (Z === "") Z = I[D];
      else Z += B + I[D];
      if ((D + 1) % Q === 0) G.push(Z), Z = ""
    }
    if (Z !== "") G.push(Z);
    return G
  }
  r0(eaA, "splitEvery");
  var pI4 = r0((A) => {
    let B = A.length,
      Q = [],
      I = !1,
      G = void 0,
      Z = 0;
    for (let D = 0; D < B; ++D) {
      let Y = A[D];
      switch (Y) {
        case '"':
          if (G !== "\\") I = !I;
          break;
        case ",":
          if (!I) Q.push(A.slice(Z, D)), Z = D + 1;
          break;
        default:
      }
      G = Y
    }
    return Q.push(A.slice(Z)), Q.map((D) => {
      D = D.trim();
      let Y = D.length;
      if (Y < 2) return D;
      if (D[0] === '"' && D[Y - 1] === '"') D = D.slice(1, Y - 1);
      return D.replace(/\\"/g, '"')
    })
  }, "splitHeader")
})
// @from(Start 3275790, End 3277228)
Z71 = z((aI4) => {
  var cI4 = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040",
    BsA = "[:A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][" + cI4 + "]*",
    lI4 = new RegExp("^" + BsA + "$"),
    iI4 = function(A, B) {
      let Q = [],
        I = B.exec(A);
      while (I) {
        let G = [];
        G.startIndex = B.lastIndex - I[0].length;
        let Z = I.length;
        for (let D = 0; D < Z; D++) G.push(I[D]);
        Q.push(G), I = B.exec(A)
      }
      return Q
    },
    nI4 = function(A) {
      let B = lI4.exec(A);
      return !(B === null || typeof B === "undefined")
    };
  aI4.isExist = function(A) {
    return typeof A !== "undefined"
  };
  aI4.isEmptyObject = function(A) {
    return Object.keys(A).length === 0
  };
  aI4.merge = function(A, B, Q) {
    if (B) {
      let I = Object.keys(B),
        G = I.length;
      for (let Z = 0; Z < G; Z++)
        if (Q === "strict") A[I[Z]] = [B[I[Z]]];
        else A[I[Z]] = B[I[Z]]
    }
  };
  aI4.getValue = function(A) {
    if (aI4.isExist(A)) return A;
    else return ""
  };
  aI4.isName = nI4;
  aI4.getAllMatches = iI4;
  aI4.nameRegexp = BsA
})
// @from(Start 3277234, End 3284710)
Mj1 = z((FG4) => {
  var qj1 = Z71(),
    BG4 = {
      allowBooleanAttributes: !1,
      unpairedTags: []
    };
  FG4.validate = function(A, B) {
    B = Object.assign({}, BG4, B);
    let Q = [],
      I = !1,
      G = !1;
    if (A[0] === "\uFEFF") A = A.substr(1);
    for (let Z = 0; Z < A.length; Z++)
      if (A[Z] === "<" && A[Z + 1] === "?") {
        if (Z += 2, Z = GsA(A, Z), Z.err) return Z
      } else if (A[Z] === "<") {
      let D = Z;
      if (Z++, A[Z] === "!") {
        Z = ZsA(A, Z);
        continue
      } else {
        let Y = !1;
        if (A[Z] === "/") Y = !0, Z++;
        let W = "";
        for (; Z < A.length && A[Z] !== ">" && A[Z] !== " " && A[Z] !== "\t" && A[Z] !== `
` && A[Z] !== "\r"; Z++) W += A[Z];
        if (W = W.trim(), W[W.length - 1] === "/") W = W.substring(0, W.length - 1), Z--;
        if (!JG4(W)) {
          let X;
          if (W.trim().length === 0) X = "Invalid space after '<'.";
          else X = "Tag '" + W + "' is an invalid name.";
          return OQ("InvalidTag", X, SD(A, Z))
        }
        let J = GG4(A, Z);
        if (J === !1) return OQ("InvalidAttr", "Attributes for '" + W + "' have open quote.", SD(A, Z));
        let F = J.value;
        if (Z = J.index, F[F.length - 1] === "/") {
          let X = Z - F.length;
          F = F.substring(0, F.length - 1);
          let V = DsA(F, B);
          if (V === !0) I = !0;
          else return OQ(V.err.code, V.err.msg, SD(A, X + V.err.line))
        } else if (Y)
          if (!J.tagClosed) return OQ("InvalidTag", "Closing tag '" + W + "' doesn't have proper closing.", SD(A, Z));
          else if (F.trim().length > 0) return OQ("InvalidTag", "Closing tag '" + W + "' can't have attributes or invalid starting.", SD(A, D));
        else if (Q.length === 0) return OQ("InvalidTag", "Closing tag '" + W + "' has not been opened.", SD(A, D));
        else {
          let X = Q.pop();
          if (W !== X.tagName) {
            let V = SD(A, X.tagStartPos);
            return OQ("InvalidTag", "Expected closing tag '" + X.tagName + "' (opened in line " + V.line + ", col " + V.col + ") instead of closing tag '" + W + "'.", SD(A, D))
          }
          if (Q.length == 0) G = !0
        } else {
          let X = DsA(F, B);
          if (X !== !0) return OQ(X.err.code, X.err.msg, SD(A, Z - F.length + X.err.line));
          if (G === !0) return OQ("InvalidXml", "Multiple possible root nodes found.", SD(A, Z));
          else if (B.unpairedTags.indexOf(W) !== -1);
          else Q.push({
            tagName: W,
            tagStartPos: D
          });
          I = !0
        }
        for (Z++; Z < A.length; Z++)
          if (A[Z] === "<")
            if (A[Z + 1] === "!") {
              Z++, Z = ZsA(A, Z);
              continue
            } else if (A[Z + 1] === "?") {
          if (Z = GsA(A, ++Z), Z.err) return Z
        } else break;
        else if (A[Z] === "&") {
          let X = YG4(A, Z);
          if (X == -1) return OQ("InvalidChar", "char '&' is not expected.", SD(A, Z));
          Z = X
        } else if (G === !0 && !IsA(A[Z])) return OQ("InvalidXml", "Extra text at the end", SD(A, Z));
        if (A[Z] === "<") Z--
      }
    } else {
      if (IsA(A[Z])) continue;
      return OQ("InvalidChar", "char '" + A[Z] + "' is not expected.", SD(A, Z))
    }
    if (!I) return OQ("InvalidXml", "Start tag expected.", 1);
    else if (Q.length == 1) return OQ("InvalidTag", "Unclosed tag '" + Q[0].tagName + "'.", SD(A, Q[0].tagStartPos));
    else if (Q.length > 0) return OQ("InvalidXml", "Invalid '" + JSON.stringify(Q.map((Z) => Z.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", {
      line: 1,
      col: 1
    });
    return !0
  };

  function IsA(A) {
    return A === " " || A === "\t" || A === `
` || A === "\r"
  }

  function GsA(A, B) {
    let Q = B;
    for (; B < A.length; B++)
      if (A[B] == "?" || A[B] == " ") {
        let I = A.substr(Q, B - Q);
        if (B > 5 && I === "xml") return OQ("InvalidXml", "XML declaration allowed only at the start of the document.", SD(A, B));
        else if (A[B] == "?" && A[B + 1] == ">") {
          B++;
          break
        } else continue
      } return B
  }

  function ZsA(A, B) {
    if (A.length > B + 5 && A[B + 1] === "-" && A[B + 2] === "-") {
      for (B += 3; B < A.length; B++)
        if (A[B] === "-" && A[B + 1] === "-" && A[B + 2] === ">") {
          B += 2;
          break
        }
    } else if (A.length > B + 8 && A[B + 1] === "D" && A[B + 2] === "O" && A[B + 3] === "C" && A[B + 4] === "T" && A[B + 5] === "Y" && A[B + 6] === "P" && A[B + 7] === "E") {
      let Q = 1;
      for (B += 8; B < A.length; B++)
        if (A[B] === "<") Q++;
        else if (A[B] === ">") {
        if (Q--, Q === 0) break
      }
    } else if (A.length > B + 9 && A[B + 1] === "[" && A[B + 2] === "C" && A[B + 3] === "D" && A[B + 4] === "A" && A[B + 5] === "T" && A[B + 6] === "A" && A[B + 7] === "[") {
      for (B += 8; B < A.length; B++)
        if (A[B] === "]" && A[B + 1] === "]" && A[B + 2] === ">") {
          B += 2;
          break
        }
    }
    return B
  }
  var QG4 = '"',
    IG4 = "'";

  function GG4(A, B) {
    let Q = "",
      I = "",
      G = !1;
    for (; B < A.length; B++) {
      if (A[B] === QG4 || A[B] === IG4)
        if (I === "") I = A[B];
        else if (I !== A[B]);
      else I = "";
      else if (A[B] === ">") {
        if (I === "") {
          G = !0;
          break
        }
      }
      Q += A[B]
    }
    if (I !== "") return !1;
    return {
      value: Q,
      index: B,
      tagClosed: G
    }
  }
  var ZG4 = new RegExp(`(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['"])(([\\s\\S])*?)\\5)?`, "g");

  function DsA(A, B) {
    let Q = qj1.getAllMatches(A, ZG4),
      I = {};
    for (let G = 0; G < Q.length; G++) {
      if (Q[G][1].length === 0) return OQ("InvalidAttr", "Attribute '" + Q[G][2] + "' has no space in starting.", en(Q[G]));
      else if (Q[G][3] !== void 0 && Q[G][4] === void 0) return OQ("InvalidAttr", "Attribute '" + Q[G][2] + "' is without value.", en(Q[G]));
      else if (Q[G][3] === void 0 && !B.allowBooleanAttributes) return OQ("InvalidAttr", "boolean attribute '" + Q[G][2] + "' is not allowed.", en(Q[G]));
      let Z = Q[G][2];
      if (!WG4(Z)) return OQ("InvalidAttr", "Attribute '" + Z + "' is an invalid name.", en(Q[G]));
      if (!I.hasOwnProperty(Z)) I[Z] = 1;
      else return OQ("InvalidAttr", "Attribute '" + Z + "' is repeated.", en(Q[G]))
    }
    return !0
  }

  function DG4(A, B) {
    let Q = /\d/;
    if (A[B] === "x") B++, Q = /[\da-fA-F]/;
    for (; B < A.length; B++) {
      if (A[B] === ";") return B;
      if (!A[B].match(Q)) break
    }
    return -1
  }

  function YG4(A, B) {
    if (B++, A[B] === ";") return -1;
    if (A[B] === "#") return B++, DG4(A, B);
    let Q = 0;
    for (; B < A.length; B++, Q++) {
      if (A[B].match(/\w/) && Q < 20) continue;
      if (A[B] === ";") break;
      return -1
    }
    return B
  }

  function OQ(A, B, Q) {
    return {
      err: {
        code: A,
        msg: B,
        line: Q.line || Q,
        col: Q.col
      }
    }
  }

  function WG4(A) {
    return qj1.isName(A)
  }

  function JG4(A) {
    return qj1.isName(A)
  }

  function SD(A, B) {
    let Q = A.substring(0, B).split(/\r?\n/);
    return {
      line: Q.length,
      col: Q[Q.length - 1].length + 1
    }
  }

  function en(A) {
    return A.startIndex + A[1].length
  }
})
// @from(Start 3284716, End 3285791)
WsA = z((CG4) => {
  var YsA = {
      preserveOrder: !1,
      attributeNamePrefix: "@_",
      attributesGroupName: !1,
      textNodeName: "#text",
      ignoreAttributes: !0,
      removeNSPrefix: !1,
      allowBooleanAttributes: !1,
      parseTagValue: !0,
      parseAttributeValue: !1,
      trimValues: !0,
      cdataPropName: !1,
      numberParseOptions: {
        hex: !0,
        leadingZeros: !0,
        eNotation: !0
      },
      tagValueProcessor: function(A, B) {
        return B
      },
      attributeValueProcessor: function(A, B) {
        return B
      },
      stopNodes: [],
      alwaysCreateTextNode: !1,
      isArray: () => !1,
      commentPropName: !1,
      unpairedTags: [],
      processEntities: !0,
      htmlEntities: !1,
      ignoreDeclaration: !1,
      ignorePiTags: !1,
      transformTagName: !1,
      transformAttributeName: !1,
      updateTag: function(A, B, Q) {
        return A
      }
    },
    VG4 = function(A) {
      return Object.assign({}, YsA, A)
    };
  CG4.buildOptions = VG4;
  CG4.defaultOptions = YsA
})
// @from(Start 3285797, End 3286352)
XsA = z((H78, FsA) => {
  class JsA {
    constructor(A) {
      this.tagname = A, this.child = [], this[":@"] = {}
    }
    add(A, B) {
      if (A === "__proto__") A = "#__proto__";
      this.child.push({
        [A]: B
      })
    }
    addChild(A) {
      if (A.tagname === "__proto__") A.tagname = "#__proto__";
      if (A[":@"] && Object.keys(A[":@"]).length > 0) this.child.push({
        [A.tagname]: A.child,
        [":@"]: A[":@"]
      });
      else this.child.push({
        [A.tagname]: A.child
      })
    }
  }
  FsA.exports = JsA
})
// @from(Start 3286358, End 3289030)
CsA = z((z78, VsA) => {
  var zG4 = Z71();

  function wG4(A, B) {
    let Q = {};
    if (A[B + 3] === "O" && A[B + 4] === "C" && A[B + 5] === "T" && A[B + 6] === "Y" && A[B + 7] === "P" && A[B + 8] === "E") {
      B = B + 9;
      let I = 1,
        G = !1,
        Z = !1,
        D = "";
      for (; B < A.length; B++)
        if (A[B] === "<" && !Z) {
          if (G && NG4(A, B)) {
            if (B += 7, [entityName, val, B] = EG4(A, B + 1), val.indexOf("&") === -1) Q[LG4(entityName)] = {
              regx: RegExp(`&${entityName};`, "g"),
              val
            }
          } else if (G && $G4(A, B)) B += 8;
          else if (G && qG4(A, B)) B += 8;
          else if (G && MG4(A, B)) B += 9;
          else if (UG4) Z = !0;
          else throw new Error("Invalid DOCTYPE");
          I++, D = ""
        } else if (A[B] === ">") {
        if (Z) {
          if (A[B - 1] === "-" && A[B - 2] === "-") Z = !1, I--
        } else I--;
        if (I === 0) break
      } else if (A[B] === "[") G = !0;
      else D += A[B];
      if (I !== 0) throw new Error("Unclosed DOCTYPE")
    } else throw new Error("Invalid Tag instead of DOCTYPE");
    return {
      entities: Q,
      i: B
    }
  }

  function EG4(A, B) {
    let Q = "";
    for (; B < A.length && (A[B] !== "'" && A[B] !== '"'); B++) Q += A[B];
    if (Q = Q.trim(), Q.indexOf(" ") !== -1) throw new Error("External entites are not supported");
    let I = A[B++],
      G = "";
    for (; B < A.length && A[B] !== I; B++) G += A[B];
    return [Q, G, B]
  }

  function UG4(A, B) {
    if (A[B + 1] === "!" && A[B + 2] === "-" && A[B + 3] === "-") return !0;
    return !1
  }

  function NG4(A, B) {
    if (A[B + 1] === "!" && A[B + 2] === "E" && A[B + 3] === "N" && A[B + 4] === "T" && A[B + 5] === "I" && A[B + 6] === "T" && A[B + 7] === "Y") return !0;
    return !1
  }

  function $G4(A, B) {
    if (A[B + 1] === "!" && A[B + 2] === "E" && A[B + 3] === "L" && A[B + 4] === "E" && A[B + 5] === "M" && A[B + 6] === "E" && A[B + 7] === "N" && A[B + 8] === "T") return !0;
    return !1
  }

  function qG4(A, B) {
    if (A[B + 1] === "!" && A[B + 2] === "A" && A[B + 3] === "T" && A[B + 4] === "T" && A[B + 5] === "L" && A[B + 6] === "I" && A[B + 7] === "S" && A[B + 8] === "T") return !0;
    return !1
  }

  function MG4(A, B) {
    if (A[B + 1] === "!" && A[B + 2] === "N" && A[B + 3] === "O" && A[B + 4] === "T" && A[B + 5] === "A" && A[B + 6] === "T" && A[B + 7] === "I" && A[B + 8] === "O" && A[B + 9] === "N") return !0;
    return !1
  }

  function LG4(A) {
    if (zG4.isName(A)) return A;
    else throw new Error(`Invalid entity name ${A}`)
  }
  VsA.exports = wG4
})
// @from(Start 3289036, End 3291020)
HsA = z((w78, KsA) => {
  var RG4 = /^[-+]?0x[a-fA-F0-9]+$/,
    OG4 = /^([\-\+])?(0*)(\.[0-9]+([eE]\-?[0-9]+)?|[0-9]+(\.[0-9]+([eE]\-?[0-9]+)?)?)$/;
  if (!Number.parseInt && window.parseInt) Number.parseInt = window.parseInt;
  if (!Number.parseFloat && window.parseFloat) Number.parseFloat = window.parseFloat;
  var TG4 = {
    hex: !0,
    leadingZeros: !0,
    decimalPoint: ".",
    eNotation: !0
  };

  function PG4(A, B = {}) {
    if (B = Object.assign({}, TG4, B), !A || typeof A !== "string") return A;
    let Q = A.trim();
    if (B.skipLike !== void 0 && B.skipLike.test(Q)) return A;
    else if (B.hex && RG4.test(Q)) return Number.parseInt(Q, 16);
    else {
      let I = OG4.exec(Q);
      if (I) {
        let G = I[1],
          Z = I[2],
          D = SG4(I[3]),
          Y = I[4] || I[6];
        if (!B.leadingZeros && Z.length > 0 && G && Q[2] !== ".") return A;
        else if (!B.leadingZeros && Z.length > 0 && !G && Q[1] !== ".") return A;
        else {
          let W = Number(Q),
            J = "" + W;
          if (J.search(/[eE]/) !== -1)
            if (B.eNotation) return W;
            else return A;
          else if (Y)
            if (B.eNotation) return W;
            else return A;
          else if (Q.indexOf(".") !== -1)
            if (J === "0" && D === "") return W;
            else if (J === D) return W;
          else if (G && J === "-" + D) return W;
          else return A;
          if (Z)
            if (D === J) return W;
            else if (G + D === J) return W;
          else return A;
          if (Q === J) return W;
          else if (Q === G + J) return W;
          return A
        }
      } else return A
    }
  }

  function SG4(A) {
    if (A && A.indexOf(".") !== -1) {
      if (A = A.replace(/0+$/, ""), A === ".") A = "0";
      else if (A[0] === ".") A = "0" + A;
      else if (A[A.length - 1] === ".") A = A.substr(0, A.length - 1);
      return A
    }
    return A
  }
  KsA.exports = PG4
})
// @from(Start 3291026, End 3303560)
UsA = z((E78, EsA) => {
  var zsA = Z71(),
    Aa = XsA(),
    _G4 = CsA(),
    jG4 = HsA();
  class wsA {
    constructor(A) {
      this.options = A, this.currentNode = null, this.tagsNodeStack = [], this.docTypeEntities = {}, this.lastEntities = {
        apos: {
          regex: /&(apos|#39|#x27);/g,
          val: "'"
        },
        gt: {
          regex: /&(gt|#62|#x3E);/g,
          val: ">"
        },
        lt: {
          regex: /&(lt|#60|#x3C);/g,
          val: "<"
        },
        quot: {
          regex: /&(quot|#34|#x22);/g,
          val: '"'
        }
      }, this.ampEntity = {
        regex: /&(amp|#38|#x26);/g,
        val: "&"
      }, this.htmlEntities = {
        space: {
          regex: /&(nbsp|#160);/g,
          val: " "
        },
        cent: {
          regex: /&(cent|#162);/g,
          val: "¢"
        },
        pound: {
          regex: /&(pound|#163);/g,
          val: "£"
        },
        yen: {
          regex: /&(yen|#165);/g,
          val: "¥"
        },
        euro: {
          regex: /&(euro|#8364);/g,
          val: "€"
        },
        copyright: {
          regex: /&(copy|#169);/g,
          val: "©"
        },
        reg: {
          regex: /&(reg|#174);/g,
          val: "®"
        },
        inr: {
          regex: /&(inr|#8377);/g,
          val: "₹"
        },
        num_dec: {
          regex: /&#([0-9]{1,7});/g,
          val: (B, Q) => String.fromCharCode(Number.parseInt(Q, 10))
        },
        num_hex: {
          regex: /&#x([0-9a-fA-F]{1,6});/g,
          val: (B, Q) => String.fromCharCode(Number.parseInt(Q, 16))
        }
      }, this.addExternalEntities = yG4, this.parseXml = bG4, this.parseTextData = kG4, this.resolveNameSpace = xG4, this.buildAttributesMap = vG4, this.isItStopNode = dG4, this.replaceEntitiesValue = hG4, this.readStopNodeData = pG4, this.saveTextToParentTag = mG4, this.addChild = gG4
    }
  }

  function yG4(A) {
    let B = Object.keys(A);
    for (let Q = 0; Q < B.length; Q++) {
      let I = B[Q];
      this.lastEntities[I] = {
        regex: new RegExp("&" + I + ";", "g"),
        val: A[I]
      }
    }
  }

  function kG4(A, B, Q, I, G, Z, D) {
    if (A !== void 0) {
      if (this.options.trimValues && !I) A = A.trim();
      if (A.length > 0) {
        if (!D) A = this.replaceEntitiesValue(A);
        let Y = this.options.tagValueProcessor(B, A, Q, G, Z);
        if (Y === null || Y === void 0) return A;
        else if (typeof Y !== typeof A || Y !== A) return Y;
        else if (this.options.trimValues) return Rj1(A, this.options.parseTagValue, this.options.numberParseOptions);
        else if (A.trim() === A) return Rj1(A, this.options.parseTagValue, this.options.numberParseOptions);
        else return A
      }
    }
  }

  function xG4(A) {
    if (this.options.removeNSPrefix) {
      let B = A.split(":"),
        Q = A.charAt(0) === "/" ? "/" : "";
      if (B[0] === "xmlns") return "";
      if (B.length === 2) A = Q + B[1]
    }
    return A
  }
  var fG4 = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");

  function vG4(A, B, Q) {
    if (!this.options.ignoreAttributes && typeof A === "string") {
      let I = zsA.getAllMatches(A, fG4),
        G = I.length,
        Z = {};
      for (let D = 0; D < G; D++) {
        let Y = this.resolveNameSpace(I[D][1]),
          W = I[D][4],
          J = this.options.attributeNamePrefix + Y;
        if (Y.length) {
          if (this.options.transformAttributeName) J = this.options.transformAttributeName(J);
          if (J === "__proto__") J = "#__proto__";
          if (W !== void 0) {
            if (this.options.trimValues) W = W.trim();
            W = this.replaceEntitiesValue(W);
            let F = this.options.attributeValueProcessor(Y, W, B);
            if (F === null || F === void 0) Z[J] = W;
            else if (typeof F !== typeof W || F !== W) Z[J] = F;
            else Z[J] = Rj1(W, this.options.parseAttributeValue, this.options.numberParseOptions)
          } else if (this.options.allowBooleanAttributes) Z[J] = !0
        }
      }
      if (!Object.keys(Z).length) return;
      if (this.options.attributesGroupName) {
        let D = {};
        return D[this.options.attributesGroupName] = Z, D
      }
      return Z
    }
  }
  var bG4 = function(A) {
    A = A.replace(/\r\n?/g, `
`);
    let B = new Aa("!xml"),
      Q = B,
      I = "",
      G = "";
    for (let Z = 0; Z < A.length; Z++)
      if (A[Z] === "<")
        if (A[Z + 1] === "/") {
          let Y = oS(A, ">", Z, "Closing Tag is not closed."),
            W = A.substring(Z + 2, Y).trim();
          if (this.options.removeNSPrefix) {
            let X = W.indexOf(":");
            if (X !== -1) W = W.substr(X + 1)
          }
          if (this.options.transformTagName) W = this.options.transformTagName(W);
          if (Q) I = this.saveTextToParentTag(I, Q, G);
          let J = G.substring(G.lastIndexOf(".") + 1);
          if (W && this.options.unpairedTags.indexOf(W) !== -1) throw new Error(`Unpaired tag can not be used as closing tag: </${W}>`);
          let F = 0;
          if (J && this.options.unpairedTags.indexOf(J) !== -1) F = G.lastIndexOf(".", G.lastIndexOf(".") - 1), this.tagsNodeStack.pop();
          else F = G.lastIndexOf(".");
          G = G.substring(0, F), Q = this.tagsNodeStack.pop(), I = "", Z = Y
        } else if (A[Z + 1] === "?") {
      let Y = Lj1(A, Z, !1, "?>");
      if (!Y) throw new Error("Pi Tag is not closed.");
      if (I = this.saveTextToParentTag(I, Q, G), this.options.ignoreDeclaration && Y.tagName === "?xml" || this.options.ignorePiTags);
      else {
        let W = new Aa(Y.tagName);
        if (W.add(this.options.textNodeName, ""), Y.tagName !== Y.tagExp && Y.attrExpPresent) W[":@"] = this.buildAttributesMap(Y.tagExp, G, Y.tagName);
        this.addChild(Q, W, G)
      }
      Z = Y.closeIndex + 1
    } else if (A.substr(Z + 1, 3) === "!--") {
      let Y = oS(A, "-->", Z + 4, "Comment is not closed.");
      if (this.options.commentPropName) {
        let W = A.substring(Z + 4, Y - 2);
        I = this.saveTextToParentTag(I, Q, G), Q.add(this.options.commentPropName, [{
          [this.options.textNodeName]: W
        }])
      }
      Z = Y
    } else if (A.substr(Z + 1, 2) === "!D") {
      let Y = _G4(A, Z);
      this.docTypeEntities = Y.entities, Z = Y.i
    } else if (A.substr(Z + 1, 2) === "![") {
      let Y = oS(A, "]]>", Z, "CDATA is not closed.") - 2,
        W = A.substring(Z + 9, Y);
      I = this.saveTextToParentTag(I, Q, G);
      let J = this.parseTextData(W, Q.tagname, G, !0, !1, !0, !0);
      if (J == null) J = "";
      if (this.options.cdataPropName) Q.add(this.options.cdataPropName, [{
        [this.options.textNodeName]: W
      }]);
      else Q.add(this.options.textNodeName, J);
      Z = Y + 2
    } else {
      let Y = Lj1(A, Z, this.options.removeNSPrefix),
        W = Y.tagName,
        J = Y.rawTagName,
        F = Y.tagExp,
        X = Y.attrExpPresent,
        V = Y.closeIndex;
      if (this.options.transformTagName) W = this.options.transformTagName(W);
      if (Q && I) {
        if (Q.tagname !== "!xml") I = this.saveTextToParentTag(I, Q, G, !1)
      }
      let C = Q;
      if (C && this.options.unpairedTags.indexOf(C.tagname) !== -1) Q = this.tagsNodeStack.pop(), G = G.substring(0, G.lastIndexOf("."));
      if (W !== B.tagname) G += G ? "." + W : W;
      if (this.isItStopNode(this.options.stopNodes, G, W)) {
        let K = "";
        if (F.length > 0 && F.lastIndexOf("/") === F.length - 1) {
          if (W[W.length - 1] === "/") W = W.substr(0, W.length - 1), G = G.substr(0, G.length - 1), F = W;
          else F = F.substr(0, F.length - 1);
          Z = Y.closeIndex
        } else if (this.options.unpairedTags.indexOf(W) !== -1) Z = Y.closeIndex;
        else {
          let N = this.readStopNodeData(A, J, V + 1);
          if (!N) throw new Error(`Unexpected end of ${J}`);
          Z = N.i, K = N.tagContent
        }
        let E = new Aa(W);
        if (W !== F && X) E[":@"] = this.buildAttributesMap(F, G, W);
        if (K) K = this.parseTextData(K, W, G, !0, X, !0, !0);
        G = G.substr(0, G.lastIndexOf(".")), E.add(this.options.textNodeName, K), this.addChild(Q, E, G)
      } else {
        if (F.length > 0 && F.lastIndexOf("/") === F.length - 1) {
          if (W[W.length - 1] === "/") W = W.substr(0, W.length - 1), G = G.substr(0, G.length - 1), F = W;
          else F = F.substr(0, F.length - 1);
          if (this.options.transformTagName) W = this.options.transformTagName(W);
          let K = new Aa(W);
          if (W !== F && X) K[":@"] = this.buildAttributesMap(F, G, W);
          this.addChild(Q, K, G), G = G.substr(0, G.lastIndexOf("."))
        } else {
          let K = new Aa(W);
          if (this.tagsNodeStack.push(Q), W !== F && X) K[":@"] = this.buildAttributesMap(F, G, W);
          this.addChild(Q, K, G), Q = K
        }
        I = "", Z = V
      }
    } else I += A[Z];
    return B.child
  };

  function gG4(A, B, Q) {
    let I = this.options.updateTag(B.tagname, Q, B[":@"]);
    if (I === !1);
    else if (typeof I === "string") B.tagname = I, A.addChild(B);
    else A.addChild(B)
  }
  var hG4 = function(A) {
    if (this.options.processEntities) {
      for (let B in this.docTypeEntities) {
        let Q = this.docTypeEntities[B];
        A = A.replace(Q.regx, Q.val)
      }
      for (let B in this.lastEntities) {
        let Q = this.lastEntities[B];
        A = A.replace(Q.regex, Q.val)
      }
      if (this.options.htmlEntities)
        for (let B in this.htmlEntities) {
          let Q = this.htmlEntities[B];
          A = A.replace(Q.regex, Q.val)
        }
      A = A.replace(this.ampEntity.regex, this.ampEntity.val)
    }
    return A
  };

  function mG4(A, B, Q, I) {
    if (A) {
      if (I === void 0) I = Object.keys(B.child).length === 0;
      if (A = this.parseTextData(A, B.tagname, Q, !1, B[":@"] ? Object.keys(B[":@"]).length !== 0 : !1, I), A !== void 0 && A !== "") B.add(this.options.textNodeName, A);
      A = ""
    }
    return A
  }

  function dG4(A, B, Q) {
    let I = "*." + Q;
    for (let G in A) {
      let Z = A[G];
      if (I === Z || B === Z) return !0
    }
    return !1
  }

  function uG4(A, B, Q = ">") {
    let I, G = "";
    for (let Z = B; Z < A.length; Z++) {
      let D = A[Z];
      if (I) {
        if (D === I) I = ""
      } else if (D === '"' || D === "'") I = D;
      else if (D === Q[0])
        if (Q[1]) {
          if (A[Z + 1] === Q[1]) return {
            data: G,
            index: Z
          }
        } else return {
          data: G,
          index: Z
        };
      else if (D === "\t") D = " ";
      G += D
    }
  }

  function oS(A, B, Q, I) {
    let G = A.indexOf(B, Q);
    if (G === -1) throw new Error(I);
    else return G + B.length - 1
  }

  function Lj1(A, B, Q, I = ">") {
    let G = uG4(A, B + 1, I);
    if (!G) return;
    let {
      data: Z,
      index: D
    } = G, Y = Z.search(/\s/), W = Z, J = !0;
    if (Y !== -1) W = Z.substring(0, Y), Z = Z.substring(Y + 1).trimStart();
    let F = W;
    if (Q) {
      let X = W.indexOf(":");
      if (X !== -1) W = W.substr(X + 1), J = W !== G.data.substr(X + 1)
    }
    return {
      tagName: W,
      tagExp: Z,
      closeIndex: D,
      attrExpPresent: J,
      rawTagName: F
    }
  }

  function pG4(A, B, Q) {
    let I = Q,
      G = 1;
    for (; Q < A.length; Q++)
      if (A[Q] === "<")
        if (A[Q + 1] === "/") {
          let Z = oS(A, ">", Q, `${B} is not closed`);
          if (A.substring(Q + 2, Z).trim() === B) {
            if (G--, G === 0) return {
              tagContent: A.substring(I, Q),
              i: Z
            }
          }
          Q = Z
        } else if (A[Q + 1] === "?") Q = oS(A, "?>", Q + 1, "StopNode is not closed.");
    else if (A.substr(Q + 1, 3) === "!--") Q = oS(A, "-->", Q + 3, "StopNode is not closed.");
    else if (A.substr(Q + 1, 2) === "![") Q = oS(A, "]]>", Q, "StopNode is not closed.") - 2;
    else {
      let Z = Lj1(A, Q, ">");
      if (Z) {
        if ((Z && Z.tagName) === B && Z.tagExp[Z.tagExp.length - 1] !== "/") G++;
        Q = Z.closeIndex
      }
    }
  }

  function Rj1(A, B, Q) {
    if (B && typeof A === "string") {
      let I = A.trim();
      if (I === "true") return !0;
      else if (I === "false") return !1;
      else return jG4(A, Q)
    } else if (zsA.isExist(A)) return A;
    else return ""
  }
  EsA.exports = wsA
})
// @from(Start 3303566, End 3305371)
$sA = z((aG4) => {
  function cG4(A, B) {
    return NsA(A, B)
  }

  function NsA(A, B, Q) {
    let I, G = {};
    for (let Z = 0; Z < A.length; Z++) {
      let D = A[Z],
        Y = lG4(D),
        W = "";
      if (Q === void 0) W = Y;
      else W = Q + "." + Y;
      if (Y === B.textNodeName)
        if (I === void 0) I = D[Y];
        else I += "" + D[Y];
      else if (Y === void 0) continue;
      else if (D[Y]) {
        let J = NsA(D[Y], B, W),
          F = nG4(J, B);
        if (D[":@"]) iG4(J, D[":@"], W, B);
        else if (Object.keys(J).length === 1 && J[B.textNodeName] !== void 0 && !B.alwaysCreateTextNode) J = J[B.textNodeName];
        else if (Object.keys(J).length === 0)
          if (B.alwaysCreateTextNode) J[B.textNodeName] = "";
          else J = "";
        if (G[Y] !== void 0 && G.hasOwnProperty(Y)) {
          if (!Array.isArray(G[Y])) G[Y] = [G[Y]];
          G[Y].push(J)
        } else if (B.isArray(Y, W, F)) G[Y] = [J];
        else G[Y] = J
      }
    }
    if (typeof I === "string") {
      if (I.length > 0) G[B.textNodeName] = I
    } else if (I !== void 0) G[B.textNodeName] = I;
    return G
  }

  function lG4(A) {
    let B = Object.keys(A);
    for (let Q = 0; Q < B.length; Q++) {
      let I = B[Q];
      if (I !== ":@") return I
    }
  }

  function iG4(A, B, Q, I) {
    if (B) {
      let G = Object.keys(B),
        Z = G.length;
      for (let D = 0; D < Z; D++) {
        let Y = G[D];
        if (I.isArray(Y, Q + "." + Y, !0, !0)) A[Y] = [B[Y]];
        else A[Y] = B[Y]
      }
    }
  }

  function nG4(A, B) {
    let {
      textNodeName: Q
    } = B, I = Object.keys(A).length;
    if (I === 0) return !0;
    if (I === 1 && (A[Q] || typeof A[Q] === "boolean" || A[Q] === 0)) return !0;
    return !1
  }
  aG4.prettify = cG4
})
// @from(Start 3305377, End 3306584)
LsA = z((N78, MsA) => {
  var {
    buildOptions: rG4
  } = WsA(), oG4 = UsA(), {
    prettify: tG4
  } = $sA(), eG4 = Mj1();
  class qsA {
    constructor(A) {
      this.externalEntities = {}, this.options = rG4(A)
    }
    parse(A, B) {
      if (typeof A === "string");
      else if (A.toString) A = A.toString();
      else throw new Error("XML data is accepted in String or Bytes[] form.");
      if (B) {
        if (B === !0) B = {};
        let G = eG4.validate(A, B);
        if (G !== !0) throw Error(`${G.err.msg}:${G.err.line}:${G.err.col}`)
      }
      let Q = new oG4(this.options);
      Q.addExternalEntities(this.externalEntities);
      let I = Q.parseXml(A);
      if (this.options.preserveOrder || I === void 0) return I;
      else return tG4(I, this.options)
    }
    addEntity(A, B) {
      if (B.indexOf("&") !== -1) throw new Error("Entity value can't have '&'");
      else if (A.indexOf("&") !== -1 || A.indexOf(";") !== -1) throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");
      else if (B === "&") throw new Error("An entity with value '&' is not permitted");
      else this.externalEntities[A] = B
    }
  }
  MsA.exports = qsA
})
// @from(Start 3306590, End 3309413)
SsA = z(($78, PsA) => {
  function AZ4(A, B) {
    let Q = "";
    if (B.format && B.indentBy.length > 0) Q = `
`;
    return OsA(A, B, "", Q)
  }

  function OsA(A, B, Q, I) {
    let G = "",
      Z = !1;
    for (let D = 0; D < A.length; D++) {
      let Y = A[D],
        W = BZ4(Y);
      if (W === void 0) continue;
      let J = "";
      if (Q.length === 0) J = W;
      else J = `${Q}.${W}`;
      if (W === B.textNodeName) {
        let K = Y[W];
        if (!QZ4(J, B)) K = B.tagValueProcessor(W, K), K = TsA(K, B);
        if (Z) G += I;
        G += K, Z = !1;
        continue
      } else if (W === B.cdataPropName) {
        if (Z) G += I;
        G += `<![CDATA[${Y[W][0][B.textNodeName]}]]>`, Z = !1;
        continue
      } else if (W === B.commentPropName) {
        G += I + `<!--${Y[W][0][B.textNodeName]}-->`, Z = !0;
        continue
      } else if (W[0] === "?") {
        let K = RsA(Y[":@"], B),
          E = W === "?xml" ? "" : I,
          N = Y[W][0][B.textNodeName];
        N = N.length !== 0 ? " " + N : "", G += E + `<${W}${N}${K}?>`, Z = !0;
        continue
      }
      let F = I;
      if (F !== "") F += B.indentBy;
      let X = RsA(Y[":@"], B),
        V = I + `<${W}${X}`,
        C = OsA(Y[W], B, J, F);
      if (B.unpairedTags.indexOf(W) !== -1)
        if (B.suppressUnpairedNode) G += V + ">";
        else G += V + "/>";
      else if ((!C || C.length === 0) && B.suppressEmptyNode) G += V + "/>";
      else if (C && C.endsWith(">")) G += V + `>${C}${I}</${W}>`;
      else {
        if (G += V + ">", C && I !== "" && (C.includes("/>") || C.includes("</"))) G += I + B.indentBy + C + I;
        else G += C;
        G += `</${W}>`
      }
      Z = !0
    }
    return G
  }

  function BZ4(A) {
    let B = Object.keys(A);
    for (let Q = 0; Q < B.length; Q++) {
      let I = B[Q];
      if (!A.hasOwnProperty(I)) continue;
      if (I !== ":@") return I
    }
  }

  function RsA(A, B) {
    let Q = "";
    if (A && !B.ignoreAttributes)
      for (let I in A) {
        if (!A.hasOwnProperty(I)) continue;
        let G = B.attributeValueProcessor(I, A[I]);
        if (G = TsA(G, B), G === !0 && B.suppressBooleanAttributes) Q += ` ${I.substr(B.attributeNamePrefix.length)}`;
        else Q += ` ${I.substr(B.attributeNamePrefix.length)}="${G}"`
      }
    return Q
  }

  function QZ4(A, B) {
    A = A.substr(0, A.length - B.textNodeName.length - 1);
    let Q = A.substr(A.lastIndexOf(".") + 1);
    for (let I in B.stopNodes)
      if (B.stopNodes[I] === A || B.stopNodes[I] === "*." + Q) return !0;
    return !1
  }

  function TsA(A, B) {
    if (A && A.length > 0 && B.processEntities)
      for (let Q = 0; Q < B.entities.length; Q++) {
        let I = B.entities[Q];
        A = A.replace(I.regex, I.val)
      }
    return A
  }
  PsA.exports = AZ4
})
// @from(Start 3309419, End 3316380)
jsA = z((q78, _sA) => {
  var IZ4 = SsA(),
    GZ4 = {
      attributeNamePrefix: "@_",
      attributesGroupName: !1,
      textNodeName: "#text",
      ignoreAttributes: !0,
      cdataPropName: !1,
      format: !1,
      indentBy: "  ",
      suppressEmptyNode: !1,
      suppressUnpairedNode: !0,
      suppressBooleanAttributes: !0,
      tagValueProcessor: function(A, B) {
        return B
      },
      attributeValueProcessor: function(A, B) {
        return B
      },
      preserveOrder: !1,
      commentPropName: !1,
      unpairedTags: [],
      entities: [{
        regex: new RegExp("&", "g"),
        val: "&amp;"
      }, {
        regex: new RegExp(">", "g"),
        val: "&gt;"
      }, {
        regex: new RegExp("<", "g"),
        val: "&lt;"
      }, {
        regex: new RegExp("'", "g"),
        val: "&apos;"
      }, {
        regex: new RegExp('"', "g"),
        val: "&quot;"
      }],
      processEntities: !0,
      stopNodes: [],
      oneListGroup: !1
    };

  function _L(A) {
    if (this.options = Object.assign({}, GZ4, A), this.options.ignoreAttributes || this.options.attributesGroupName) this.isAttribute = function() {
      return !1
    };
    else this.attrPrefixLen = this.options.attributeNamePrefix.length, this.isAttribute = YZ4;
    if (this.processTextOrObjNode = ZZ4, this.options.format) this.indentate = DZ4, this.tagEndChar = `>
`, this.newLine = `
`;
    else this.indentate = function() {
      return ""
    }, this.tagEndChar = ">", this.newLine = ""
  }
  _L.prototype.build = function(A) {
    if (this.options.preserveOrder) return IZ4(A, this.options);
    else {
      if (Array.isArray(A) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) A = {
        [this.options.arrayNodeName]: A
      };
      return this.j2x(A, 0).val
    }
  };
  _L.prototype.j2x = function(A, B) {
    let Q = "",
      I = "";
    for (let G in A) {
      if (!Object.prototype.hasOwnProperty.call(A, G)) continue;
      if (typeof A[G] === "undefined") {
        if (this.isAttribute(G)) I += ""
      } else if (A[G] === null)
        if (this.isAttribute(G)) I += "";
        else if (G[0] === "?") I += this.indentate(B) + "<" + G + "?" + this.tagEndChar;
      else I += this.indentate(B) + "<" + G + "/" + this.tagEndChar;
      else if (A[G] instanceof Date) I += this.buildTextValNode(A[G], G, "", B);
      else if (typeof A[G] !== "object") {
        let Z = this.isAttribute(G);
        if (Z) Q += this.buildAttrPairStr(Z, "" + A[G]);
        else if (G === this.options.textNodeName) {
          let D = this.options.tagValueProcessor(G, "" + A[G]);
          I += this.replaceEntitiesValue(D)
        } else I += this.buildTextValNode(A[G], G, "", B)
      } else if (Array.isArray(A[G])) {
        let Z = A[G].length,
          D = "",
          Y = "";
        for (let W = 0; W < Z; W++) {
          let J = A[G][W];
          if (typeof J === "undefined");
          else if (J === null)
            if (G[0] === "?") I += this.indentate(B) + "<" + G + "?" + this.tagEndChar;
            else I += this.indentate(B) + "<" + G + "/" + this.tagEndChar;
          else if (typeof J === "object")
            if (this.options.oneListGroup) {
              let F = this.j2x(J, B + 1);
              if (D += F.val, this.options.attributesGroupName && J.hasOwnProperty(this.options.attributesGroupName)) Y += F.attrStr
            } else D += this.processTextOrObjNode(J, G, B);
          else if (this.options.oneListGroup) {
            let F = this.options.tagValueProcessor(G, J);
            F = this.replaceEntitiesValue(F), D += F
          } else D += this.buildTextValNode(J, G, "", B)
        }
        if (this.options.oneListGroup) D = this.buildObjectNode(D, G, Y, B);
        I += D
      } else if (this.options.attributesGroupName && G === this.options.attributesGroupName) {
        let Z = Object.keys(A[G]),
          D = Z.length;
        for (let Y = 0; Y < D; Y++) Q += this.buildAttrPairStr(Z[Y], "" + A[G][Z[Y]])
      } else I += this.processTextOrObjNode(A[G], G, B)
    }
    return {
      attrStr: Q,
      val: I
    }
  };
  _L.prototype.buildAttrPairStr = function(A, B) {
    if (B = this.options.attributeValueProcessor(A, "" + B), B = this.replaceEntitiesValue(B), this.options.suppressBooleanAttributes && B === "true") return " " + A;
    else return " " + A + '="' + B + '"'
  };

  function ZZ4(A, B, Q) {
    let I = this.j2x(A, Q + 1);
    if (A[this.options.textNodeName] !== void 0 && Object.keys(A).length === 1) return this.buildTextValNode(A[this.options.textNodeName], B, I.attrStr, Q);
    else return this.buildObjectNode(I.val, B, I.attrStr, Q)
  }
  _L.prototype.buildObjectNode = function(A, B, Q, I) {
    if (A === "")
      if (B[0] === "?") return this.indentate(I) + "<" + B + Q + "?" + this.tagEndChar;
      else return this.indentate(I) + "<" + B + Q + this.closeTag(B) + this.tagEndChar;
    else {
      let G = "</" + B + this.tagEndChar,
        Z = "";
      if (B[0] === "?") Z = "?", G = "";
      if ((Q || Q === "") && A.indexOf("<") === -1) return this.indentate(I) + "<" + B + Q + Z + ">" + A + G;
      else if (this.options.commentPropName !== !1 && B === this.options.commentPropName && Z.length === 0) return this.indentate(I) + `<!--${A}-->` + this.newLine;
      else return this.indentate(I) + "<" + B + Q + Z + this.tagEndChar + A + this.indentate(I) + G
    }
  };
  _L.prototype.closeTag = function(A) {
    let B = "";
    if (this.options.unpairedTags.indexOf(A) !== -1) {
      if (!this.options.suppressUnpairedNode) B = "/"
    } else if (this.options.suppressEmptyNode) B = "/";
    else B = `></${A}`;
    return B
  };
  _L.prototype.buildTextValNode = function(A, B, Q, I) {
    if (this.options.cdataPropName !== !1 && B === this.options.cdataPropName) return this.indentate(I) + `<![CDATA[${A}]]>` + this.newLine;
    else if (this.options.commentPropName !== !1 && B === this.options.commentPropName) return this.indentate(I) + `<!--${A}-->` + this.newLine;
    else if (B[0] === "?") return this.indentate(I) + "<" + B + Q + "?" + this.tagEndChar;
    else {
      let G = this.options.tagValueProcessor(B, A);
      if (G = this.replaceEntitiesValue(G), G === "") return this.indentate(I) + "<" + B + Q + this.closeTag(B) + this.tagEndChar;
      else return this.indentate(I) + "<" + B + Q + ">" + G + "</" + B + this.tagEndChar
    }
  };
  _L.prototype.replaceEntitiesValue = function(A) {
    if (A && A.length > 0 && this.options.processEntities)
      for (let B = 0; B < this.options.entities.length; B++) {
        let Q = this.options.entities[B];
        A = A.replace(Q.regex, Q.val)
      }
    return A
  };

  function DZ4(A) {
    return this.options.indentBy.repeat(A)
  }

  function YZ4(A) {
    if (A.startsWith(this.options.attributeNamePrefix) && A !== this.options.textNodeName) return A.substr(this.attrPrefixLen);
    else return !1
  }
  _sA.exports = _L
})
// @from(Start 3316386, End 3316550)
ksA = z((M78, ysA) => {
  var WZ4 = Mj1(),
    JZ4 = LsA(),
    FZ4 = jsA();
  ysA.exports = {
    XMLParser: JZ4,
    XMLValidator: WZ4,
    XMLBuilder: FZ4
  }
})
// @from(Start 3316556, End 3321629)
hsA = z((L78, gsA) => {
  var {
    defineProperty: D71,
    getOwnPropertyDescriptor: XZ4,
    getOwnPropertyNames: VZ4
  } = Object, CZ4 = Object.prototype.hasOwnProperty, fY = (A, B) => D71(A, "name", {
    value: B,
    configurable: !0
  }), KZ4 = (A, B) => {
    for (var Q in B) D71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, HZ4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of VZ4(B))
        if (!CZ4.call(A, G) && G !== Q) D71(A, G, {
          get: () => B[G],
          enumerable: !(I = XZ4(B, G)) || I.enumerable
        })
    }
    return A
  }, zZ4 = (A) => HZ4(D71({}, "__esModule", {
    value: !0
  }), A), xsA = {};
  KZ4(xsA, {
    _toBool: () => EZ4,
    _toNum: () => UZ4,
    _toStr: () => wZ4,
    awsExpectUnion: () => $Z4,
    loadRestJsonErrorCode: () => LZ4,
    loadRestXmlErrorCode: () => PZ4,
    parseJsonBody: () => vsA,
    parseJsonErrorBody: () => MZ4,
    parseXmlBody: () => bsA,
    parseXmlErrorBody: () => TZ4
  });
  gsA.exports = zZ4(xsA);
  var wZ4 = fY((A) => {
      if (A == null) return A;
      if (typeof A === "number" || typeof A === "bigint") {
        let B = new Error(`Received number ${A} where a string was expected.`);
        return B.name = "Warning", console.warn(B), String(A)
      }
      if (typeof A === "boolean") {
        let B = new Error(`Received boolean ${A} where a string was expected.`);
        return B.name = "Warning", console.warn(B), String(A)
      }
      return A
    }, "_toStr"),
    EZ4 = fY((A) => {
      if (A == null) return A;
      if (typeof A === "string") {
        let B = A.toLowerCase();
        if (A !== "" && B !== "false" && B !== "true") {
          let Q = new Error(`Received string "${A}" where a boolean was expected.`);
          Q.name = "Warning", console.warn(Q)
        }
        return A !== "" && B !== "false"
      }
      return A
    }, "_toBool"),
    UZ4 = fY((A) => {
      if (A == null) return A;
      if (typeof A === "string") {
        let B = Number(A);
        if (B.toString() !== A) {
          let Q = new Error(`Received string "${A}" where a number was expected.`);
          return Q.name = "Warning", console.warn(Q), A
        }
        return B
      }
      return A
    }, "_toNum"),
    NZ4 = G71(),
    $Z4 = fY((A) => {
      if (A == null) return;
      if (typeof A === "object" && "__type" in A) delete A.__type;
      return NZ4.expectUnion(A)
    }, "awsExpectUnion"),
    qZ4 = G71(),
    fsA = fY((A, B) => qZ4.collectBody(A, B).then((Q) => B.utf8Encoder(Q)), "collectBodyString"),
    vsA = fY((A, B) => fsA(A, B).then((Q) => {
      if (Q.length) try {
        return JSON.parse(Q)
      } catch (I) {
        if (I?.name === "SyntaxError") Object.defineProperty(I, "$responseBodyText", {
          value: Q
        });
        throw I
      }
      return {}
    }), "parseJsonBody"),
    MZ4 = fY(async (A, B) => {
      let Q = await vsA(A, B);
      return Q.message = Q.message ?? Q.Message, Q
    }, "parseJsonErrorBody"),
    LZ4 = fY((A, B) => {
      let Q = fY((Z, D) => Object.keys(Z).find((Y) => Y.toLowerCase() === D.toLowerCase()), "findKey"),
        I = fY((Z) => {
          let D = Z;
          if (typeof D === "number") D = D.toString();
          if (D.indexOf(",") >= 0) D = D.split(",")[0];
          if (D.indexOf(":") >= 0) D = D.split(":")[0];
          if (D.indexOf("#") >= 0) D = D.split("#")[1];
          return D
        }, "sanitizeErrorCode"),
        G = Q(A.headers, "x-amzn-errortype");
      if (G !== void 0) return I(A.headers[G]);
      if (B.code !== void 0) return I(B.code);
      if (B.__type !== void 0) return I(B.__type)
    }, "loadRestJsonErrorCode"),
    RZ4 = G71(),
    OZ4 = ksA(),
    bsA = fY((A, B) => fsA(A, B).then((Q) => {
      if (Q.length) {
        let I = new OZ4.XMLParser({
          attributeNamePrefix: "",
          htmlEntities: !0,
          ignoreAttributes: !1,
          ignoreDeclaration: !0,
          parseTagValue: !1,
          trimValues: !1,
          tagValueProcessor: fY((W, J) => J.trim() === "" && J.includes(`
`) ? "" : void 0, "tagValueProcessor")
        });
        I.addEntity("#xD", "\r"), I.addEntity("#10", `
`);
        let G;
        try {
          G = I.parse(Q, !0)
        } catch (W) {
          if (W && typeof W === "object") Object.defineProperty(W, "$responseBodyText", {
            value: Q
          });
          throw W
        }
        let Z = "#text",
          D = Object.keys(G)[0],
          Y = G[D];
        if (Y[Z]) Y[D] = Y[Z], delete Y[Z];
        return RZ4.getValueFromTextNode(Y)
      }
      return {}
    }), "parseXmlBody"),
    TZ4 = fY(async (A, B) => {
      let Q = await bsA(A, B);
      if (Q.Error) Q.Error.message = Q.Error.message ?? Q.Error.Message;
      return Q
    }, "parseXmlErrorBody"),
    PZ4 = fY((A, B) => {
      if (B?.Error?.Code !== void 0) return B.Error.Code;
      if (B?.Code !== void 0) return B.Code;
      if (A.statusCode == 404) return "NotFound"
    }, "loadRestXmlErrorCode")
})
// @from(Start 3321635, End 3321828)
IB = z((Ba) => {
  Object.defineProperty(Ba, "__esModule", {
    value: !0
  });
  var Oj1 = $nA();
  Oj1.__exportStar(NC(), Ba);
  Oj1.__exportStar(yaA(), Ba);
  Oj1.__exportStar(hsA(), Ba)
})
// @from(Start 3321834, End 3327434)
jL = z((O78, osA) => {
  var {
    defineProperty: W71,
    getOwnPropertyDescriptor: SZ4,
    getOwnPropertyNames: _Z4
  } = Object, jZ4 = Object.prototype.hasOwnProperty, JN = (A, B) => W71(A, "name", {
    value: B,
    configurable: !0
  }), yZ4 = (A, B) => {
    for (var Q in B) W71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, kZ4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of _Z4(B))
        if (!jZ4.call(A, G) && G !== Q) W71(A, G, {
          get: () => B[G],
          enumerable: !(I = SZ4(B, G)) || I.enumerable
        })
    }
    return A
  }, xZ4 = (A) => kZ4(W71({}, "__esModule", {
    value: !0
  }), A), psA = {};
  yZ4(psA, {
    DEFAULT_UA_APP_ID: () => csA,
    getUserAgentMiddlewareOptions: () => rsA,
    getUserAgentPlugin: () => uZ4,
    resolveUserAgentConfig: () => isA,
    userAgentMiddleware: () => ssA
  });
  osA.exports = xZ4(psA);
  var fZ4 = NI(),
    csA = void 0;

  function lsA(A) {
    if (A === void 0) return !0;
    return typeof A === "string" && A.length <= 50
  }
  JN(lsA, "isValidUserAgentAppId");

  function isA(A) {
    let B = fZ4.normalizeProvider(A.userAgentAppId ?? csA),
      {
        customUserAgent: Q
      } = A;
    return Object.assign(A, {
      customUserAgent: typeof Q === "string" ? [
        [Q]
      ] : Q,
      userAgentAppId: JN(async () => {
        let I = await B();
        if (!lsA(I)) {
          let G = A.logger?.constructor?.name === "NoOpLogger" || !A.logger ? console : A.logger;
          if (typeof I !== "string") G?.warn("userAgentAppId must be a string or undefined.");
          else if (I.length > 50) G?.warn("The provided userAgentAppId exceeds the maximum length of 50 characters.")
        }
        return I
      }, "userAgentAppId")
    })
  }
  JN(isA, "resolveUserAgentConfig");
  var vZ4 = RL(),
    bZ4 = iiA(),
    gz = IB(),
    gZ4 = /\d{12}\.ddb/;
  async function nsA(A, B, Q) {
    if (Q.request?.headers?.["smithy-protocol"] === "rpc-v2-cbor") gz.setFeature(A, "PROTOCOL_RPC_V2_CBOR", "M");
    if (typeof B.retryStrategy === "function") {
      let Z = await B.retryStrategy();
      if (typeof Z.acquireInitialRetryToken === "function")
        if (Z.constructor?.name?.includes("Adaptive")) gz.setFeature(A, "RETRY_MODE_ADAPTIVE", "F");
        else gz.setFeature(A, "RETRY_MODE_STANDARD", "E");
      else gz.setFeature(A, "RETRY_MODE_LEGACY", "D")
    }
    if (typeof B.accountIdEndpointMode === "function") {
      let Z = A.endpointV2;
      if (String(Z?.url?.hostname).match(gZ4)) gz.setFeature(A, "ACCOUNT_ID_ENDPOINT", "O");
      switch (await B.accountIdEndpointMode?.()) {
        case "disabled":
          gz.setFeature(A, "ACCOUNT_ID_MODE_DISABLED", "Q");
          break;
        case "preferred":
          gz.setFeature(A, "ACCOUNT_ID_MODE_PREFERRED", "P");
          break;
        case "required":
          gz.setFeature(A, "ACCOUNT_ID_MODE_REQUIRED", "R");
          break
      }
    }
    let G = A.__smithy_context?.selectedHttpAuthScheme?.identity;
    if (G?.$source) {
      let Z = G;
      if (Z.accountId) gz.setFeature(A, "RESOLVED_ACCOUNT_ID", "T");
      for (let [D, Y] of Object.entries(Z.$source ?? {})) gz.setFeature(A, D, Y)
    }
  }
  JN(nsA, "checkFeatures");
  var msA = "user-agent",
    Tj1 = "x-amz-user-agent",
    dsA = " ",
    Pj1 = "/",
    hZ4 = /[^\!\$\%\&\'\*\+\-\.\^\_\`\|\~\d\w]/g,
    mZ4 = /[^\!\$\%\&\'\*\+\-\.\^\_\`\|\~\d\w\#]/g,
    usA = "-",
    dZ4 = 1024;

  function asA(A) {
    let B = "";
    for (let Q in A) {
      let I = A[Q];
      if (B.length + I.length + 1 <= dZ4) {
        if (B.length) B += "," + I;
        else B += I;
        continue
      }
      break
    }
    return B
  }
  JN(asA, "encodeFeatures");
  var ssA = JN((A) => (B, Q) => async (I) => {
      let {
        request: G
      } = I;
      if (!bZ4.HttpRequest.isInstance(G)) return B(I);
      let {
        headers: Z
      } = G, D = Q?.userAgent?.map(Y71) || [], Y = (await A.defaultUserAgentProvider()).map(Y71);
      await nsA(Q, A, I);
      let W = Q;
      Y.push(`m/${asA(Object.assign({},Q.__smithy_context?.features,W.__aws_sdk_context?.features))}`);
      let J = A?.customUserAgent?.map(Y71) || [],
        F = await A.userAgentAppId();
      if (F) Y.push(Y71([`app/${F}`]));
      let X = vZ4.getUserAgentPrefix(),
        V = (X ? [X] : []).concat([...Y, ...D, ...J]).join(dsA),
        C = [...Y.filter((K) => K.startsWith("aws-sdk-")), ...J].join(dsA);
      if (A.runtime !== "browser") {
        if (C) Z[Tj1] = Z[Tj1] ? `${Z[msA]} ${C}` : C;
        Z[msA] = V
      } else Z[Tj1] = V;
      return B({
        ...I,
        request: G
      })
    }, "userAgentMiddleware"),
    Y71 = JN((A) => {
      let B = A[0].split(Pj1).map((D) => D.replace(hZ4, usA)).join(Pj1),
        Q = A[1]?.replace(mZ4, usA),
        I = B.indexOf(Pj1),
        G = B.substring(0, I),
        Z = B.substring(I + 1);
      if (G === "api") Z = Z.toLowerCase();
      return [G, Z, Q].filter((D) => D && D.length > 0).reduce((D, Y, W) => {
        switch (W) {
          case 0:
            return Y;
          case 1:
            return `${D}/${Y}`;
          default:
            return `${D}#${Y}`
        }
      }, "")
    }, "escapeUserAgent"),
    rsA = {
      name: "getUserAgentMiddleware",
      step: "build",
      priority: "low",
      tags: ["SET_USER_AGENT", "USER_AGENT"],
      override: !0
    },
    uZ4 = JN((A) => ({
      applyToStack: JN((B) => {
        B.add(ssA(A), rsA)
      }, "applyToStack")
    }), "getUserAgentPlugin")
})
// @from(Start 3327440, End 3328886)
QrA = z((T78, BrA) => {
  var {
    defineProperty: J71,
    getOwnPropertyDescriptor: pZ4,
    getOwnPropertyNames: cZ4
  } = Object, lZ4 = Object.prototype.hasOwnProperty, tsA = (A, B) => J71(A, "name", {
    value: B,
    configurable: !0
  }), iZ4 = (A, B) => {
    for (var Q in B) J71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, nZ4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of cZ4(B))
        if (!lZ4.call(A, G) && G !== Q) J71(A, G, {
          get: () => B[G],
          enumerable: !(I = pZ4(B, G)) || I.enumerable
        })
    }
    return A
  }, aZ4 = (A) => nZ4(J71({}, "__esModule", {
    value: !0
  }), A), esA = {};
  iZ4(esA, {
    SelectorType: () => ArA,
    booleanSelector: () => sZ4,
    numberSelector: () => rZ4
  });
  BrA.exports = aZ4(esA);
  var sZ4 = tsA((A, B, Q) => {
      if (!(B in A)) return;
      if (A[B] === "true") return !0;
      if (A[B] === "false") return !1;
      throw new Error(`Cannot load ${Q} "${B}". Expected "true" or "false", got ${A[B]}.`)
    }, "booleanSelector"),
    rZ4 = tsA((A, B, Q) => {
      if (!(B in A)) return;
      let I = parseInt(A[B], 10);
      if (Number.isNaN(I)) throw new TypeError(`Cannot load ${Q} '${B}'. Expected number, got '${A[B]}'.`);
      return I
    }, "numberSelector"),
    ArA = ((A) => {
      return A.ENV = "env", A.CONFIG = "shared config entry", A
    })(ArA || {})
})
// @from(Start 3328892, End 3335616)
_D = z((P78, CrA) => {
  var {
    defineProperty: X71,
    getOwnPropertyDescriptor: oZ4,
    getOwnPropertyNames: tZ4
  } = Object, eZ4 = Object.prototype.hasOwnProperty, $C = (A, B) => X71(A, "name", {
    value: B,
    configurable: !0
  }), AD4 = (A, B) => {
    for (var Q in B) X71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, BD4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of tZ4(B))
        if (!eZ4.call(A, G) && G !== Q) X71(A, G, {
          get: () => B[G],
          enumerable: !(I = oZ4(B, G)) || I.enumerable
        })
    }
    return A
  }, QD4 = (A) => BD4(X71({}, "__esModule", {
    value: !0
  }), A), ZrA = {};
  AD4(ZrA, {
    CONFIG_USE_DUALSTACK_ENDPOINT: () => YrA,
    CONFIG_USE_FIPS_ENDPOINT: () => JrA,
    DEFAULT_USE_DUALSTACK_ENDPOINT: () => ID4,
    DEFAULT_USE_FIPS_ENDPOINT: () => ZD4,
    ENV_USE_DUALSTACK_ENDPOINT: () => DrA,
    ENV_USE_FIPS_ENDPOINT: () => WrA,
    NODE_REGION_CONFIG_FILE_OPTIONS: () => XD4,
    NODE_REGION_CONFIG_OPTIONS: () => FD4,
    NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS: () => GD4,
    NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS: () => DD4,
    REGION_ENV_NAME: () => FrA,
    REGION_INI_NAME: () => XrA,
    getRegionInfo: () => zD4,
    resolveCustomEndpointsConfig: () => YD4,
    resolveEndpointsConfig: () => JD4,
    resolveRegionConfig: () => VD4
  });
  CrA.exports = QD4(ZrA);
  var yL = QrA(),
    DrA = "AWS_USE_DUALSTACK_ENDPOINT",
    YrA = "use_dualstack_endpoint",
    ID4 = !1,
    GD4 = {
      environmentVariableSelector: (A) => yL.booleanSelector(A, DrA, yL.SelectorType.ENV),
      configFileSelector: (A) => yL.booleanSelector(A, YrA, yL.SelectorType.CONFIG),
      default: !1
    },
    WrA = "AWS_USE_FIPS_ENDPOINT",
    JrA = "use_fips_endpoint",
    ZD4 = !1,
    DD4 = {
      environmentVariableSelector: (A) => yL.booleanSelector(A, WrA, yL.SelectorType.ENV),
      configFileSelector: (A) => yL.booleanSelector(A, JrA, yL.SelectorType.CONFIG),
      default: !1
    },
    F71 = ZX(),
    YD4 = $C((A) => {
      let {
        tls: B,
        endpoint: Q,
        urlParser: I,
        useDualstackEndpoint: G
      } = A;
      return Object.assign(A, {
        tls: B ?? !0,
        endpoint: F71.normalizeProvider(typeof Q === "string" ? I(Q) : Q),
        isCustomEndpoint: !0,
        useDualstackEndpoint: F71.normalizeProvider(G ?? !1)
      })
    }, "resolveCustomEndpointsConfig"),
    WD4 = $C(async (A) => {
      let {
        tls: B = !0
      } = A, Q = await A.region();
      if (!new RegExp(/^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])$/).test(Q)) throw new Error("Invalid region in client config");
      let G = await A.useDualstackEndpoint(),
        Z = await A.useFipsEndpoint(),
        {
          hostname: D
        } = await A.regionInfoProvider(Q, {
          useDualstackEndpoint: G,
          useFipsEndpoint: Z
        }) ?? {};
      if (!D) throw new Error("Cannot resolve hostname from client config");
      return A.urlParser(`${B?"https:":"http:"}//${D}`)
    }, "getEndpointFromRegion"),
    JD4 = $C((A) => {
      let B = F71.normalizeProvider(A.useDualstackEndpoint ?? !1),
        {
          endpoint: Q,
          useFipsEndpoint: I,
          urlParser: G,
          tls: Z
        } = A;
      return Object.assign(A, {
        tls: Z ?? !0,
        endpoint: Q ? F71.normalizeProvider(typeof Q === "string" ? G(Q) : Q) : () => WD4({
          ...A,
          useDualstackEndpoint: B,
          useFipsEndpoint: I
        }),
        isCustomEndpoint: !!Q,
        useDualstackEndpoint: B
      })
    }, "resolveEndpointsConfig"),
    FrA = "AWS_REGION",
    XrA = "region",
    FD4 = {
      environmentVariableSelector: (A) => A[FrA],
      configFileSelector: (A) => A[XrA],
      default: () => {
        throw new Error("Region is missing")
      }
    },
    XD4 = {
      preferredFile: "credentials"
    },
    VrA = $C((A) => typeof A === "string" && (A.startsWith("fips-") || A.endsWith("-fips")), "isFipsRegion"),
    IrA = $C((A) => VrA(A) ? ["fips-aws-global", "aws-fips"].includes(A) ? "us-east-1" : A.replace(/fips-(dkr-|prod-)?|-fips/, "") : A, "getRealRegion"),
    VD4 = $C((A) => {
      let {
        region: B,
        useFipsEndpoint: Q
      } = A;
      if (!B) throw new Error("Region is missing");
      return Object.assign(A, {
        region: async () => {
          if (typeof B === "string") return IrA(B);
          let I = await B();
          return IrA(I)
        },
        useFipsEndpoint: async () => {
          let I = typeof B === "string" ? B : await B();
          if (VrA(I)) return !0;
          return typeof Q !== "function" ? Promise.resolve(!!Q) : Q()
        }
      })
    }, "resolveRegionConfig"),
    GrA = $C((A = [], {
      useFipsEndpoint: B,
      useDualstackEndpoint: Q
    }) => A.find(({
      tags: I
    }) => B === I.includes("fips") && Q === I.includes("dualstack"))?.hostname, "getHostnameFromVariants"),
    CD4 = $C((A, {
      regionHostname: B,
      partitionHostname: Q
    }) => B ? B : Q ? Q.replace("{region}", A) : void 0, "getResolvedHostname"),
    KD4 = $C((A, {
      partitionHash: B
    }) => Object.keys(B || {}).find((Q) => B[Q].regions.includes(A)) ?? "aws", "getResolvedPartition"),
    HD4 = $C((A, {
      signingRegion: B,
      regionRegex: Q,
      useFipsEndpoint: I
    }) => {
      if (B) return B;
      else if (I) {
        let G = Q.replace("\\\\", "\\").replace(/^\^/g, "\\.").replace(/\$$/g, "\\."),
          Z = A.match(G);
        if (Z) return Z[0].slice(1, -1)
      }
    }, "getResolvedSigningRegion"),
    zD4 = $C((A, {
      useFipsEndpoint: B = !1,
      useDualstackEndpoint: Q = !1,
      signingService: I,
      regionHash: G,
      partitionHash: Z
    }) => {
      let D = KD4(A, {
          partitionHash: Z
        }),
        Y = A in G ? A : Z[D]?.endpoint ?? A,
        W = {
          useFipsEndpoint: B,
          useDualstackEndpoint: Q
        },
        J = GrA(G[Y]?.variants, W),
        F = GrA(Z[D]?.variants, W),
        X = CD4(Y, {
          regionHostname: J,
          partitionHostname: F
        });
      if (X === void 0) throw new Error(`Endpoint resolution failed for: ${{resolvedRegion:Y,useFipsEndpoint:B,useDualstackEndpoint:Q}}`);
      let V = HD4(X, {
        signingRegion: G[Y]?.signingRegion,
        regionRegex: Z[D].regionRegex,
        useFipsEndpoint: B
      });
      return {
        partition: D,
        signingService: I,
        hostname: X,
        ...V && {
          signingRegion: V
        },
        ...G[Y]?.signingService && {
          signingService: G[Y].signingService
        }
      }
    }, "getRegionInfo")
})
// @from(Start 3335622, End 3338405)
MrA = z((S78, qrA) => {
  var {
    defineProperty: V71,
    getOwnPropertyDescriptor: wD4,
    getOwnPropertyNames: ED4
  } = Object, UD4 = Object.prototype.hasOwnProperty, C71 = (A, B) => V71(A, "name", {
    value: B,
    configurable: !0
  }), ND4 = (A, B) => {
    for (var Q in B) V71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, $D4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of ED4(B))
        if (!UD4.call(A, G) && G !== Q) V71(A, G, {
          get: () => B[G],
          enumerable: !(I = wD4(B, G)) || I.enumerable
        })
    }
    return A
  }, qD4 = (A) => $D4(V71({}, "__esModule", {
    value: !0
  }), A), KrA = {};
  ND4(KrA, {
    AlgorithmId: () => ErA,
    EndpointURLScheme: () => wrA,
    FieldPosition: () => UrA,
    HttpApiKeyAuthLocation: () => zrA,
    HttpAuthLocation: () => HrA,
    IniSectionType: () => NrA,
    RequestHandlerProtocol: () => $rA,
    SMITHY_CONTEXT_KEY: () => TD4,
    getDefaultClientConfiguration: () => RD4,
    resolveDefaultRuntimeConfig: () => OD4
  });
  qrA.exports = qD4(KrA);
  var HrA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(HrA || {}),
    zrA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(zrA || {}),
    wrA = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(wrA || {}),
    ErA = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(ErA || {}),
    MD4 = C71((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    LD4 = C71((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    RD4 = C71((A) => {
      return MD4(A)
    }, "getDefaultClientConfiguration"),
    OD4 = C71((A) => {
      return LD4(A)
    }, "resolveDefaultRuntimeConfig"),
    UrA = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(UrA || {}),
    TD4 = "__smithy_context",
    NrA = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(NrA || {}),
    $rA = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })($rA || {})
})
// @from(Start 3338411, End 3342918)
SrA = z((_78, PrA) => {
  var {
    defineProperty: K71,
    getOwnPropertyDescriptor: PD4,
    getOwnPropertyNames: SD4
  } = Object, _D4 = Object.prototype.hasOwnProperty, kL = (A, B) => K71(A, "name", {
    value: B,
    configurable: !0
  }), jD4 = (A, B) => {
    for (var Q in B) K71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, yD4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of SD4(B))
        if (!_D4.call(A, G) && G !== Q) K71(A, G, {
          get: () => B[G],
          enumerable: !(I = PD4(B, G)) || I.enumerable
        })
    }
    return A
  }, kD4 = (A) => yD4(K71({}, "__esModule", {
    value: !0
  }), A), LrA = {};
  jD4(LrA, {
    Field: () => vD4,
    Fields: () => bD4,
    HttpRequest: () => gD4,
    HttpResponse: () => hD4,
    IHttpRequest: () => RrA.HttpRequest,
    getHttpHandlerExtensionConfiguration: () => xD4,
    isValidHostname: () => TrA,
    resolveHttpHandlerRuntimeConfig: () => fD4
  });
  PrA.exports = kD4(LrA);
  var xD4 = kL((A) => {
      return {
        setHttpHandler(B) {
          A.httpHandler = B
        },
        httpHandler() {
          return A.httpHandler
        },
        updateHttpClientConfig(B, Q) {
          A.httpHandler?.updateHttpClientConfig(B, Q)
        },
        httpHandlerConfigs() {
          return A.httpHandler.httpHandlerConfigs()
        }
      }
    }, "getHttpHandlerExtensionConfiguration"),
    fD4 = kL((A) => {
      return {
        httpHandler: A.httpHandler()
      }
    }, "resolveHttpHandlerRuntimeConfig"),
    RrA = MrA(),
    vD4 = class {
      static {
        kL(this, "Field")
      }
      constructor({
        name: A,
        kind: B = RrA.FieldPosition.HEADER,
        values: Q = []
      }) {
        this.name = A, this.kind = B, this.values = Q
      }
      add(A) {
        this.values.push(A)
      }
      set(A) {
        this.values = A
      }
      remove(A) {
        this.values = this.values.filter((B) => B !== A)
      }
      toString() {
        return this.values.map((A) => A.includes(",") || A.includes(" ") ? `"${A}"` : A).join(", ")
      }
      get() {
        return this.values
      }
    },
    bD4 = class {
      constructor({
        fields: A = [],
        encoding: B = "utf-8"
      }) {
        this.entries = {}, A.forEach(this.setField.bind(this)), this.encoding = B
      }
      static {
        kL(this, "Fields")
      }
      setField(A) {
        this.entries[A.name.toLowerCase()] = A
      }
      getField(A) {
        return this.entries[A.toLowerCase()]
      }
      removeField(A) {
        delete this.entries[A.toLowerCase()]
      }
      getByType(A) {
        return Object.values(this.entries).filter((B) => B.kind === A)
      }
    },
    gD4 = class A {
      static {
        kL(this, "HttpRequest")
      }
      constructor(B) {
        this.method = B.method || "GET", this.hostname = B.hostname || "localhost", this.port = B.port, this.query = B.query || {}, this.headers = B.headers || {}, this.body = B.body, this.protocol = B.protocol ? B.protocol.slice(-1) !== ":" ? `${B.protocol}:` : B.protocol : "https:", this.path = B.path ? B.path.charAt(0) !== "/" ? `/${B.path}` : B.path : "/", this.username = B.username, this.password = B.password, this.fragment = B.fragment
      }
      static clone(B) {
        let Q = new A({
          ...B,
          headers: {
            ...B.headers
          }
        });
        if (Q.query) Q.query = OrA(Q.query);
        return Q
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return "method" in Q && "protocol" in Q && "hostname" in Q && "path" in Q && typeof Q.query === "object" && typeof Q.headers === "object"
      }
      clone() {
        return A.clone(this)
      }
    };

  function OrA(A) {
    return Object.keys(A).reduce((B, Q) => {
      let I = A[Q];
      return {
        ...B,
        [Q]: Array.isArray(I) ? [...I] : I
      }
    }, {})
  }
  kL(OrA, "cloneQuery");
  var hD4 = class {
    static {
      kL(this, "HttpResponse")
    }
    constructor(A) {
      this.statusCode = A.statusCode, this.reason = A.reason, this.headers = A.headers || {}, this.body = A.body
    }
    static isInstance(A) {
      if (!A) return !1;
      let B = A;
      return typeof B.statusCode === "number" && typeof B.headers === "object"
    }
  };

  function TrA(A) {
    return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(A)
  }
  kL(TrA, "isValidHostname")
})
// @from(Start 3342924, End 3344678)
tS = z((x78, xrA) => {
  var {
    defineProperty: H71,
    getOwnPropertyDescriptor: mD4,
    getOwnPropertyNames: dD4
  } = Object, uD4 = Object.prototype.hasOwnProperty, jrA = (A, B) => H71(A, "name", {
    value: B,
    configurable: !0
  }), pD4 = (A, B) => {
    for (var Q in B) H71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, cD4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of dD4(B))
        if (!uD4.call(A, G) && G !== Q) H71(A, G, {
          get: () => B[G],
          enumerable: !(I = mD4(B, G)) || I.enumerable
        })
    }
    return A
  }, lD4 = (A) => cD4(H71({}, "__esModule", {
    value: !0
  }), A), yrA = {};
  pD4(yrA, {
    contentLengthMiddleware: () => Sj1,
    contentLengthMiddlewareOptions: () => krA,
    getContentLengthPlugin: () => nD4
  });
  xrA.exports = lD4(yrA);
  var iD4 = SrA(),
    _rA = "content-length";

  function Sj1(A) {
    return (B) => async (Q) => {
      let I = Q.request;
      if (iD4.HttpRequest.isInstance(I)) {
        let {
          body: G,
          headers: Z
        } = I;
        if (G && Object.keys(Z).map((D) => D.toLowerCase()).indexOf(_rA) === -1) try {
          let D = A(G);
          I.headers = {
            ...I.headers,
            [_rA]: String(D)
          }
        } catch (D) {}
      }
      return B({
        ...Q,
        request: I
      })
    }
  }
  jrA(Sj1, "contentLengthMiddleware");
  var krA = {
      step: "build",
      tags: ["SET_CONTENT_LENGTH", "CONTENT_LENGTH"],
      name: "contentLengthMiddleware",
      override: !0
    },
    nD4 = jrA((A) => ({
      applyToStack: (B) => {
        B.add(Sj1(A.bodyLengthChecker), krA)
      }
    }), "getContentLengthPlugin")
})
// @from(Start 3344684, End 3345316)
zb = z((frA) => {
  Object.defineProperty(frA, "__esModule", {
    value: !0
  });
  frA.getHomeDir = void 0;
  var aD4 = Z1("os"),
    sD4 = Z1("path"),
    _j1 = {},
    rD4 = () => {
      if (process && process.geteuid) return `${process.geteuid()}`;
      return "DEFAULT"
    },
    oD4 = () => {
      let {
        HOME: A,
        USERPROFILE: B,
        HOMEPATH: Q,
        HOMEDRIVE: I = `C:${sD4.sep}`
      } = process.env;
      if (A) return A;
      if (B) return B;
      if (Q) return `${I}${Q}`;
      let G = rD4();
      if (!_j1[G]) _j1[G] = aD4.homedir();
      return _j1[G]
    };
  frA.getHomeDir = oD4
})
// @from(Start 3345322, End 3345705)
jj1 = z((brA) => {
  Object.defineProperty(brA, "__esModule", {
    value: !0
  });
  brA.getSSOTokenFilepath = void 0;
  var tD4 = Z1("crypto"),
    eD4 = Z1("path"),
    AY4 = zb(),
    BY4 = (A) => {
      let Q = tD4.createHash("sha1").update(A).digest("hex");
      return eD4.join(AY4.getHomeDir(), ".aws", "sso", "cache", `${Q}.json`)
    };
  brA.getSSOTokenFilepath = BY4
})
// @from(Start 3345711, End 3346087)
drA = z((hrA) => {
  Object.defineProperty(hrA, "__esModule", {
    value: !0
  });
  hrA.getSSOTokenFromFile = void 0;
  var QY4 = Z1("fs"),
    IY4 = jj1(),
    {
      readFile: GY4
    } = QY4.promises,
    ZY4 = async (A) => {
      let B = IY4.getSSOTokenFilepath(A),
        Q = await GY4(B, "utf8");
      return JSON.parse(Q)
    };
  hrA.getSSOTokenFromFile = ZY4
})
// @from(Start 3346093, End 3348876)
orA = z((g78, rrA) => {
  var {
    defineProperty: z71,
    getOwnPropertyDescriptor: DY4,
    getOwnPropertyNames: YY4
  } = Object, WY4 = Object.prototype.hasOwnProperty, w71 = (A, B) => z71(A, "name", {
    value: B,
    configurable: !0
  }), JY4 = (A, B) => {
    for (var Q in B) z71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, FY4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of YY4(B))
        if (!WY4.call(A, G) && G !== Q) z71(A, G, {
          get: () => B[G],
          enumerable: !(I = DY4(B, G)) || I.enumerable
        })
    }
    return A
  }, XY4 = (A) => FY4(z71({}, "__esModule", {
    value: !0
  }), A), urA = {};
  JY4(urA, {
    AlgorithmId: () => irA,
    EndpointURLScheme: () => lrA,
    FieldPosition: () => nrA,
    HttpApiKeyAuthLocation: () => crA,
    HttpAuthLocation: () => prA,
    IniSectionType: () => arA,
    RequestHandlerProtocol: () => srA,
    SMITHY_CONTEXT_KEY: () => zY4,
    getDefaultClientConfiguration: () => KY4,
    resolveDefaultRuntimeConfig: () => HY4
  });
  rrA.exports = XY4(urA);
  var prA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(prA || {}),
    crA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(crA || {}),
    lrA = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(lrA || {}),
    irA = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(irA || {}),
    VY4 = w71((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    CY4 = w71((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    KY4 = w71((A) => {
      return VY4(A)
    }, "getDefaultClientConfiguration"),
    HY4 = w71((A) => {
      return CY4(A)
    }, "resolveDefaultRuntimeConfig"),
    nrA = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(nrA || {}),
    zY4 = "__smithy_context",
    arA = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(arA || {}),
    srA = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(srA || {})
})
// @from(Start 3348882, End 3349250)
kj1 = z((trA) => {
  Object.defineProperty(trA, "__esModule", {
    value: !0
  });
  trA.slurpFile = void 0;
  var wY4 = Z1("fs"),
    {
      readFile: EY4
    } = wY4.promises,
    yj1 = {},
    UY4 = (A, B) => {
      if (!yj1[A] || (B === null || B === void 0 ? void 0 : B.ignoreCache)) yj1[A] = EY4(A, "utf8");
      return yj1[A]
    };
  trA.slurpFile = UY4
})
// @from(Start 3349256, End 3353948)
xL = z((m78, Ia) => {
  var {
    defineProperty: N71,
    getOwnPropertyDescriptor: NY4,
    getOwnPropertyNames: $Y4
  } = Object, qY4 = Object.prototype.hasOwnProperty, YX = (A, B) => N71(A, "name", {
    value: B,
    configurable: !0
  }), MY4 = (A, B) => {
    for (var Q in B) N71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, xj1 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of $Y4(B))
        if (!qY4.call(A, G) && G !== Q) N71(A, G, {
          get: () => B[G],
          enumerable: !(I = NY4(B, G)) || I.enumerable
        })
    }
    return A
  }, vj1 = (A, B, Q) => (xj1(A, B, "default"), Q && xj1(Q, B, "default")), LY4 = (A) => xj1(N71({}, "__esModule", {
    value: !0
  }), A), Qa = {};
  MY4(Qa, {
    CONFIG_PREFIX_SEPARATOR: () => eS,
    DEFAULT_PROFILE: () => IoA,
    ENV_PROFILE: () => QoA,
    getProfileName: () => RY4,
    loadSharedConfigFiles: () => ZoA,
    loadSsoSessionData: () => gY4,
    parseKnownFiles: () => mY4
  });
  Ia.exports = LY4(Qa);
  vj1(Qa, zb(), Ia.exports);
  var QoA = "AWS_PROFILE",
    IoA = "default",
    RY4 = YX((A) => A.profile || process.env[QoA] || IoA, "getProfileName");
  vj1(Qa, jj1(), Ia.exports);
  vj1(Qa, drA(), Ia.exports);
  var E71 = orA(),
    OY4 = YX((A) => Object.entries(A).filter(([B]) => {
      let Q = B.indexOf(eS);
      if (Q === -1) return !1;
      return Object.values(E71.IniSectionType).includes(B.substring(0, Q))
    }).reduce((B, [Q, I]) => {
      let G = Q.indexOf(eS),
        Z = Q.substring(0, G) === E71.IniSectionType.PROFILE ? Q.substring(G + 1) : Q;
      return B[Z] = I, B
    }, {
      ...A.default && {
        default: A.default
      }
    }), "getConfigData"),
    U71 = Z1("path"),
    TY4 = zb(),
    PY4 = "AWS_CONFIG_FILE",
    GoA = YX(() => process.env[PY4] || U71.join(TY4.getHomeDir(), ".aws", "config"), "getConfigFilepath"),
    SY4 = zb(),
    _Y4 = "AWS_SHARED_CREDENTIALS_FILE",
    jY4 = YX(() => process.env[_Y4] || U71.join(SY4.getHomeDir(), ".aws", "credentials"), "getCredentialsFilepath"),
    yY4 = zb(),
    kY4 = /^([\w-]+)\s(["'])?([\w-@\+\.%:/]+)\2$/,
    xY4 = ["__proto__", "profile __proto__"],
    fj1 = YX((A) => {
      let B = {},
        Q, I;
      for (let G of A.split(/\r?\n/)) {
        let Z = G.split(/(^|\s)[;#]/)[0].trim();
        if (Z[0] === "[" && Z[Z.length - 1] === "]") {
          Q = void 0, I = void 0;
          let Y = Z.substring(1, Z.length - 1),
            W = kY4.exec(Y);
          if (W) {
            let [, J, , F] = W;
            if (Object.values(E71.IniSectionType).includes(J)) Q = [J, F].join(eS)
          } else Q = Y;
          if (xY4.includes(Y)) throw new Error(`Found invalid profile name "${Y}"`)
        } else if (Q) {
          let Y = Z.indexOf("=");
          if (![0, -1].includes(Y)) {
            let [W, J] = [Z.substring(0, Y).trim(), Z.substring(Y + 1).trim()];
            if (J === "") I = W;
            else {
              if (I && G.trimStart() === G) I = void 0;
              B[Q] = B[Q] || {};
              let F = I ? [I, W].join(eS) : W;
              B[Q][F] = J
            }
          }
        }
      }
      return B
    }, "parseIni"),
    AoA = kj1(),
    BoA = YX(() => ({}), "swallowError"),
    eS = ".",
    ZoA = YX(async (A = {}) => {
      let {
        filepath: B = jY4(),
        configFilepath: Q = GoA()
      } = A, I = yY4.getHomeDir(), G = "~/", Z = B;
      if (B.startsWith("~/")) Z = U71.join(I, B.slice(2));
      let D = Q;
      if (Q.startsWith("~/")) D = U71.join(I, Q.slice(2));
      let Y = await Promise.all([AoA.slurpFile(D, {
        ignoreCache: A.ignoreCache
      }).then(fj1).then(OY4).catch(BoA), AoA.slurpFile(Z, {
        ignoreCache: A.ignoreCache
      }).then(fj1).catch(BoA)]);
      return {
        configFile: Y[0],
        credentialsFile: Y[1]
      }
    }, "loadSharedConfigFiles"),
    fY4 = YX((A) => Object.entries(A).filter(([B]) => B.startsWith(E71.IniSectionType.SSO_SESSION + eS)).reduce((B, [Q, I]) => ({
      ...B,
      [Q.substring(Q.indexOf(eS) + 1)]: I
    }), {}), "getSsoSessionData"),
    vY4 = kj1(),
    bY4 = YX(() => ({}), "swallowError"),
    gY4 = YX(async (A = {}) => vY4.slurpFile(A.configFilepath ?? GoA()).then(fj1).then(fY4).catch(bY4), "loadSsoSessionData"),
    hY4 = YX((...A) => {
      let B = {};
      for (let Q of A)
        for (let [I, G] of Object.entries(Q))
          if (B[I] !== void 0) Object.assign(B[I], G);
          else B[I] = G;
      return B
    }, "mergeConfigFiles"),
    mY4 = YX(async (A) => {
      let B = await ZoA(A);
      return hY4(B.configFile, B.credentialsFile)
    }, "parseKnownFiles")
})
// @from(Start 3353954, End 3356450)
qC = z((d78, WoA) => {
  var {
    defineProperty: $71,
    getOwnPropertyDescriptor: dY4,
    getOwnPropertyNames: uY4
  } = Object, pY4 = Object.prototype.hasOwnProperty, wb = (A, B) => $71(A, "name", {
    value: B,
    configurable: !0
  }), cY4 = (A, B) => {
    for (var Q in B) $71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, lY4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of uY4(B))
        if (!pY4.call(A, G) && G !== Q) $71(A, G, {
          get: () => B[G],
          enumerable: !(I = dY4(B, G)) || I.enumerable
        })
    }
    return A
  }, iY4 = (A) => lY4($71({}, "__esModule", {
    value: !0
  }), A), YoA = {};
  cY4(YoA, {
    loadConfig: () => oY4
  });
  WoA.exports = iY4(YoA);
  var Ga = $I();

  function bj1(A) {
    try {
      let B = new Set(Array.from(A.match(/([A-Z_]){3,}/g) ?? []));
      return B.delete("CONFIG"), B.delete("CONFIG_PREFIX_SEPARATOR"), B.delete("ENV"), [...B].join(", ")
    } catch (B) {
      return A
    }
  }
  wb(bj1, "getSelectorName");
  var nY4 = wb((A, B) => async () => {
      try {
        let Q = A(process.env);
        if (Q === void 0) throw new Error;
        return Q
      } catch (Q) {
        throw new Ga.CredentialsProviderError(Q.message || `Not found in ENV: ${bj1(A.toString())}`, {
          logger: B
        })
      }
    }, "fromEnv"),
    DoA = xL(),
    aY4 = wb((A, {
      preferredFile: B = "config",
      ...Q
    } = {}) => async () => {
      let I = DoA.getProfileName(Q),
        {
          configFile: G,
          credentialsFile: Z
        } = await DoA.loadSharedConfigFiles(Q),
        D = Z[I] || {},
        Y = G[I] || {},
        W = B === "config" ? {
          ...D,
          ...Y
        } : {
          ...Y,
          ...D
        };
      try {
        let F = A(W, B === "config" ? G : Z);
        if (F === void 0) throw new Error;
        return F
      } catch (J) {
        throw new Ga.CredentialsProviderError(J.message || `Not found in config files w/ profile [${I}]: ${bj1(A.toString())}`, {
          logger: Q.logger
        })
      }
    }, "fromSharedConfigFiles"),
    sY4 = wb((A) => typeof A === "function", "isFunction"),
    rY4 = wb((A) => sY4(A) ? async () => await A(): Ga.fromStatic(A), "fromStatic"),
    oY4 = wb(({
      environmentVariableSelector: A,
      configFileSelector: B,
      default: Q
    }, I = {}) => Ga.memoize(Ga.chain(nY4(A), aY4(B, I), rY4(Q))), "loadConfig")
})
// @from(Start 3356456, End 3357405)
KoA = z((VoA) => {
  Object.defineProperty(VoA, "__esModule", {
    value: !0
  });
  VoA.getEndpointUrlConfig = void 0;
  var JoA = xL(),
    FoA = "AWS_ENDPOINT_URL",
    XoA = "endpoint_url",
    tY4 = (A) => ({
      environmentVariableSelector: (B) => {
        let Q = A.split(" ").map((Z) => Z.toUpperCase()),
          I = B[[FoA, ...Q].join("_")];
        if (I) return I;
        let G = B[FoA];
        if (G) return G;
        return
      },
      configFileSelector: (B, Q) => {
        if (Q && B.services) {
          let G = Q[["services", B.services].join(JoA.CONFIG_PREFIX_SEPARATOR)];
          if (G) {
            let Z = A.split(" ").map((Y) => Y.toLowerCase()),
              D = G[[Z.join("_"), XoA].join(JoA.CONFIG_PREFIX_SEPARATOR)];
            if (D) return D
          }
        }
        let I = B[XoA];
        if (I) return I;
        return
      },
      default: void 0
    });
  VoA.getEndpointUrlConfig = tY4
})
// @from(Start 3357411, End 3357708)
gj1 = z((HoA) => {
  Object.defineProperty(HoA, "__esModule", {
    value: !0
  });
  HoA.getEndpointFromConfig = void 0;
  var eY4 = qC(),
    AW4 = KoA(),
    BW4 = async (A) => eY4.loadConfig(AW4.getEndpointUrlConfig(A !== null && A !== void 0 ? A : ""))();
  HoA.getEndpointFromConfig = BW4
})
// @from(Start 3357714, End 3358895)
NoA = z((c78, UoA) => {
  var {
    defineProperty: q71,
    getOwnPropertyDescriptor: QW4,
    getOwnPropertyNames: IW4
  } = Object, GW4 = Object.prototype.hasOwnProperty, ZW4 = (A, B) => q71(A, "name", {
    value: B,
    configurable: !0
  }), DW4 = (A, B) => {
    for (var Q in B) q71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, YW4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of IW4(B))
        if (!GW4.call(A, G) && G !== Q) q71(A, G, {
          get: () => B[G],
          enumerable: !(I = QW4(B, G)) || I.enumerable
        })
    }
    return A
  }, WW4 = (A) => YW4(q71({}, "__esModule", {
    value: !0
  }), A), woA = {};
  DW4(woA, {
    parseQueryString: () => EoA
  });
  UoA.exports = WW4(woA);

  function EoA(A) {
    let B = {};
    if (A = A.replace(/^\?/, ""), A)
      for (let Q of A.split("&")) {
        let [I, G = null] = Q.split("=");
        if (I = decodeURIComponent(I), G) G = decodeURIComponent(G);
        if (!(I in B)) B[I] = G;
        else if (Array.isArray(B[I])) B[I].push(G);
        else B[I] = [B[I], G]
      }
    return B
  }
  ZW4(EoA, "parseQueryString")
})
// @from(Start 3358901, End 3360106)
FN = z((l78, MoA) => {
  var {
    defineProperty: M71,
    getOwnPropertyDescriptor: JW4,
    getOwnPropertyNames: FW4
  } = Object, XW4 = Object.prototype.hasOwnProperty, VW4 = (A, B) => M71(A, "name", {
    value: B,
    configurable: !0
  }), CW4 = (A, B) => {
    for (var Q in B) M71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, KW4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of FW4(B))
        if (!XW4.call(A, G) && G !== Q) M71(A, G, {
          get: () => B[G],
          enumerable: !(I = JW4(B, G)) || I.enumerable
        })
    }
    return A
  }, HW4 = (A) => KW4(M71({}, "__esModule", {
    value: !0
  }), A), $oA = {};
  CW4($oA, {
    parseUrl: () => qoA
  });
  MoA.exports = HW4($oA);
  var zW4 = NoA(),
    qoA = VW4((A) => {
      if (typeof A === "string") return qoA(new URL(A));
      let {
        hostname: B,
        pathname: Q,
        port: I,
        protocol: G,
        search: Z
      } = A, D;
      if (Z) D = zW4.parseQueryString(Z);
      return {
        hostname: B,
        port: I ? parseInt(I) : void 0,
        protocol: G,
        path: Q,
        query: D
      }
    }, "parseUrl")
})
// @from(Start 3360112, End 3367113)
hz = z((i78, _oA) => {
  var {
    defineProperty: R71,
    getOwnPropertyDescriptor: wW4,
    getOwnPropertyNames: EW4
  } = Object, UW4 = Object.prototype.hasOwnProperty, MC = (A, B) => R71(A, "name", {
    value: B,
    configurable: !0
  }), NW4 = (A, B) => {
    for (var Q in B) R71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, $W4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of EW4(B))
        if (!UW4.call(A, G) && G !== Q) R71(A, G, {
          get: () => B[G],
          enumerable: !(I = wW4(B, G)) || I.enumerable
        })
    }
    return A
  }, qW4 = (A) => $W4(R71({}, "__esModule", {
    value: !0
  }), A), RoA = {};
  NW4(RoA, {
    endpointMiddleware: () => PoA,
    endpointMiddlewareOptions: () => SoA,
    getEndpointFromInstructions: () => OoA,
    getEndpointPlugin: () => kW4,
    resolveEndpointConfig: () => fW4,
    resolveParams: () => ToA,
    toEndpointV1: () => hj1
  });
  _oA.exports = qW4(RoA);
  var MW4 = MC(async (A) => {
      let B = A?.Bucket || "";
      if (typeof A.Bucket === "string") A.Bucket = B.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?"));
      if (PW4(B)) {
        if (A.ForcePathStyle === !0) throw new Error("Path-style addressing cannot be used with ARN buckets")
      } else if (!TW4(B) || B.indexOf(".") !== -1 && !String(A.Endpoint).startsWith("http:") || B.toLowerCase() !== B || B.length < 3) A.ForcePathStyle = !0;
      if (A.DisableMultiRegionAccessPoints) A.disableMultiRegionAccessPoints = !0, A.DisableMRAP = !0;
      return A
    }, "resolveParamsForS3"),
    LW4 = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/,
    RW4 = /(\d+\.){3}\d+/,
    OW4 = /\.\./,
    TW4 = MC((A) => LW4.test(A) && !RW4.test(A) && !OW4.test(A), "isDnsCompatibleBucketName"),
    PW4 = MC((A) => {
      let [B, Q, I, , , G] = A.split(":"), Z = B === "arn" && A.split(":").length >= 6, D = Boolean(Z && Q && I && G);
      if (Z && !D) throw new Error(`Invalid ARN: ${A} was an invalid ARN.`);
      return D
    }, "isArnBucketName"),
    SW4 = MC((A, B, Q) => {
      let I = MC(async () => {
        let G = Q[A] ?? Q[B];
        if (typeof G === "function") return G();
        return G
      }, "configProvider");
      if (A === "credentialScope" || B === "CredentialScope") return async () => {
        let G = typeof Q.credentials === "function" ? await Q.credentials() : Q.credentials;
        return G?.credentialScope ?? G?.CredentialScope
      };
      if (A === "accountId" || B === "AccountId") return async () => {
        let G = typeof Q.credentials === "function" ? await Q.credentials() : Q.credentials;
        return G?.accountId ?? G?.AccountId
      };
      if (A === "endpoint" || B === "endpoint") return async () => {
        let G = await I();
        if (G && typeof G === "object") {
          if ("url" in G) return G.url.href;
          if ("hostname" in G) {
            let {
              protocol: Z,
              hostname: D,
              port: Y,
              path: W
            } = G;
            return `${Z}//${D}${Y?":"+Y:""}${W}`
          }
        }
        return G
      };
      return I
    }, "createConfigValueProvider"),
    _W4 = gj1(),
    LoA = FN(),
    hj1 = MC((A) => {
      if (typeof A === "object") {
        if ("url" in A) return LoA.parseUrl(A.url);
        return A
      }
      return LoA.parseUrl(A)
    }, "toEndpointV1"),
    OoA = MC(async (A, B, Q, I) => {
      if (!Q.endpoint) {
        let D;
        if (Q.serviceConfiguredEndpoint) D = await Q.serviceConfiguredEndpoint();
        else D = await _W4.getEndpointFromConfig(Q.serviceId);
        if (D) Q.endpoint = () => Promise.resolve(hj1(D))
      }
      let G = await ToA(A, B, Q);
      if (typeof Q.endpointProvider !== "function") throw new Error("config.endpointProvider is not set.");
      return Q.endpointProvider(G, I)
    }, "getEndpointFromInstructions"),
    ToA = MC(async (A, B, Q) => {
      let I = {},
        G = B?.getEndpointParameterInstructions?.() || {};
      for (let [Z, D] of Object.entries(G)) switch (D.type) {
        case "staticContextParams":
          I[Z] = D.value;
          break;
        case "contextParams":
          I[Z] = A[D.name];
          break;
        case "clientContextParams":
        case "builtInParams":
          I[Z] = await SW4(D.name, Z, Q)();
          break;
        case "operationContextParams":
          I[Z] = D.get(A);
          break;
        default:
          throw new Error("Unrecognized endpoint parameter instruction: " + JSON.stringify(D))
      }
      if (Object.keys(G).length === 0) Object.assign(I, Q);
      if (String(Q.serviceId).toLowerCase() === "s3") await MW4(I);
      return I
    }, "resolveParams"),
    jW4 = NI(),
    L71 = ZX(),
    PoA = MC(({
      config: A,
      instructions: B
    }) => {
      return (Q, I) => async (G) => {
        if (A.endpoint) jW4.setFeature(I, "ENDPOINT_OVERRIDE", "N");
        let Z = await OoA(G.input, {
          getEndpointParameterInstructions() {
            return B
          }
        }, {
          ...A
        }, I);
        I.endpointV2 = Z, I.authSchemes = Z.properties?.authSchemes;
        let D = I.authSchemes?.[0];
        if (D) {
          I.signing_region = D.signingRegion, I.signing_service = D.signingName;
          let W = L71.getSmithyContext(I)?.selectedHttpAuthScheme?.httpAuthOption;
          if (W) W.signingProperties = Object.assign(W.signingProperties || {}, {
            signing_region: D.signingRegion,
            signingRegion: D.signingRegion,
            signing_service: D.signingName,
            signingName: D.signingName,
            signingRegionSet: D.signingRegionSet
          }, D.properties)
        }
        return Q({
          ...G
        })
      }
    }, "endpointMiddleware"),
    yW4 = yz(),
    SoA = {
      step: "serialize",
      tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"],
      name: "endpointV2Middleware",
      override: !0,
      relation: "before",
      toMiddleware: yW4.serializerMiddlewareOption.name
    },
    kW4 = MC((A, B) => ({
      applyToStack: (Q) => {
        Q.addRelativeTo(PoA({
          config: A,
          instructions: B
        }), SoA)
      }
    }), "getEndpointPlugin"),
    xW4 = gj1(),
    fW4 = MC((A) => {
      let B = A.tls ?? !0,
        {
          endpoint: Q,
          useDualstackEndpoint: I,
          useFipsEndpoint: G
        } = A,
        Z = Q != null ? async () => hj1(await L71.normalizeProvider(Q)()): void 0, Y = Object.assign(A, {
          endpoint: Z,
          tls: B,
          isCustomEndpoint: !!Q,
          useDualstackEndpoint: L71.normalizeProvider(I ?? !1),
          useFipsEndpoint: L71.normalizeProvider(G ?? !1)
        }), W = void 0;
      return Y.serviceConfiguredEndpoint = async () => {
        if (A.serviceId && !W) W = xW4.getEndpointFromConfig(A.serviceId);
        return W
      }, Y
    }, "resolveEndpointConfig")
})
// @from(Start 3367119, End 3369902)
mj1 = z((n78, hoA) => {
  var {
    defineProperty: O71,
    getOwnPropertyDescriptor: vW4,
    getOwnPropertyNames: bW4
  } = Object, gW4 = Object.prototype.hasOwnProperty, T71 = (A, B) => O71(A, "name", {
    value: B,
    configurable: !0
  }), hW4 = (A, B) => {
    for (var Q in B) O71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, mW4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of bW4(B))
        if (!gW4.call(A, G) && G !== Q) O71(A, G, {
          get: () => B[G],
          enumerable: !(I = vW4(B, G)) || I.enumerable
        })
    }
    return A
  }, dW4 = (A) => mW4(O71({}, "__esModule", {
    value: !0
  }), A), joA = {};
  hW4(joA, {
    AlgorithmId: () => foA,
    EndpointURLScheme: () => xoA,
    FieldPosition: () => voA,
    HttpApiKeyAuthLocation: () => koA,
    HttpAuthLocation: () => yoA,
    IniSectionType: () => boA,
    RequestHandlerProtocol: () => goA,
    SMITHY_CONTEXT_KEY: () => iW4,
    getDefaultClientConfiguration: () => cW4,
    resolveDefaultRuntimeConfig: () => lW4
  });
  hoA.exports = dW4(joA);
  var yoA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(yoA || {}),
    koA = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(koA || {}),
    xoA = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(xoA || {}),
    foA = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(foA || {}),
    uW4 = T71((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    pW4 = T71((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    cW4 = T71((A) => {
      return uW4(A)
    }, "getDefaultClientConfiguration"),
    lW4 = T71((A) => {
      return pW4(A)
    }, "resolveDefaultRuntimeConfig"),
    voA = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(voA || {}),
    iW4 = "__smithy_context",
    boA = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(boA || {}),
    goA = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(goA || {})
})
// @from(Start 3369908, End 3374415)
loA = z((a78, coA) => {
  var {
    defineProperty: P71,
    getOwnPropertyDescriptor: nW4,
    getOwnPropertyNames: aW4
  } = Object, sW4 = Object.prototype.hasOwnProperty, fL = (A, B) => P71(A, "name", {
    value: B,
    configurable: !0
  }), rW4 = (A, B) => {
    for (var Q in B) P71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, oW4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of aW4(B))
        if (!sW4.call(A, G) && G !== Q) P71(A, G, {
          get: () => B[G],
          enumerable: !(I = nW4(B, G)) || I.enumerable
        })
    }
    return A
  }, tW4 = (A) => oW4(P71({}, "__esModule", {
    value: !0
  }), A), moA = {};
  rW4(moA, {
    Field: () => BJ4,
    Fields: () => QJ4,
    HttpRequest: () => IJ4,
    HttpResponse: () => GJ4,
    IHttpRequest: () => doA.HttpRequest,
    getHttpHandlerExtensionConfiguration: () => eW4,
    isValidHostname: () => poA,
    resolveHttpHandlerRuntimeConfig: () => AJ4
  });
  coA.exports = tW4(moA);
  var eW4 = fL((A) => {
      return {
        setHttpHandler(B) {
          A.httpHandler = B
        },
        httpHandler() {
          return A.httpHandler
        },
        updateHttpClientConfig(B, Q) {
          A.httpHandler?.updateHttpClientConfig(B, Q)
        },
        httpHandlerConfigs() {
          return A.httpHandler.httpHandlerConfigs()
        }
      }
    }, "getHttpHandlerExtensionConfiguration"),
    AJ4 = fL((A) => {
      return {
        httpHandler: A.httpHandler()
      }
    }, "resolveHttpHandlerRuntimeConfig"),
    doA = mj1(),
    BJ4 = class {
      static {
        fL(this, "Field")
      }
      constructor({
        name: A,
        kind: B = doA.FieldPosition.HEADER,
        values: Q = []
      }) {
        this.name = A, this.kind = B, this.values = Q
      }
      add(A) {
        this.values.push(A)
      }
      set(A) {
        this.values = A
      }
      remove(A) {
        this.values = this.values.filter((B) => B !== A)
      }
      toString() {
        return this.values.map((A) => A.includes(",") || A.includes(" ") ? `"${A}"` : A).join(", ")
      }
      get() {
        return this.values
      }
    },
    QJ4 = class {
      constructor({
        fields: A = [],
        encoding: B = "utf-8"
      }) {
        this.entries = {}, A.forEach(this.setField.bind(this)), this.encoding = B
      }
      static {
        fL(this, "Fields")
      }
      setField(A) {
        this.entries[A.name.toLowerCase()] = A
      }
      getField(A) {
        return this.entries[A.toLowerCase()]
      }
      removeField(A) {
        delete this.entries[A.toLowerCase()]
      }
      getByType(A) {
        return Object.values(this.entries).filter((B) => B.kind === A)
      }
    },
    IJ4 = class A {
      static {
        fL(this, "HttpRequest")
      }
      constructor(B) {
        this.method = B.method || "GET", this.hostname = B.hostname || "localhost", this.port = B.port, this.query = B.query || {}, this.headers = B.headers || {}, this.body = B.body, this.protocol = B.protocol ? B.protocol.slice(-1) !== ":" ? `${B.protocol}:` : B.protocol : "https:", this.path = B.path ? B.path.charAt(0) !== "/" ? `/${B.path}` : B.path : "/", this.username = B.username, this.password = B.password, this.fragment = B.fragment
      }
      static clone(B) {
        let Q = new A({
          ...B,
          headers: {
            ...B.headers
          }
        });
        if (Q.query) Q.query = uoA(Q.query);
        return Q
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return "method" in Q && "protocol" in Q && "hostname" in Q && "path" in Q && typeof Q.query === "object" && typeof Q.headers === "object"
      }
      clone() {
        return A.clone(this)
      }
    };

  function uoA(A) {
    return Object.keys(A).reduce((B, Q) => {
      let I = A[Q];
      return {
        ...B,
        [Q]: Array.isArray(I) ? [...I] : I
      }
    }, {})
  }
  fL(uoA, "cloneQuery");
  var GJ4 = class {
    static {
      fL(this, "HttpResponse")
    }
    constructor(A) {
      this.statusCode = A.statusCode, this.reason = A.reason, this.headers = A.headers || {}, this.body = A.body
    }
    static isInstance(A) {
      if (!A) return !1;
      let B = A;
      return typeof B.statusCode === "number" && typeof B.headers === "object"
    }
  };

  function poA(A) {
    return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(A)
  }
  fL(poA, "isValidHostname")
})
// @from(Start 3374421, End 3374833)
dj1 = z((ioA) => {
  Object.defineProperty(ioA, "__esModule", {
    value: !0
  });
  ioA.default = YJ4;
  var ZJ4 = DJ4(Z1("crypto"));

  function DJ4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
  var _71 = new Uint8Array(256),
    S71 = _71.length;

  function YJ4() {
    if (S71 > _71.length - 16) ZJ4.default.randomFillSync(_71), S71 = 0;
    return _71.slice(S71, S71 += 16)
  }
})
// @from(Start 3374839, End 3375100)
soA = z((noA) => {
  Object.defineProperty(noA, "__esModule", {
    value: !0
  });
  noA.default = void 0;
  var JJ4 = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
  noA.default = JJ4
})
// @from(Start 3375106, End 3375442)
Za = z((roA) => {
  Object.defineProperty(roA, "__esModule", {
    value: !0
  });
  roA.default = void 0;
  var FJ4 = XJ4(soA());

  function XJ4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function VJ4(A) {
    return typeof A === "string" && FJ4.default.test(A)
  }
  var CJ4 = VJ4;
  roA.default = CJ4
})
// @from(Start 3375448, End 3376272)
Da = z((eoA) => {
  Object.defineProperty(eoA, "__esModule", {
    value: !0
  });
  eoA.default = void 0;
  eoA.unsafeStringify = toA;
  var KJ4 = HJ4(Za());

  function HJ4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
  var OG = [];
  for (let A = 0; A < 256; ++A) OG.push((A + 256).toString(16).slice(1));

  function toA(A, B = 0) {
    return OG[A[B + 0]] + OG[A[B + 1]] + OG[A[B + 2]] + OG[A[B + 3]] + "-" + OG[A[B + 4]] + OG[A[B + 5]] + "-" + OG[A[B + 6]] + OG[A[B + 7]] + "-" + OG[A[B + 8]] + OG[A[B + 9]] + "-" + OG[A[B + 10]] + OG[A[B + 11]] + OG[A[B + 12]] + OG[A[B + 13]] + OG[A[B + 14]] + OG[A[B + 15]]
  }

  function zJ4(A, B = 0) {
    let Q = toA(A, B);
    if (!KJ4.default(Q)) throw TypeError("Stringified UUID is invalid");
    return Q
  }
  var wJ4 = zJ4;
  eoA.default = wJ4
})
// @from(Start 3376278, End 3377815)
GtA = z((QtA) => {
  Object.defineProperty(QtA, "__esModule", {
    value: !0
  });
  QtA.default = void 0;
  var UJ4 = $J4(dj1()),
    NJ4 = Da();

  function $J4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
  var BtA, uj1, pj1 = 0,
    cj1 = 0;

  function qJ4(A, B, Q) {
    let I = B && Q || 0,
      G = B || new Array(16);
    A = A || {};
    let Z = A.node || BtA,
      D = A.clockseq !== void 0 ? A.clockseq : uj1;
    if (Z == null || D == null) {
      let V = A.random || (A.rng || UJ4.default)();
      if (Z == null) Z = BtA = [V[0] | 1, V[1], V[2], V[3], V[4], V[5]];
      if (D == null) D = uj1 = (V[6] << 8 | V[7]) & 16383
    }
    let Y = A.msecs !== void 0 ? A.msecs : Date.now(),
      W = A.nsecs !== void 0 ? A.nsecs : cj1 + 1,
      J = Y - pj1 + (W - cj1) / 1e4;
    if (J < 0 && A.clockseq === void 0) D = D + 1 & 16383;
    if ((J < 0 || Y > pj1) && A.nsecs === void 0) W = 0;
    if (W >= 1e4) throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
    pj1 = Y, cj1 = W, uj1 = D, Y += 12219292800000;
    let F = ((Y & 268435455) * 1e4 + W) % 4294967296;
    G[I++] = F >>> 24 & 255, G[I++] = F >>> 16 & 255, G[I++] = F >>> 8 & 255, G[I++] = F & 255;
    let X = Y / 4294967296 * 1e4 & 268435455;
    G[I++] = X >>> 8 & 255, G[I++] = X & 255, G[I++] = X >>> 24 & 15 | 16, G[I++] = X >>> 16 & 255, G[I++] = D >>> 8 | 128, G[I++] = D & 255;
    for (let V = 0; V < 6; ++V) G[I + V] = Z[V];
    return B || NJ4.unsafeStringify(G)
  }
  var MJ4 = qJ4;
  QtA.default = MJ4
})
// @from(Start 3377821, End 3378699)
lj1 = z((ZtA) => {
  Object.defineProperty(ZtA, "__esModule", {
    value: !0
  });
  ZtA.default = void 0;
  var LJ4 = RJ4(Za());

  function RJ4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function OJ4(A) {
    if (!LJ4.default(A)) throw TypeError("Invalid UUID");
    let B, Q = new Uint8Array(16);
    return Q[0] = (B = parseInt(A.slice(0, 8), 16)) >>> 24, Q[1] = B >>> 16 & 255, Q[2] = B >>> 8 & 255, Q[3] = B & 255, Q[4] = (B = parseInt(A.slice(9, 13), 16)) >>> 8, Q[5] = B & 255, Q[6] = (B = parseInt(A.slice(14, 18), 16)) >>> 8, Q[7] = B & 255, Q[8] = (B = parseInt(A.slice(19, 23), 16)) >>> 8, Q[9] = B & 255, Q[10] = (B = parseInt(A.slice(24, 36), 16)) / 1099511627776 & 255, Q[11] = B / 4294967296 & 255, Q[12] = B >>> 24 & 255, Q[13] = B >>> 16 & 255, Q[14] = B >>> 8 & 255, Q[15] = B & 255, Q
  }
  var TJ4 = OJ4;
  ZtA.default = TJ4
})
// @from(Start 3378705, End 3379965)
ij1 = z((JtA) => {
  Object.defineProperty(JtA, "__esModule", {
    value: !0
  });
  JtA.URL = JtA.DNS = void 0;
  JtA.default = yJ4;
  var PJ4 = Da(),
    SJ4 = _J4(lj1());

  function _J4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function jJ4(A) {
    A = unescape(encodeURIComponent(A));
    let B = [];
    for (let Q = 0; Q < A.length; ++Q) B.push(A.charCodeAt(Q));
    return B
  }
  var YtA = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
  JtA.DNS = YtA;
  var WtA = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
  JtA.URL = WtA;

  function yJ4(A, B, Q) {
    function I(G, Z, D, Y) {
      var W;
      if (typeof G === "string") G = jJ4(G);
      if (typeof Z === "string") Z = SJ4.default(Z);
      if (((W = Z) === null || W === void 0 ? void 0 : W.length) !== 16) throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
      let J = new Uint8Array(16 + G.length);
      if (J.set(Z), J.set(G, Z.length), J = Q(J), J[6] = J[6] & 15 | B, J[8] = J[8] & 63 | 128, D) {
        Y = Y || 0;
        for (let F = 0; F < 16; ++F) D[Y + F] = J[F];
        return D
      }
      return PJ4.unsafeStringify(J)
    }
    try {
      I.name = A
    } catch (G) {}
    return I.DNS = YtA, I.URL = WtA, I
  }
})
// @from(Start 3379971, End 3380429)
CtA = z((XtA) => {
  Object.defineProperty(XtA, "__esModule", {
    value: !0
  });
  XtA.default = void 0;
  var fJ4 = vJ4(Z1("crypto"));

  function vJ4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function bJ4(A) {
    if (Array.isArray(A)) A = Buffer.from(A);
    else if (typeof A === "string") A = Buffer.from(A, "utf8");
    return fJ4.default.createHash("md5").update(A).digest()
  }
  var gJ4 = bJ4;
  XtA.default = gJ4
})
// @from(Start 3380435, End 3380759)
wtA = z((HtA) => {
  Object.defineProperty(HtA, "__esModule", {
    value: !0
  });
  HtA.default = void 0;
  var hJ4 = KtA(ij1()),
    mJ4 = KtA(CtA());

  function KtA(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
  var dJ4 = hJ4.default("v3", 48, mJ4.default),
    uJ4 = dJ4;
  HtA.default = uJ4
})
// @from(Start 3380765, End 3381069)
NtA = z((EtA) => {
  Object.defineProperty(EtA, "__esModule", {
    value: !0
  });
  EtA.default = void 0;
  var pJ4 = cJ4(Z1("crypto"));

  function cJ4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
  var lJ4 = {
    randomUUID: pJ4.default.randomUUID
  };
  EtA.default = lJ4
})
// @from(Start 3381075, End 3381729)
RtA = z((MtA) => {
  Object.defineProperty(MtA, "__esModule", {
    value: !0
  });
  MtA.default = void 0;
  var $tA = qtA(NtA()),
    iJ4 = qtA(dj1()),
    nJ4 = Da();

  function qtA(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function aJ4(A, B, Q) {
    if ($tA.default.randomUUID && !B && !A) return $tA.default.randomUUID();
    A = A || {};
    let I = A.random || (A.rng || iJ4.default)();
    if (I[6] = I[6] & 15 | 64, I[8] = I[8] & 63 | 128, B) {
      Q = Q || 0;
      for (let G = 0; G < 16; ++G) B[Q + G] = I[G];
      return B
    }
    return nJ4.unsafeStringify(I)
  }
  var sJ4 = aJ4;
  MtA.default = sJ4
})
// @from(Start 3381735, End 3382194)
PtA = z((OtA) => {
  Object.defineProperty(OtA, "__esModule", {
    value: !0
  });
  OtA.default = void 0;
  var rJ4 = oJ4(Z1("crypto"));

  function oJ4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function tJ4(A) {
    if (Array.isArray(A)) A = Buffer.from(A);
    else if (typeof A === "string") A = Buffer.from(A, "utf8");
    return rJ4.default.createHash("sha1").update(A).digest()
  }
  var eJ4 = tJ4;
  OtA.default = eJ4
})
// @from(Start 3382200, End 3382524)
ytA = z((_tA) => {
  Object.defineProperty(_tA, "__esModule", {
    value: !0
  });
  _tA.default = void 0;
  var AF4 = StA(ij1()),
    BF4 = StA(PtA());

  function StA(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
  var QF4 = AF4.default("v5", 80, BF4.default),
    IF4 = QF4;
  _tA.default = IF4
})
// @from(Start 3382530, End 3382712)
ftA = z((ktA) => {
  Object.defineProperty(ktA, "__esModule", {
    value: !0
  });
  ktA.default = void 0;
  var GF4 = "00000000-0000-0000-0000-000000000000";
  ktA.default = GF4
})
// @from(Start 3382718, End 3383097)
gtA = z((vtA) => {
  Object.defineProperty(vtA, "__esModule", {
    value: !0
  });
  vtA.default = void 0;
  var ZF4 = DF4(Za());

  function DF4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function YF4(A) {
    if (!ZF4.default(A)) throw TypeError("Invalid UUID");
    return parseInt(A.slice(14, 15), 16)
  }
  var WF4 = YF4;
  vtA.default = WF4
})
// @from(Start 3383103, End 3384517)
htA = z((LC) => {
  Object.defineProperty(LC, "__esModule", {
    value: !0
  });
  Object.defineProperty(LC, "NIL", {
    enumerable: !0,
    get: function() {
      return CF4.default
    }
  });
  Object.defineProperty(LC, "parse", {
    enumerable: !0,
    get: function() {
      return wF4.default
    }
  });
  Object.defineProperty(LC, "stringify", {
    enumerable: !0,
    get: function() {
      return zF4.default
    }
  });
  Object.defineProperty(LC, "v1", {
    enumerable: !0,
    get: function() {
      return JF4.default
    }
  });
  Object.defineProperty(LC, "v3", {
    enumerable: !0,
    get: function() {
      return FF4.default
    }
  });
  Object.defineProperty(LC, "v4", {
    enumerable: !0,
    get: function() {
      return XF4.default
    }
  });
  Object.defineProperty(LC, "v5", {
    enumerable: !0,
    get: function() {
      return VF4.default
    }
  });
  Object.defineProperty(LC, "validate", {
    enumerable: !0,
    get: function() {
      return HF4.default
    }
  });
  Object.defineProperty(LC, "version", {
    enumerable: !0,
    get: function() {
      return KF4.default
    }
  });
  var JF4 = XN(GtA()),
    FF4 = XN(wtA()),
    XF4 = XN(RtA()),
    VF4 = XN(ytA()),
    CF4 = XN(ftA()),
    KF4 = XN(gtA()),
    HF4 = XN(Za()),
    zF4 = XN(Da()),
    wF4 = XN(lj1());

  function XN(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
})
// @from(Start 3384523, End 3386973)
aj1 = z((KI8, utA) => {
  var {
    defineProperty: j71,
    getOwnPropertyDescriptor: EF4,
    getOwnPropertyNames: UF4
  } = Object, NF4 = Object.prototype.hasOwnProperty, Eb = (A, B) => j71(A, "name", {
    value: B,
    configurable: !0
  }), $F4 = (A, B) => {
    for (var Q in B) j71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, qF4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of UF4(B))
        if (!NF4.call(A, G) && G !== Q) j71(A, G, {
          get: () => B[G],
          enumerable: !(I = EF4(B, G)) || I.enumerable
        })
    }
    return A
  }, MF4 = (A) => qF4(j71({}, "__esModule", {
    value: !0
  }), A), mtA = {};
  $F4(mtA, {
    isClockSkewCorrectedError: () => dtA,
    isClockSkewError: () => _F4,
    isRetryableByTrait: () => SF4,
    isServerError: () => yF4,
    isThrottlingError: () => jF4,
    isTransientError: () => nj1
  });
  utA.exports = MF4(mtA);
  var LF4 = ["AuthFailure", "InvalidSignatureException", "RequestExpired", "RequestInTheFuture", "RequestTimeTooSkewed", "SignatureDoesNotMatch"],
    RF4 = ["BandwidthLimitExceeded", "EC2ThrottledException", "LimitExceededException", "PriorRequestNotComplete", "ProvisionedThroughputExceededException", "RequestLimitExceeded", "RequestThrottled", "RequestThrottledException", "SlowDown", "ThrottledException", "Throttling", "ThrottlingException", "TooManyRequestsException", "TransactionInProgressException"],
    OF4 = ["TimeoutError", "RequestTimeout", "RequestTimeoutException"],
    TF4 = [500, 502, 503, 504],
    PF4 = ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT"],
    SF4 = Eb((A) => A.$retryable !== void 0, "isRetryableByTrait"),
    _F4 = Eb((A) => LF4.includes(A.name), "isClockSkewError"),
    dtA = Eb((A) => A.$metadata?.clockSkewCorrected, "isClockSkewCorrectedError"),
    jF4 = Eb((A) => A.$metadata?.httpStatusCode === 429 || RF4.includes(A.name) || A.$retryable?.throttling == !0, "isThrottlingError"),
    nj1 = Eb((A, B = 0) => dtA(A) || OF4.includes(A.name) || PF4.includes(A?.code || "") || TF4.includes(A.$metadata?.httpStatusCode || 0) || A.cause !== void 0 && B <= 10 && nj1(A.cause, B + 1), "isTransientError"),
    yF4 = Eb((A) => {
      if (A.$metadata?.httpStatusCode !== void 0) {
        let B = A.$metadata.httpStatusCode;
        if (500 <= B && B <= 599 && !nj1(A)) return !0;
        return !1
      }
      return !1
    }, "isServerError")
})
// @from(Start 3386979, End 3395865)
vL = z((HI8, otA) => {
  var {
    defineProperty: y71,
    getOwnPropertyDescriptor: kF4,
    getOwnPropertyNames: xF4
  } = Object, fF4 = Object.prototype.hasOwnProperty, RC = (A, B) => y71(A, "name", {
    value: B,
    configurable: !0
  }), vF4 = (A, B) => {
    for (var Q in B) y71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, bF4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of xF4(B))
        if (!fF4.call(A, G) && G !== Q) y71(A, G, {
          get: () => B[G],
          enumerable: !(I = kF4(B, G)) || I.enumerable
        })
    }
    return A
  }, gF4 = (A) => bF4(y71({}, "__esModule", {
    value: !0
  }), A), ctA = {};
  vF4(ctA, {
    AdaptiveRetryStrategy: () => cF4,
    ConfiguredRetryStrategy: () => lF4,
    DEFAULT_MAX_ATTEMPTS: () => sj1,
    DEFAULT_RETRY_DELAY_BASE: () => Ya,
    DEFAULT_RETRY_MODE: () => hF4,
    DefaultRateLimiter: () => itA,
    INITIAL_RETRY_TOKENS: () => rj1,
    INVOCATION_ID_HEADER: () => dF4,
    MAXIMUM_RETRY_DELAY: () => oj1,
    NO_RETRY_INCREMENT: () => rtA,
    REQUEST_HEADER: () => uF4,
    RETRY_COST: () => atA,
    RETRY_MODES: () => ltA,
    StandardRetryStrategy: () => tj1,
    THROTTLING_RETRY_DELAY_BASE: () => ntA,
    TIMEOUT_RETRY_COST: () => stA
  });
  otA.exports = gF4(ctA);
  var ltA = ((A) => {
      return A.STANDARD = "standard", A.ADAPTIVE = "adaptive", A
    })(ltA || {}),
    sj1 = 3,
    hF4 = "standard",
    mF4 = aj1(),
    itA = class A {
      constructor(B) {
        this.currentCapacity = 0, this.enabled = !1, this.lastMaxRate = 0, this.measuredTxRate = 0, this.requestCount = 0, this.lastTimestamp = 0, this.timeWindow = 0, this.beta = B?.beta ?? 0.7, this.minCapacity = B?.minCapacity ?? 1, this.minFillRate = B?.minFillRate ?? 0.5, this.scaleConstant = B?.scaleConstant ?? 0.4, this.smooth = B?.smooth ?? 0.8;
        let Q = this.getCurrentTimeInSeconds();
        this.lastThrottleTime = Q, this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds()), this.fillRate = this.minFillRate, this.maxCapacity = this.minCapacity
      }
      static {
        RC(this, "DefaultRateLimiter")
      }
      static {
        this.setTimeoutFn = setTimeout
      }
      getCurrentTimeInSeconds() {
        return Date.now() / 1000
      }
      async getSendToken() {
        return this.acquireTokenBucket(1)
      }
      async acquireTokenBucket(B) {
        if (!this.enabled) return;
        if (this.refillTokenBucket(), B > this.currentCapacity) {
          let Q = (B - this.currentCapacity) / this.fillRate * 1000;
          await new Promise((I) => A.setTimeoutFn(I, Q))
        }
        this.currentCapacity = this.currentCapacity - B
      }
      refillTokenBucket() {
        let B = this.getCurrentTimeInSeconds();
        if (!this.lastTimestamp) {
          this.lastTimestamp = B;
          return
        }
        let Q = (B - this.lastTimestamp) * this.fillRate;
        this.currentCapacity = Math.min(this.maxCapacity, this.currentCapacity + Q), this.lastTimestamp = B
      }
      updateClientSendingRate(B) {
        let Q;
        if (this.updateMeasuredRate(), mF4.isThrottlingError(B)) {
          let G = !this.enabled ? this.measuredTxRate : Math.min(this.measuredTxRate, this.fillRate);
          this.lastMaxRate = G, this.calculateTimeWindow(), this.lastThrottleTime = this.getCurrentTimeInSeconds(), Q = this.cubicThrottle(G), this.enableTokenBucket()
        } else this.calculateTimeWindow(), Q = this.cubicSuccess(this.getCurrentTimeInSeconds());
        let I = Math.min(Q, 2 * this.measuredTxRate);
        this.updateTokenBucketRate(I)
      }
      calculateTimeWindow() {
        this.timeWindow = this.getPrecise(Math.pow(this.lastMaxRate * (1 - this.beta) / this.scaleConstant, 0.3333333333333333))
      }
      cubicThrottle(B) {
        return this.getPrecise(B * this.beta)
      }
      cubicSuccess(B) {
        return this.getPrecise(this.scaleConstant * Math.pow(B - this.lastThrottleTime - this.timeWindow, 3) + this.lastMaxRate)
      }
      enableTokenBucket() {
        this.enabled = !0
      }
      updateTokenBucketRate(B) {
        this.refillTokenBucket(), this.fillRate = Math.max(B, this.minFillRate), this.maxCapacity = Math.max(B, this.minCapacity), this.currentCapacity = Math.min(this.currentCapacity, this.maxCapacity)
      }
      updateMeasuredRate() {
        let B = this.getCurrentTimeInSeconds(),
          Q = Math.floor(B * 2) / 2;
        if (this.requestCount++, Q > this.lastTxRateBucket) {
          let I = this.requestCount / (Q - this.lastTxRateBucket);
          this.measuredTxRate = this.getPrecise(I * this.smooth + this.measuredTxRate * (1 - this.smooth)), this.requestCount = 0, this.lastTxRateBucket = Q
        }
      }
      getPrecise(B) {
        return parseFloat(B.toFixed(8))
      }
    },
    Ya = 100,
    oj1 = 20000,
    ntA = 500,
    rj1 = 500,
    atA = 5,
    stA = 10,
    rtA = 1,
    dF4 = "amz-sdk-invocation-id",
    uF4 = "amz-sdk-request",
    pF4 = RC(() => {
      let A = Ya;
      return {
        computeNextBackoffDelay: RC((I) => {
          return Math.floor(Math.min(oj1, Math.random() * 2 ** I * A))
        }, "computeNextBackoffDelay"),
        setDelayBase: RC((I) => {
          A = I
        }, "setDelayBase")
      }
    }, "getDefaultRetryBackoffStrategy"),
    ptA = RC(({
      retryDelay: A,
      retryCount: B,
      retryCost: Q
    }) => {
      return {
        getRetryCount: RC(() => B, "getRetryCount"),
        getRetryDelay: RC(() => Math.min(oj1, A), "getRetryDelay"),
        getRetryCost: RC(() => Q, "getRetryCost")
      }
    }, "createDefaultRetryToken"),
    tj1 = class {
      constructor(A) {
        this.maxAttempts = A, this.mode = "standard", this.capacity = rj1, this.retryBackoffStrategy = pF4(), this.maxAttemptsProvider = typeof A === "function" ? A : async () => A
      }
      static {
        RC(this, "StandardRetryStrategy")
      }
      async acquireInitialRetryToken(A) {
        return ptA({
          retryDelay: Ya,
          retryCount: 0
        })
      }
      async refreshRetryTokenForRetry(A, B) {
        let Q = await this.getMaxAttempts();
        if (this.shouldRetry(A, B, Q)) {
          let I = B.errorType;
          this.retryBackoffStrategy.setDelayBase(I === "THROTTLING" ? ntA : Ya);
          let G = this.retryBackoffStrategy.computeNextBackoffDelay(A.getRetryCount()),
            Z = B.retryAfterHint ? Math.max(B.retryAfterHint.getTime() - Date.now() || 0, G) : G,
            D = this.getCapacityCost(I);
          return this.capacity -= D, ptA({
            retryDelay: Z,
            retryCount: A.getRetryCount() + 1,
            retryCost: D
          })
        }
        throw new Error("No retry token available")
      }
      recordSuccess(A) {
        this.capacity = Math.max(rj1, this.capacity + (A.getRetryCost() ?? rtA))
      }
      getCapacity() {
        return this.capacity
      }
      async getMaxAttempts() {
        try {
          return await this.maxAttemptsProvider()
        } catch (A) {
          return console.warn(`Max attempts provider could not resolve. Using default of ${sj1}`), sj1
        }
      }
      shouldRetry(A, B, Q) {
        return A.getRetryCount() + 1 < Q && this.capacity >= this.getCapacityCost(B.errorType) && this.isRetryableError(B.errorType)
      }
      getCapacityCost(A) {
        return A === "TRANSIENT" ? stA : atA
      }
      isRetryableError(A) {
        return A === "THROTTLING" || A === "TRANSIENT"
      }
    },
    cF4 = class {
      constructor(A, B) {
        this.maxAttemptsProvider = A, this.mode = "adaptive";
        let {
          rateLimiter: Q
        } = B ?? {};
        this.rateLimiter = Q ?? new itA, this.standardRetryStrategy = new tj1(A)
      }
      static {
        RC(this, "AdaptiveRetryStrategy")
      }
      async acquireInitialRetryToken(A) {
        return await this.rateLimiter.getSendToken(), this.standardRetryStrategy.acquireInitialRetryToken(A)
      }
      async refreshRetryTokenForRetry(A, B) {
        return this.rateLimiter.updateClientSendingRate(B), this.standardRetryStrategy.refreshRetryTokenForRetry(A, B)
      }
      recordSuccess(A) {
        this.rateLimiter.updateClientSendingRate({}), this.standardRetryStrategy.recordSuccess(A)
      }
    },
    lF4 = class extends tj1 {
      static {
        RC(this, "ConfiguredRetryStrategy")
      }
      constructor(A, B = Ya) {
        super(typeof A === "function" ? A : async () => A);
        if (typeof B === "number") this.computeNextBackoffDelay = () => B;
        else this.computeNextBackoffDelay = B
      }
      async refreshRetryTokenForRetry(A, B) {
        let Q = await super.refreshRetryTokenForRetry(A, B);
        return Q.getRetryDelay = () => this.computeNextBackoffDelay(Q.getRetryCount()), Q
      }
    }
})
// @from(Start 3395871, End 3424409)
zeA = z((UI8, HeA) => {
  var {
    defineProperty: f71,
    getOwnPropertyDescriptor: iF4,
    getOwnPropertyNames: nF4
  } = Object, aF4 = Object.prototype.hasOwnProperty, o0 = (A, B) => f71(A, "name", {
    value: B,
    configurable: !0
  }), sF4 = (A, B) => {
    for (var Q in B) f71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, rF4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of nF4(B))
        if (!aF4.call(A, G) && G !== Q) f71(A, G, {
          get: () => B[G],
          enumerable: !(I = iF4(B, G)) || I.enumerable
        })
    }
    return A
  }, oF4 = (A) => rF4(f71({}, "__esModule", {
    value: !0
  }), A), etA = {};
  sF4(etA, {
    Client: () => tF4,
    Command: () => BeA,
    LazyJsonString: () => A_,
    NoOpLogger: () => aX4,
    SENSITIVE_STRING: () => AX4,
    ServiceException: () => fX4,
    _json: () => Zy1,
    collectBody: () => ej1.collectBody,
    convertMap: () => sX4,
    createAggregatedClient: () => BX4,
    dateToUtcString: () => YeA,
    decorateServiceException: () => WeA,
    emitWarningIfUnsupportedVersion: () => hX4,
    expectBoolean: () => IX4,
    expectByte: () => Gy1,
    expectFloat32: () => k71,
    expectInt: () => ZX4,
    expectInt32: () => Qy1,
    expectLong: () => Fa,
    expectNonNull: () => YX4,
    expectNumber: () => Ja,
    expectObject: () => QeA,
    expectShort: () => Iy1,
    expectString: () => WX4,
    expectUnion: () => JX4,
    extendedEncodeURIComponent: () => ej1.extendedEncodeURIComponent,
    getArrayIfSingleItem: () => iX4,
    getDefaultClientConfiguration: () => cX4,
    getDefaultExtensionConfiguration: () => FeA,
    getValueFromTextNode: () => XeA,
    handleFloat: () => VX4,
    isSerializableHeaderValue: () => nX4,
    limitedParseDouble: () => Wy1,
    limitedParseFloat: () => CX4,
    limitedParseFloat32: () => KX4,
    loadConfigsForDefaultMode: () => gX4,
    logger: () => Xa,
    map: () => Fy1,
    parseBoolean: () => QX4,
    parseEpochTimestamp: () => OX4,
    parseRfc3339DateTime: () => UX4,
    parseRfc3339DateTimeWithOffset: () => $X4,
    parseRfc7231DateTime: () => RX4,
    quoteHeader: () => CeA,
    resolveDefaultRuntimeConfig: () => lX4,
    resolvedPath: () => ej1.resolvedPath,
    serializeDateTime: () => BV4,
    serializeFloat: () => AV4,
    splitEvery: () => KeA,
    splitHeader: () => QV4,
    strictParseByte: () => DeA,
    strictParseDouble: () => Yy1,
    strictParseFloat: () => FX4,
    strictParseFloat32: () => IeA,
    strictParseInt: () => HX4,
    strictParseInt32: () => zX4,
    strictParseLong: () => ZeA,
    strictParseShort: () => Ub,
    take: () => rX4,
    throwDefaultError: () => JeA,
    withBaseException: () => vX4
  });
  HeA.exports = oF4(etA);
  var AeA = WN(),
    tF4 = class {
      constructor(A) {
        this.config = A, this.middlewareStack = AeA.constructStack()
      }
      static {
        o0(this, "Client")
      }
      send(A, B, Q) {
        let I = typeof B !== "function" ? B : void 0,
          G = typeof B === "function" ? B : Q,
          Z = I === void 0 && this.config.cacheMiddleware === !0,
          D;
        if (Z) {
          if (!this.handlers) this.handlers = new WeakMap;
          let Y = this.handlers;
          if (Y.has(A.constructor)) D = Y.get(A.constructor);
          else D = A.resolveMiddleware(this.middlewareStack, this.config, I), Y.set(A.constructor, D)
        } else delete this.handlers, D = A.resolveMiddleware(this.middlewareStack, this.config, I);
        if (G) D(A).then((Y) => G(null, Y.output), (Y) => G(Y)).catch(() => {});
        else return D(A).then((Y) => Y.output)
      }
      destroy() {
        this.config?.requestHandler?.destroy?.(), delete this.handlers
      }
    },
    ej1 = vz(),
    By1 = mj1(),
    BeA = class {
      constructor() {
        this.middlewareStack = AeA.constructStack()
      }
      static {
        o0(this, "Command")
      }
      static classBuilder() {
        return new eF4
      }
      resolveMiddlewareWithContext(A, B, Q, {
        middlewareFn: I,
        clientName: G,
        commandName: Z,
        inputFilterSensitiveLog: D,
        outputFilterSensitiveLog: Y,
        smithyContext: W,
        additionalContext: J,
        CommandCtor: F
      }) {
        for (let E of I.bind(this)(F, A, B, Q)) this.middlewareStack.use(E);
        let X = A.concat(this.middlewareStack),
          {
            logger: V
          } = B,
          C = {
            logger: V,
            clientName: G,
            commandName: Z,
            inputFilterSensitiveLog: D,
            outputFilterSensitiveLog: Y,
            [By1.SMITHY_CONTEXT_KEY]: {
              commandInstance: this,
              ...W
            },
            ...J
          },
          {
            requestHandler: K
          } = B;
        return X.resolve((E) => K.handle(E.request, Q || {}), C)
      }
    },
    eF4 = class {
      constructor() {
        this._init = () => {}, this._ep = {}, this._middlewareFn = () => [], this._commandName = "", this._clientName = "", this._additionalContext = {}, this._smithyContext = {}, this._inputFilterSensitiveLog = (A) => A, this._outputFilterSensitiveLog = (A) => A, this._serializer = null, this._deserializer = null
      }
      static {
        o0(this, "ClassBuilder")
      }
      init(A) {
        this._init = A
      }
      ep(A) {
        return this._ep = A, this
      }
      m(A) {
        return this._middlewareFn = A, this
      }
      s(A, B, Q = {}) {
        return this._smithyContext = {
          service: A,
          operation: B,
          ...Q
        }, this
      }
      c(A = {}) {
        return this._additionalContext = A, this
      }
      n(A, B) {
        return this._clientName = A, this._commandName = B, this
      }
      f(A = (Q) => Q, B = (Q) => Q) {
        return this._inputFilterSensitiveLog = A, this._outputFilterSensitiveLog = B, this
      }
      ser(A) {
        return this._serializer = A, this
      }
      de(A) {
        return this._deserializer = A, this
      }
      build() {
        let A = this,
          B;
        return B = class extends BeA {
          constructor(...[Q]) {
            super();
            this.serialize = A._serializer, this.deserialize = A._deserializer, this.input = Q ?? {}, A._init(this)
          }
          static {
            o0(this, "CommandRef")
          }
          static getEndpointParameterInstructions() {
            return A._ep
          }
          resolveMiddleware(Q, I, G) {
            return this.resolveMiddlewareWithContext(Q, I, G, {
              CommandCtor: B,
              middlewareFn: A._middlewareFn,
              clientName: A._clientName,
              commandName: A._commandName,
              inputFilterSensitiveLog: A._inputFilterSensitiveLog,
              outputFilterSensitiveLog: A._outputFilterSensitiveLog,
              smithyContext: A._smithyContext,
              additionalContext: A._additionalContext
            })
          }
        }
      }
    },
    AX4 = "***SensitiveInformation***",
    BX4 = o0((A, B) => {
      for (let Q of Object.keys(A)) {
        let I = A[Q],
          G = o0(async function(D, Y, W) {
            let J = new I(D);
            if (typeof Y === "function") this.send(J, Y);
            else if (typeof W === "function") {
              if (typeof Y !== "object") throw new Error(`Expected http options but got ${typeof Y}`);
              this.send(J, Y || {}, W)
            } else return this.send(J, Y)
          }, "methodImpl"),
          Z = (Q[0].toLowerCase() + Q.slice(1)).replace(/Command$/, "");
        B.prototype[Z] = G
      }
    }, "createAggregatedClient"),
    QX4 = o0((A) => {
      switch (A) {
        case "true":
          return !0;
        case "false":
          return !1;
        default:
          throw new Error(`Unable to parse boolean value "${A}"`)
      }
    }, "parseBoolean"),
    IX4 = o0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "number") {
        if (A === 0 || A === 1) Xa.warn(x71(`Expected boolean, got ${typeof A}: ${A}`));
        if (A === 0) return !1;
        if (A === 1) return !0
      }
      if (typeof A === "string") {
        let B = A.toLowerCase();
        if (B === "false" || B === "true") Xa.warn(x71(`Expected boolean, got ${typeof A}: ${A}`));
        if (B === "false") return !1;
        if (B === "true") return !0
      }
      if (typeof A === "boolean") return A;
      throw new TypeError(`Expected boolean, got ${typeof A}: ${A}`)
    }, "expectBoolean"),
    Ja = o0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "string") {
        let B = parseFloat(A);
        if (!Number.isNaN(B)) {
          if (String(B) !== String(A)) Xa.warn(x71(`Expected number but observed string: ${A}`));
          return B
        }
      }
      if (typeof A === "number") return A;
      throw new TypeError(`Expected number, got ${typeof A}: ${A}`)
    }, "expectNumber"),
    GX4 = Math.ceil(340282346638528860000000000000000000000),
    k71 = o0((A) => {
      let B = Ja(A);
      if (B !== void 0 && !Number.isNaN(B) && B !== 1 / 0 && B !== -1 / 0) {
        if (Math.abs(B) > GX4) throw new TypeError(`Expected 32-bit float, got ${A}`)
      }
      return B
    }, "expectFloat32"),
    Fa = o0((A) => {
      if (A === null || A === void 0) return;
      if (Number.isInteger(A) && !Number.isNaN(A)) return A;
      throw new TypeError(`Expected integer, got ${typeof A}: ${A}`)
    }, "expectLong"),
    ZX4 = Fa,
    Qy1 = o0((A) => Dy1(A, 32), "expectInt32"),
    Iy1 = o0((A) => Dy1(A, 16), "expectShort"),
    Gy1 = o0((A) => Dy1(A, 8), "expectByte"),
    Dy1 = o0((A, B) => {
      let Q = Fa(A);
      if (Q !== void 0 && DX4(Q, B) !== Q) throw new TypeError(`Expected ${B}-bit integer, got ${A}`);
      return Q
    }, "expectSizedInt"),
    DX4 = o0((A, B) => {
      switch (B) {
        case 32:
          return Int32Array.of(A)[0];
        case 16:
          return Int16Array.of(A)[0];
        case 8:
          return Int8Array.of(A)[0]
      }
    }, "castInt"),
    YX4 = o0((A, B) => {
      if (A === null || A === void 0) {
        if (B) throw new TypeError(`Expected a non-null value for ${B}`);
        throw new TypeError("Expected a non-null value")
      }
      return A
    }, "expectNonNull"),
    QeA = o0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "object" && !Array.isArray(A)) return A;
      let B = Array.isArray(A) ? "array" : typeof A;
      throw new TypeError(`Expected object, got ${B}: ${A}`)
    }, "expectObject"),
    WX4 = o0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "string") return A;
      if (["boolean", "number", "bigint"].includes(typeof A)) return Xa.warn(x71(`Expected string, got ${typeof A}: ${A}`)), String(A);
      throw new TypeError(`Expected string, got ${typeof A}: ${A}`)
    }, "expectString"),
    JX4 = o0((A) => {
      if (A === null || A === void 0) return;
      let B = QeA(A),
        Q = Object.entries(B).filter(([, I]) => I != null).map(([I]) => I);
      if (Q.length === 0) throw new TypeError("Unions must have exactly one non-null member. None were found.");
      if (Q.length > 1) throw new TypeError(`Unions must have exactly one non-null member. Keys ${Q} were not null.`);
      return B
    }, "expectUnion"),
    Yy1 = o0((A) => {
      if (typeof A == "string") return Ja($b(A));
      return Ja(A)
    }, "strictParseDouble"),
    FX4 = Yy1,
    IeA = o0((A) => {
      if (typeof A == "string") return k71($b(A));
      return k71(A)
    }, "strictParseFloat32"),
    XX4 = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g,
    $b = o0((A) => {
      let B = A.match(XX4);
      if (B === null || B[0].length !== A.length) throw new TypeError("Expected real number, got implicit NaN");
      return parseFloat(A)
    }, "parseNumber"),
    Wy1 = o0((A) => {
      if (typeof A == "string") return GeA(A);
      return Ja(A)
    }, "limitedParseDouble"),
    VX4 = Wy1,
    CX4 = Wy1,
    KX4 = o0((A) => {
      if (typeof A == "string") return GeA(A);
      return k71(A)
    }, "limitedParseFloat32"),
    GeA = o0((A) => {
      switch (A) {
        case "NaN":
          return NaN;
        case "Infinity":
          return 1 / 0;
        case "-Infinity":
          return -1 / 0;
        default:
          throw new Error(`Unable to parse float value: ${A}`)
      }
    }, "parseFloatString"),
    ZeA = o0((A) => {
      if (typeof A === "string") return Fa($b(A));
      return Fa(A)
    }, "strictParseLong"),
    HX4 = ZeA,
    zX4 = o0((A) => {
      if (typeof A === "string") return Qy1($b(A));
      return Qy1(A)
    }, "strictParseInt32"),
    Ub = o0((A) => {
      if (typeof A === "string") return Iy1($b(A));
      return Iy1(A)
    }, "strictParseShort"),
    DeA = o0((A) => {
      if (typeof A === "string") return Gy1($b(A));
      return Gy1(A)
    }, "strictParseByte"),
    x71 = o0((A) => {
      return String(new TypeError(A).stack || A).split(`
`).slice(0, 5).filter((B) => !B.includes("stackTraceWarning")).join(`
`)
    }, "stackTraceWarning"),
    Xa = {
      warn: console.warn
    },
    wX4 = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
    Jy1 = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];

  function YeA(A) {
    let B = A.getUTCFullYear(),
      Q = A.getUTCMonth(),
      I = A.getUTCDay(),
      G = A.getUTCDate(),
      Z = A.getUTCHours(),
      D = A.getUTCMinutes(),
      Y = A.getUTCSeconds(),
      W = G < 10 ? `0${G}` : `${G}`,
      J = Z < 10 ? `0${Z}` : `${Z}`,
      F = D < 10 ? `0${D}` : `${D}`,
      X = Y < 10 ? `0${Y}` : `${Y}`;
    return `${wX4[I]}, ${W} ${Jy1[Q]} ${B} ${J}:${F}:${X} GMT`
  }
  o0(YeA, "dateToUtcString");
  var EX4 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/),
    UX4 = o0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-3339 date-times must be expressed as strings");
      let B = EX4.exec(A);
      if (!B) throw new TypeError("Invalid RFC-3339 date-time value");
      let [Q, I, G, Z, D, Y, W, J] = B, F = Ub(Nb(I)), X = mz(G, "month", 1, 12), V = mz(Z, "day", 1, 31);
      return Wa(F, X, V, {
        hours: D,
        minutes: Y,
        seconds: W,
        fractionalMilliseconds: J
      })
    }, "parseRfc3339DateTime"),
    NX4 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/),
    $X4 = o0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-3339 date-times must be expressed as strings");
      let B = NX4.exec(A);
      if (!B) throw new TypeError("Invalid RFC-3339 date-time value");
      let [Q, I, G, Z, D, Y, W, J, F] = B, X = Ub(Nb(I)), V = mz(G, "month", 1, 12), C = mz(Z, "day", 1, 31), K = Wa(X, V, C, {
        hours: D,
        minutes: Y,
        seconds: W,
        fractionalMilliseconds: J
      });
      if (F.toUpperCase() != "Z") K.setTime(K.getTime() - xX4(F));
      return K
    }, "parseRfc3339DateTimeWithOffset"),
    qX4 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/),
    MX4 = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/),
    LX4 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/),
    RX4 = o0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-7231 date-times must be expressed as strings");
      let B = qX4.exec(A);
      if (B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return Wa(Ub(Nb(Z)), Ay1(G), mz(I, "day", 1, 31), {
          hours: D,
          minutes: Y,
          seconds: W,
          fractionalMilliseconds: J
        })
      }
      if (B = MX4.exec(A), B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return SX4(Wa(TX4(Z), Ay1(G), mz(I, "day", 1, 31), {
          hours: D,
          minutes: Y,
          seconds: W,
          fractionalMilliseconds: J
        }))
      }
      if (B = LX4.exec(A), B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return Wa(Ub(Nb(J)), Ay1(I), mz(G.trimLeft(), "day", 1, 31), {
          hours: Z,
          minutes: D,
          seconds: Y,
          fractionalMilliseconds: W
        })
      }
      throw new TypeError("Invalid RFC-7231 date-time value")
    }, "parseRfc7231DateTime"),
    OX4 = o0((A) => {
      if (A === null || A === void 0) return;
      let B;
      if (typeof A === "number") B = A;
      else if (typeof A === "string") B = Yy1(A);
      else if (typeof A === "object" && A.tag === 1) B = A.value;
      else throw new TypeError("Epoch timestamps must be expressed as floating point numbers or their string representation");
      if (Number.isNaN(B) || B === 1 / 0 || B === -1 / 0) throw new TypeError("Epoch timestamps must be valid, non-Infinite, non-NaN numerics");
      return new Date(Math.round(B * 1000))
    }, "parseEpochTimestamp"),
    Wa = o0((A, B, Q, I) => {
      let G = B - 1;
      return jX4(A, G, Q), new Date(Date.UTC(A, G, Q, mz(I.hours, "hour", 0, 23), mz(I.minutes, "minute", 0, 59), mz(I.seconds, "seconds", 0, 60), kX4(I.fractionalMilliseconds)))
    }, "buildDate"),
    TX4 = o0((A) => {
      let B = new Date().getUTCFullYear(),
        Q = Math.floor(B / 100) * 100 + Ub(Nb(A));
      if (Q < B) return Q + 100;
      return Q
    }, "parseTwoDigitYear"),
    PX4 = 1576800000000,
    SX4 = o0((A) => {
      if (A.getTime() - new Date().getTime() > PX4) return new Date(Date.UTC(A.getUTCFullYear() - 100, A.getUTCMonth(), A.getUTCDate(), A.getUTCHours(), A.getUTCMinutes(), A.getUTCSeconds(), A.getUTCMilliseconds()));
      return A
    }, "adjustRfc850Year"),
    Ay1 = o0((A) => {
      let B = Jy1.indexOf(A);
      if (B < 0) throw new TypeError(`Invalid month: ${A}`);
      return B + 1
    }, "parseMonthByShortName"),
    _X4 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
    jX4 = o0((A, B, Q) => {
      let I = _X4[B];
      if (B === 1 && yX4(A)) I = 29;
      if (Q > I) throw new TypeError(`Invalid day for ${Jy1[B]} in ${A}: ${Q}`)
    }, "validateDayOfMonth"),
    yX4 = o0((A) => {
      return A % 4 === 0 && (A % 100 !== 0 || A % 400 === 0)
    }, "isLeapYear"),
    mz = o0((A, B, Q, I) => {
      let G = DeA(Nb(A));
      if (G < Q || G > I) throw new TypeError(`${B} must be between ${Q} and ${I}, inclusive`);
      return G
    }, "parseDateValue"),
    kX4 = o0((A) => {
      if (A === null || A === void 0) return 0;
      return IeA("0." + A) * 1000
    }, "parseMilliseconds"),
    xX4 = o0((A) => {
      let B = A[0],
        Q = 1;
      if (B == "+") Q = 1;
      else if (B == "-") Q = -1;
      else throw new TypeError(`Offset direction, ${B}, must be "+" or "-"`);
      let I = Number(A.substring(1, 3)),
        G = Number(A.substring(4, 6));
      return Q * (I * 60 + G) * 60 * 1000
    }, "parseOffsetToMilliseconds"),
    Nb = o0((A) => {
      let B = 0;
      while (B < A.length - 1 && A.charAt(B) === "0") B++;
      if (B === 0) return A;
      return A.slice(B)
    }, "stripLeadingZeroes"),
    fX4 = class A extends Error {
      static {
        o0(this, "ServiceException")
      }
      constructor(B) {
        super(B.message);
        Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype), this.name = B.name, this.$fault = B.$fault, this.$metadata = B.$metadata
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return A.prototype.isPrototypeOf(Q) || Boolean(Q.$fault) && Boolean(Q.$metadata) && (Q.$fault === "client" || Q.$fault === "server")
      }
      static[Symbol.hasInstance](B) {
        if (!B) return !1;
        let Q = B;
        if (this === A) return A.isInstance(B);
        if (A.isInstance(B)) {
          if (Q.name && this.name) return this.prototype.isPrototypeOf(B) || Q.name === this.name;
          return this.prototype.isPrototypeOf(B)
        }
        return !1
      }
    },
    WeA = o0((A, B = {}) => {
      Object.entries(B).filter(([, I]) => I !== void 0).forEach(([I, G]) => {
        if (A[I] == null || A[I] === "") A[I] = G
      });
      let Q = A.message || A.Message || "UnknownError";
      return A.message = Q, delete A.Message, A
    }, "decorateServiceException"),
    JeA = o0(({
      output: A,
      parsedBody: B,
      exceptionCtor: Q,
      errorCode: I
    }) => {
      let G = bX4(A),
        Z = G.httpStatusCode ? G.httpStatusCode + "" : void 0,
        D = new Q({
          name: B?.code || B?.Code || I || Z || "UnknownError",
          $fault: "client",
          $metadata: G
        });
      throw WeA(D, B)
    }, "throwDefaultError"),
    vX4 = o0((A) => {
      return ({
        output: B,
        parsedBody: Q,
        errorCode: I
      }) => {
        JeA({
          output: B,
          parsedBody: Q,
          exceptionCtor: A,
          errorCode: I
        })
      }
    }, "withBaseException"),
    bX4 = o0((A) => ({
      httpStatusCode: A.statusCode,
      requestId: A.headers["x-amzn-requestid"] ?? A.headers["x-amzn-request-id"] ?? A.headers["x-amz-request-id"],
      extendedRequestId: A.headers["x-amz-id-2"],
      cfId: A.headers["x-amz-cf-id"]
    }), "deserializeMetadata"),
    gX4 = o0((A) => {
      switch (A) {
        case "standard":
          return {
            retryMode: "standard", connectionTimeout: 3100
          };
        case "in-region":
          return {
            retryMode: "standard", connectionTimeout: 1100
          };
        case "cross-region":
          return {
            retryMode: "standard", connectionTimeout: 3100
          };
        case "mobile":
          return {
            retryMode: "standard", connectionTimeout: 30000
          };
        default:
          return {}
      }
    }, "loadConfigsForDefaultMode"),
    ttA = !1,
    hX4 = o0((A) => {
      if (A && !ttA && parseInt(A.substring(1, A.indexOf("."))) < 16) ttA = !0
    }, "emitWarningIfUnsupportedVersion"),
    mX4 = o0((A) => {
      let B = [];
      for (let Q in By1.AlgorithmId) {
        let I = By1.AlgorithmId[Q];
        if (A[I] === void 0) continue;
        B.push({
          algorithmId: () => I,
          checksumConstructor: () => A[I]
        })
      }
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    dX4 = o0((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    uX4 = o0((A) => {
      return {
        setRetryStrategy(B) {
          A.retryStrategy = B
        },
        retryStrategy() {
          return A.retryStrategy
        }
      }
    }, "getRetryConfiguration"),
    pX4 = o0((A) => {
      let B = {};
      return B.retryStrategy = A.retryStrategy(), B
    }, "resolveRetryRuntimeConfig"),
    FeA = o0((A) => {
      return Object.assign(mX4(A), uX4(A))
    }, "getDefaultExtensionConfiguration"),
    cX4 = FeA,
    lX4 = o0((A) => {
      return Object.assign(dX4(A), pX4(A))
    }, "resolveDefaultRuntimeConfig"),
    iX4 = o0((A) => Array.isArray(A) ? A : [A], "getArrayIfSingleItem"),
    XeA = o0((A) => {
      for (let Q in A)
        if (A.hasOwnProperty(Q) && A[Q]["#text"] !== void 0) A[Q] = A[Q]["#text"];
        else if (typeof A[Q] === "object" && A[Q] !== null) A[Q] = XeA(A[Q]);
      return A
    }, "getValueFromTextNode"),
    nX4 = o0((A) => {
      return A != null
    }, "isSerializableHeaderValue"),
    A_ = o0(function A(B) {
      return Object.assign(new String(B), {
        deserializeJSON() {
          return JSON.parse(String(B))
        },
        toString() {
          return String(B)
        },
        toJSON() {
          return String(B)
        }
      })
    }, "LazyJsonString");
  A_.from = (A) => {
    if (A && typeof A === "object" && (A instanceof A_ || ("deserializeJSON" in A))) return A;
    else if (typeof A === "string" || Object.getPrototypeOf(A) === String.prototype) return A_(String(A));
    return A_(JSON.stringify(A))
  };
  A_.fromObject = A_.from;
  var aX4 = class {
    static {
      o0(this, "NoOpLogger")
    }
    trace() {}
    debug() {}
    info() {}
    warn() {}
    error() {}
  };

  function Fy1(A, B, Q) {
    let I, G, Z;
    if (typeof B === "undefined" && typeof Q === "undefined") I = {}, Z = A;
    else if (I = A, typeof B === "function") return G = B, Z = Q, oX4(I, G, Z);
    else Z = B;
    for (let D of Object.keys(Z)) {
      if (!Array.isArray(Z[D])) {
        I[D] = Z[D];
        continue
      }
      VeA(I, null, Z, D)
    }
    return I
  }
  o0(Fy1, "map");
  var sX4 = o0((A) => {
      let B = {};
      for (let [Q, I] of Object.entries(A || {})) B[Q] = [, I];
      return B
    }, "convertMap"),
    rX4 = o0((A, B) => {
      let Q = {};
      for (let I in B) VeA(Q, A, B, I);
      return Q
    }, "take"),
    oX4 = o0((A, B, Q) => {
      return Fy1(A, Object.entries(Q).reduce((I, [G, Z]) => {
        if (Array.isArray(Z)) I[G] = Z;
        else if (typeof Z === "function") I[G] = [B, Z()];
        else I[G] = [B, Z];
        return I
      }, {}))
    }, "mapWithFilter"),
    VeA = o0((A, B, Q, I) => {
      if (B !== null) {
        let D = Q[I];
        if (typeof D === "function") D = [, D];
        let [Y = tX4, W = eX4, J = I] = D;
        if (typeof Y === "function" && Y(B[J]) || typeof Y !== "function" && !!Y) A[I] = W(B[J]);
        return
      }
      let [G, Z] = Q[I];
      if (typeof Z === "function") {
        let D, Y = G === void 0 && (D = Z()) != null,
          W = typeof G === "function" && !!G(void 0) || typeof G !== "function" && !!G;
        if (Y) A[I] = D;
        else if (W) A[I] = Z()
      } else {
        let D = G === void 0 && Z != null,
          Y = typeof G === "function" && !!G(Z) || typeof G !== "function" && !!G;
        if (D || Y) A[I] = Z
      }
    }, "applyInstruction"),
    tX4 = o0((A) => A != null, "nonNullish"),
    eX4 = o0((A) => A, "pass");

  function CeA(A) {
    if (A.includes(",") || A.includes('"')) A = `"${A.replace(/"/g,"\\\"")}"`;
    return A
  }
  o0(CeA, "quoteHeader");
  var AV4 = o0((A) => {
      if (A !== A) return "NaN";
      switch (A) {
        case 1 / 0:
          return "Infinity";
        case -1 / 0:
          return "-Infinity";
        default:
          return A
      }
    }, "serializeFloat"),
    BV4 = o0((A) => A.toISOString().replace(".000Z", "Z"), "serializeDateTime"),
    Zy1 = o0((A) => {
      if (A == null) return {};
      if (Array.isArray(A)) return A.filter((B) => B != null).map(Zy1);
      if (typeof A === "object") {
        let B = {};
        for (let Q of Object.keys(A)) {
          if (A[Q] == null) continue;
          B[Q] = Zy1(A[Q])
        }
        return B
      }
      return A
    }, "_json");

  function KeA(A, B, Q) {
    if (Q <= 0 || !Number.isInteger(Q)) throw new Error("Invalid number of delimiters (" + Q + ") for splitEvery.");
    let I = A.split(B);
    if (Q === 1) return I;
    let G = [],
      Z = "";
    for (let D = 0; D < I.length; D++) {
      if (Z === "") Z = I[D];
      else Z += B + I[D];
      if ((D + 1) % Q === 0) G.push(Z), Z = ""
    }
    if (Z !== "") G.push(Z);
    return G
  }
  o0(KeA, "splitEvery");
  var QV4 = o0((A) => {
    let B = A.length,
      Q = [],
      I = !1,
      G = void 0,
      Z = 0;
    for (let D = 0; D < B; ++D) {
      let Y = A[D];
      switch (Y) {
        case '"':
          if (G !== "\\") I = !I;
          break;
        case ",":
          if (!I) Q.push(A.slice(Z, D)), Z = D + 1;
          break;
        default:
      }
      G = Y
    }
    return Q.push(A.slice(Z)), Q.map((D) => {
      D = D.trim();
      let Y = D.length;
      if (Y < 2) return D;
      if (D[0] === '"' && D[Y - 1] === '"') D = D.slice(1, Y - 1);
      return D.replace(/\\"/g, '"')
    })
  }, "splitHeader")
})
// @from(Start 3424415, End 3424799)
UeA = z((weA) => {
  Object.defineProperty(weA, "__esModule", {
    value: !0
  });
  weA.isStreamingPayload = void 0;
  var IV4 = Z1("stream"),
    GV4 = (A) => (A === null || A === void 0 ? void 0 : A.body) instanceof IV4.Readable || typeof ReadableStream !== "undefined" && (A === null || A === void 0 ? void 0 : A.body) instanceof ReadableStream;
  weA.isStreamingPayload = GV4
})
// @from(Start 3424805, End 3435450)
KJ = z((OI8, xeA) => {
  var {
    defineProperty: v71,
    getOwnPropertyDescriptor: ZV4,
    getOwnPropertyNames: DV4
  } = Object, YV4 = Object.prototype.hasOwnProperty, D7 = (A, B) => v71(A, "name", {
    value: B,
    configurable: !0
  }), WV4 = (A, B) => {
    for (var Q in B) v71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, JV4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of DV4(B))
        if (!YV4.call(A, G) && G !== Q) v71(A, G, {
          get: () => B[G],
          enumerable: !(I = ZV4(B, G)) || I.enumerable
        })
    }
    return A
  }, FV4 = (A) => JV4(v71({}, "__esModule", {
    value: !0
  }), A), $eA = {};
  WV4($eA, {
    AdaptiveRetryStrategy: () => CV4,
    CONFIG_MAX_ATTEMPTS: () => Vy1,
    CONFIG_RETRY_MODE: () => PeA,
    ENV_MAX_ATTEMPTS: () => Xy1,
    ENV_RETRY_MODE: () => TeA,
    NODE_MAX_ATTEMPT_CONFIG_OPTIONS: () => KV4,
    NODE_RETRY_MODE_CONFIG_OPTIONS: () => zV4,
    StandardRetryStrategy: () => OeA,
    defaultDelayDecider: () => MeA,
    defaultRetryDecider: () => LeA,
    getOmitRetryHeadersPlugin: () => wV4,
    getRetryAfterHint: () => keA,
    getRetryPlugin: () => MV4,
    omitRetryHeadersMiddleware: () => SeA,
    omitRetryHeadersMiddlewareOptions: () => _eA,
    resolveRetryConfig: () => HV4,
    retryMiddleware: () => jeA,
    retryMiddlewareOptions: () => yeA
  });
  xeA.exports = FV4($eA);
  var qb = loA(),
    qeA = htA(),
    $3 = vL(),
    XV4 = D7((A, B) => {
      let Q = A,
        I = B?.noRetryIncrement ?? $3.NO_RETRY_INCREMENT,
        G = B?.retryCost ?? $3.RETRY_COST,
        Z = B?.timeoutRetryCost ?? $3.TIMEOUT_RETRY_COST,
        D = A,
        Y = D7((X) => X.name === "TimeoutError" ? Z : G, "getCapacityAmount"),
        W = D7((X) => Y(X) <= D, "hasRetryTokens");
      return Object.freeze({
        hasRetryTokens: W,
        retrieveRetryTokens: D7((X) => {
          if (!W(X)) throw new Error("No retry token available");
          let V = Y(X);
          return D -= V, V
        }, "retrieveRetryTokens"),
        releaseRetryTokens: D7((X) => {
          D += X ?? I, D = Math.min(D, Q)
        }, "releaseRetryTokens")
      })
    }, "getDefaultRetryQuota"),
    MeA = D7((A, B) => Math.floor(Math.min($3.MAXIMUM_RETRY_DELAY, Math.random() * 2 ** B * A)), "defaultDelayDecider"),
    bL = aj1(),
    LeA = D7((A) => {
      if (!A) return !1;
      return bL.isRetryableByTrait(A) || bL.isClockSkewError(A) || bL.isThrottlingError(A) || bL.isTransientError(A)
    }, "defaultRetryDecider"),
    ReA = D7((A) => {
      if (A instanceof Error) return A;
      if (A instanceof Object) return Object.assign(new Error, A);
      if (typeof A === "string") return new Error(A);
      return new Error(`AWS SDK error wrapper for ${A}`)
    }, "asSdkError"),
    OeA = class {
      constructor(A, B) {
        this.maxAttemptsProvider = A, this.mode = $3.RETRY_MODES.STANDARD, this.retryDecider = B?.retryDecider ?? LeA, this.delayDecider = B?.delayDecider ?? MeA, this.retryQuota = B?.retryQuota ?? XV4($3.INITIAL_RETRY_TOKENS)
      }
      static {
        D7(this, "StandardRetryStrategy")
      }
      shouldRetry(A, B, Q) {
        return B < Q && this.retryDecider(A) && this.retryQuota.hasRetryTokens(A)
      }
      async getMaxAttempts() {
        let A;
        try {
          A = await this.maxAttemptsProvider()
        } catch (B) {
          A = $3.DEFAULT_MAX_ATTEMPTS
        }
        return A
      }
      async retry(A, B, Q) {
        let I, G = 0,
          Z = 0,
          D = await this.getMaxAttempts(),
          {
            request: Y
          } = B;
        if (qb.HttpRequest.isInstance(Y)) Y.headers[$3.INVOCATION_ID_HEADER] = qeA.v4();
        while (!0) try {
          if (qb.HttpRequest.isInstance(Y)) Y.headers[$3.REQUEST_HEADER] = `attempt=${G+1}; max=${D}`;
          if (Q?.beforeRequest) await Q.beforeRequest();
          let {
            response: W,
            output: J
          } = await A(B);
          if (Q?.afterRequest) Q.afterRequest(W);
          return this.retryQuota.releaseRetryTokens(I), J.$metadata.attempts = G + 1, J.$metadata.totalRetryDelay = Z, {
            response: W,
            output: J
          }
        } catch (W) {
          let J = ReA(W);
          if (G++, this.shouldRetry(J, G, D)) {
            I = this.retryQuota.retrieveRetryTokens(J);
            let F = this.delayDecider(bL.isThrottlingError(J) ? $3.THROTTLING_RETRY_DELAY_BASE : $3.DEFAULT_RETRY_DELAY_BASE, G),
              X = VV4(J.$response),
              V = Math.max(X || 0, F);
            Z += V, await new Promise((C) => setTimeout(C, V));
            continue
          }
          if (!J.$metadata) J.$metadata = {};
          throw J.$metadata.attempts = G, J.$metadata.totalRetryDelay = Z, J
        }
      }
    },
    VV4 = D7((A) => {
      if (!qb.HttpResponse.isInstance(A)) return;
      let B = Object.keys(A.headers).find((Z) => Z.toLowerCase() === "retry-after");
      if (!B) return;
      let Q = A.headers[B],
        I = Number(Q);
      if (!Number.isNaN(I)) return I * 1000;
      return new Date(Q).getTime() - Date.now()
    }, "getDelayFromRetryAfterHeader"),
    CV4 = class extends OeA {
      static {
        D7(this, "AdaptiveRetryStrategy")
      }
      constructor(A, B) {
        let {
          rateLimiter: Q,
          ...I
        } = B ?? {};
        super(A, I);
        this.rateLimiter = Q ?? new $3.DefaultRateLimiter, this.mode = $3.RETRY_MODES.ADAPTIVE
      }
      async retry(A, B) {
        return super.retry(A, B, {
          beforeRequest: async () => {
            return this.rateLimiter.getSendToken()
          },
          afterRequest: (Q) => {
            this.rateLimiter.updateClientSendingRate(Q)
          }
        })
      }
    },
    NeA = ZX(),
    Xy1 = "AWS_MAX_ATTEMPTS",
    Vy1 = "max_attempts",
    KV4 = {
      environmentVariableSelector: (A) => {
        let B = A[Xy1];
        if (!B) return;
        let Q = parseInt(B);
        if (Number.isNaN(Q)) throw new Error(`Environment variable ${Xy1} mast be a number, got "${B}"`);
        return Q
      },
      configFileSelector: (A) => {
        let B = A[Vy1];
        if (!B) return;
        let Q = parseInt(B);
        if (Number.isNaN(Q)) throw new Error(`Shared config file entry ${Vy1} mast be a number, got "${B}"`);
        return Q
      },
      default: $3.DEFAULT_MAX_ATTEMPTS
    },
    HV4 = D7((A) => {
      let {
        retryStrategy: B,
        retryMode: Q,
        maxAttempts: I
      } = A, G = NeA.normalizeProvider(I ?? $3.DEFAULT_MAX_ATTEMPTS);
      return Object.assign(A, {
        maxAttempts: G,
        retryStrategy: async () => {
          if (B) return B;
          if (await NeA.normalizeProvider(Q)() === $3.RETRY_MODES.ADAPTIVE) return new $3.AdaptiveRetryStrategy(G);
          return new $3.StandardRetryStrategy(G)
        }
      })
    }, "resolveRetryConfig"),
    TeA = "AWS_RETRY_MODE",
    PeA = "retry_mode",
    zV4 = {
      environmentVariableSelector: (A) => A[TeA],
      configFileSelector: (A) => A[PeA],
      default: $3.DEFAULT_RETRY_MODE
    },
    SeA = D7(() => (A) => async (B) => {
      let {
        request: Q
      } = B;
      if (qb.HttpRequest.isInstance(Q)) delete Q.headers[$3.INVOCATION_ID_HEADER], delete Q.headers[$3.REQUEST_HEADER];
      return A(B)
    }, "omitRetryHeadersMiddleware"),
    _eA = {
      name: "omitRetryHeadersMiddleware",
      tags: ["RETRY", "HEADERS", "OMIT_RETRY_HEADERS"],
      relation: "before",
      toMiddleware: "awsAuthMiddleware",
      override: !0
    },
    wV4 = D7((A) => ({
      applyToStack: (B) => {
        B.addRelativeTo(SeA(), _eA)
      }
    }), "getOmitRetryHeadersPlugin"),
    EV4 = zeA(),
    UV4 = UeA(),
    jeA = D7((A) => (B, Q) => async (I) => {
      let G = await A.retryStrategy(),
        Z = await A.maxAttempts();
      if (NV4(G)) {
        G = G;
        let D = await G.acquireInitialRetryToken(Q.partition_id),
          Y = new Error,
          W = 0,
          J = 0,
          {
            request: F
          } = I,
          X = qb.HttpRequest.isInstance(F);
        if (X) F.headers[$3.INVOCATION_ID_HEADER] = qeA.v4();
        while (!0) try {
          if (X) F.headers[$3.REQUEST_HEADER] = `attempt=${W+1}; max=${Z}`;
          let {
            response: V,
            output: C
          } = await B(I);
          return G.recordSuccess(D), C.$metadata.attempts = W + 1, C.$metadata.totalRetryDelay = J, {
            response: V,
            output: C
          }
        } catch (V) {
          let C = $V4(V);
          if (Y = ReA(V), X && UV4.isStreamingPayload(F)) throw (Q.logger instanceof EV4.NoOpLogger ? console : Q.logger)?.warn("An error was encountered in a non-retryable streaming request."), Y;
          try {
            D = await G.refreshRetryTokenForRetry(D, C)
          } catch (E) {
            if (!Y.$metadata) Y.$metadata = {};
            throw Y.$metadata.attempts = W + 1, Y.$metadata.totalRetryDelay = J, Y
          }
          W = D.getRetryCount();
          let K = D.getRetryDelay();
          J += K, await new Promise((E) => setTimeout(E, K))
        }
      } else {
        if (G = G, G?.mode) Q.userAgent = [...Q.userAgent || [],
          ["cfg/retry-mode", G.mode]
        ];
        return G.retry(B, I)
      }
    }, "retryMiddleware"),
    NV4 = D7((A) => typeof A.acquireInitialRetryToken !== "undefined" && typeof A.refreshRetryTokenForRetry !== "undefined" && typeof A.recordSuccess !== "undefined", "isRetryStrategyV2"),
    $V4 = D7((A) => {
      let B = {
          error: A,
          errorType: qV4(A)
        },
        Q = keA(A.$response);
      if (Q) B.retryAfterHint = Q;
      return B
    }, "getRetryErrorInfo"),
    qV4 = D7((A) => {
      if (bL.isThrottlingError(A)) return "THROTTLING";
      if (bL.isTransientError(A)) return "TRANSIENT";
      if (bL.isServerError(A)) return "SERVER_ERROR";
      return "CLIENT_ERROR"
    }, "getRetryErrorType"),
    yeA = {
      name: "retryMiddleware",
      tags: ["RETRY"],
      step: "finalizeRequest",
      priority: "high",
      override: !0
    },
    MV4 = D7((A) => ({
      applyToStack: (B) => {
        B.add(jeA(A), yeA)
      }
    }), "getRetryPlugin"),
    keA = D7((A) => {
      if (!qb.HttpResponse.isInstance(A)) return;
      let B = Object.keys(A.headers).find((Z) => Z.toLowerCase() === "retry-after");
      if (!B) return;
      let Q = A.headers[B],
        I = Number(Q);
      if (!Number.isNaN(I)) return new Date(I * 1000);
      return new Date(Q)
    }, "getRetryAfterHint")
})
// @from(Start 3435456, End 3436755)
Ky1 = z((feA) => {
  Object.defineProperty(feA, "__esModule", {
    value: !0
  });
  feA.resolveHttpAuthSchemeConfig = feA.defaultBedrockHttpAuthSchemeProvider = feA.defaultBedrockHttpAuthSchemeParametersProvider = void 0;
  var LV4 = IB(),
    Cy1 = ZX(),
    RV4 = async (A, B, Q) => {
      return {
        operation: Cy1.getSmithyContext(B).operation,
        region: await Cy1.normalizeProvider(A.region)() || (() => {
          throw new Error("expected `region` to be configured for `aws.auth#sigv4`")
        })()
      }
    };
  feA.defaultBedrockHttpAuthSchemeParametersProvider = RV4;

  function OV4(A) {
    return {
      schemeId: "aws.auth#sigv4",
      signingProperties: {
        name: "bedrock",
        region: A.region
      },
      propertiesExtractor: (B, Q) => ({
        signingProperties: {
          config: B,
          context: Q
        }
      })
    }
  }
  var TV4 = (A) => {
    let B = [];
    switch (A.operation) {
      default:
        B.push(OV4(A))
    }
    return B
  };
  feA.defaultBedrockHttpAuthSchemeProvider = TV4;
  var PV4 = (A) => {
    let B = LV4.resolveAwsSdkSigV4Config(A);
    return Object.assign(B, {
      authSchemePreference: Cy1.normalizeProvider(A.authSchemePreference ?? [])
    })
  };
  feA.resolveHttpAuthSchemeConfig = PV4
})
// @from(Start 3436761, End 3454081)
X10 = z((_I8, h71) => {
  var beA, geA, heA, meA, deA, ueA, peA, ceA, leA, ieA, neA, aeA, seA, b71, Hy1, reA, oeA, teA, Mb, eeA, A10, B10, Q10, I10, G10, Z10, D10, Y10, g71, W10, J10, F10;
  (function(A) {
    var B = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
    if (typeof define === "function" && define.amd) define("tslib", ["exports"], function(I) {
      A(Q(B, Q(I)))
    });
    else if (typeof h71 === "object" && typeof _I8 === "object") A(Q(B, Q(_I8)));
    else A(Q(B));

    function Q(I, G) {
      if (I !== B)
        if (typeof Object.create === "function") Object.defineProperty(I, "__esModule", {
          value: !0
        });
        else I.__esModule = !0;
      return function(Z, D) {
        return I[Z] = G ? G(Z, D) : D
      }
    }
  })(function(A) {
    var B = Object.setPrototypeOf || {
      __proto__: []
    }
    instanceof Array && function(Z, D) {
      Z.__proto__ = D
    } || function(Z, D) {
      for (var Y in D)
        if (Object.prototype.hasOwnProperty.call(D, Y)) Z[Y] = D[Y]
    };
    beA = function(Z, D) {
      if (typeof D !== "function" && D !== null) throw new TypeError("Class extends value " + String(D) + " is not a constructor or null");
      B(Z, D);

      function Y() {
        this.constructor = Z
      }
      Z.prototype = D === null ? Object.create(D) : (Y.prototype = D.prototype, new Y)
    }, geA = Object.assign || function(Z) {
      for (var D, Y = 1, W = arguments.length; Y < W; Y++) {
        D = arguments[Y];
        for (var J in D)
          if (Object.prototype.hasOwnProperty.call(D, J)) Z[J] = D[J]
      }
      return Z
    }, heA = function(Z, D) {
      var Y = {};
      for (var W in Z)
        if (Object.prototype.hasOwnProperty.call(Z, W) && D.indexOf(W) < 0) Y[W] = Z[W];
      if (Z != null && typeof Object.getOwnPropertySymbols === "function") {
        for (var J = 0, W = Object.getOwnPropertySymbols(Z); J < W.length; J++)
          if (D.indexOf(W[J]) < 0 && Object.prototype.propertyIsEnumerable.call(Z, W[J])) Y[W[J]] = Z[W[J]]
      }
      return Y
    }, meA = function(Z, D, Y, W) {
      var J = arguments.length,
        F = J < 3 ? D : W === null ? W = Object.getOwnPropertyDescriptor(D, Y) : W,
        X;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") F = Reflect.decorate(Z, D, Y, W);
      else
        for (var V = Z.length - 1; V >= 0; V--)
          if (X = Z[V]) F = (J < 3 ? X(F) : J > 3 ? X(D, Y, F) : X(D, Y)) || F;
      return J > 3 && F && Object.defineProperty(D, Y, F), F
    }, deA = function(Z, D) {
      return function(Y, W) {
        D(Y, W, Z)
      }
    }, ueA = function(Z, D, Y, W, J, F) {
      function X(_) {
        if (_ !== void 0 && typeof _ !== "function") throw new TypeError("Function expected");
        return _
      }
      var V = W.kind,
        C = V === "getter" ? "get" : V === "setter" ? "set" : "value",
        K = !D && Z ? W.static ? Z : Z.prototype : null,
        E = D || (K ? Object.getOwnPropertyDescriptor(K, W.name) : {}),
        N, q = !1;
      for (var O = Y.length - 1; O >= 0; O--) {
        var R = {};
        for (var T in W) R[T] = T === "access" ? {} : W[T];
        for (var T in W.access) R.access[T] = W.access[T];
        R.addInitializer = function(_) {
          if (q) throw new TypeError("Cannot add initializers after decoration has completed");
          F.push(X(_ || null))
        };
        var L = Y[O](V === "accessor" ? {
          get: E.get,
          set: E.set
        } : E[C], R);
        if (V === "accessor") {
          if (L === void 0) continue;
          if (L === null || typeof L !== "object") throw new TypeError("Object expected");
          if (N = X(L.get)) E.get = N;
          if (N = X(L.set)) E.set = N;
          if (N = X(L.init)) J.unshift(N)
        } else if (N = X(L))
          if (V === "field") J.unshift(N);
          else E[C] = N
      }
      if (K) Object.defineProperty(K, W.name, E);
      q = !0
    }, peA = function(Z, D, Y) {
      var W = arguments.length > 2;
      for (var J = 0; J < D.length; J++) Y = W ? D[J].call(Z, Y) : D[J].call(Z);
      return W ? Y : void 0
    }, ceA = function(Z) {
      return typeof Z === "symbol" ? Z : "".concat(Z)
    }, leA = function(Z, D, Y) {
      if (typeof D === "symbol") D = D.description ? "[".concat(D.description, "]") : "";
      return Object.defineProperty(Z, "name", {
        configurable: !0,
        value: Y ? "".concat(Y, " ", D) : D
      })
    }, ieA = function(Z, D) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(Z, D)
    }, neA = function(Z, D, Y, W) {
      function J(F) {
        return F instanceof Y ? F : new Y(function(X) {
          X(F)
        })
      }
      return new(Y || (Y = Promise))(function(F, X) {
        function V(E) {
          try {
            K(W.next(E))
          } catch (N) {
            X(N)
          }
        }

        function C(E) {
          try {
            K(W.throw(E))
          } catch (N) {
            X(N)
          }
        }

        function K(E) {
          E.done ? F(E.value) : J(E.value).then(V, C)
        }
        K((W = W.apply(Z, D || [])).next())
      })
    }, aeA = function(Z, D) {
      var Y = {
          label: 0,
          sent: function() {
            if (F[0] & 1) throw F[1];
            return F[1]
          },
          trys: [],
          ops: []
        },
        W, J, F, X = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
      return X.next = V(0), X.throw = V(1), X.return = V(2), typeof Symbol === "function" && (X[Symbol.iterator] = function() {
        return this
      }), X;

      function V(K) {
        return function(E) {
          return C([K, E])
        }
      }

      function C(K) {
        if (W) throw new TypeError("Generator is already executing.");
        while (X && (X = 0, K[0] && (Y = 0)), Y) try {
          if (W = 1, J && (F = K[0] & 2 ? J.return : K[0] ? J.throw || ((F = J.return) && F.call(J), 0) : J.next) && !(F = F.call(J, K[1])).done) return F;
          if (J = 0, F) K = [K[0] & 2, F.value];
          switch (K[0]) {
            case 0:
            case 1:
              F = K;
              break;
            case 4:
              return Y.label++, {
                value: K[1],
                done: !1
              };
            case 5:
              Y.label++, J = K[1], K = [0];
              continue;
            case 7:
              K = Y.ops.pop(), Y.trys.pop();
              continue;
            default:
              if ((F = Y.trys, !(F = F.length > 0 && F[F.length - 1])) && (K[0] === 6 || K[0] === 2)) {
                Y = 0;
                continue
              }
              if (K[0] === 3 && (!F || K[1] > F[0] && K[1] < F[3])) {
                Y.label = K[1];
                break
              }
              if (K[0] === 6 && Y.label < F[1]) {
                Y.label = F[1], F = K;
                break
              }
              if (F && Y.label < F[2]) {
                Y.label = F[2], Y.ops.push(K);
                break
              }
              if (F[2]) Y.ops.pop();
              Y.trys.pop();
              continue
          }
          K = D.call(Z, Y)
        } catch (E) {
          K = [6, E], J = 0
        } finally {
          W = F = 0
        }
        if (K[0] & 5) throw K[1];
        return {
          value: K[0] ? K[1] : void 0,
          done: !0
        }
      }
    }, seA = function(Z, D) {
      for (var Y in Z)
        if (Y !== "default" && !Object.prototype.hasOwnProperty.call(D, Y)) g71(D, Z, Y)
    }, g71 = Object.create ? function(Z, D, Y, W) {
      if (W === void 0) W = Y;
      var J = Object.getOwnPropertyDescriptor(D, Y);
      if (!J || ("get" in J ? !D.__esModule : J.writable || J.configurable)) J = {
        enumerable: !0,
        get: function() {
          return D[Y]
        }
      };
      Object.defineProperty(Z, W, J)
    } : function(Z, D, Y, W) {
      if (W === void 0) W = Y;
      Z[W] = D[Y]
    }, b71 = function(Z) {
      var D = typeof Symbol === "function" && Symbol.iterator,
        Y = D && Z[D],
        W = 0;
      if (Y) return Y.call(Z);
      if (Z && typeof Z.length === "number") return {
        next: function() {
          if (Z && W >= Z.length) Z = void 0;
          return {
            value: Z && Z[W++],
            done: !Z
          }
        }
      };
      throw new TypeError(D ? "Object is not iterable." : "Symbol.iterator is not defined.")
    }, Hy1 = function(Z, D) {
      var Y = typeof Symbol === "function" && Z[Symbol.iterator];
      if (!Y) return Z;
      var W = Y.call(Z),
        J, F = [],
        X;
      try {
        while ((D === void 0 || D-- > 0) && !(J = W.next()).done) F.push(J.value)
      } catch (V) {
        X = {
          error: V
        }
      } finally {
        try {
          if (J && !J.done && (Y = W.return)) Y.call(W)
        } finally {
          if (X) throw X.error
        }
      }
      return F
    }, reA = function() {
      for (var Z = [], D = 0; D < arguments.length; D++) Z = Z.concat(Hy1(arguments[D]));
      return Z
    }, oeA = function() {
      for (var Z = 0, D = 0, Y = arguments.length; D < Y; D++) Z += arguments[D].length;
      for (var W = Array(Z), J = 0, D = 0; D < Y; D++)
        for (var F = arguments[D], X = 0, V = F.length; X < V; X++, J++) W[J] = F[X];
      return W
    }, teA = function(Z, D, Y) {
      if (Y || arguments.length === 2) {
        for (var W = 0, J = D.length, F; W < J; W++)
          if (F || !(W in D)) {
            if (!F) F = Array.prototype.slice.call(D, 0, W);
            F[W] = D[W]
          }
      }
      return Z.concat(F || Array.prototype.slice.call(D))
    }, Mb = function(Z) {
      return this instanceof Mb ? (this.v = Z, this) : new Mb(Z)
    }, eeA = function(Z, D, Y) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var W = Y.apply(Z, D || []),
        J, F = [];
      return J = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), V("next"), V("throw"), V("return", X), J[Symbol.asyncIterator] = function() {
        return this
      }, J;

      function X(O) {
        return function(R) {
          return Promise.resolve(R).then(O, N)
        }
      }

      function V(O, R) {
        if (W[O]) {
          if (J[O] = function(T) {
              return new Promise(function(L, _) {
                F.push([O, T, L, _]) > 1 || C(O, T)
              })
            }, R) J[O] = R(J[O])
        }
      }

      function C(O, R) {
        try {
          K(W[O](R))
        } catch (T) {
          q(F[0][3], T)
        }
      }

      function K(O) {
        O.value instanceof Mb ? Promise.resolve(O.value.v).then(E, N) : q(F[0][2], O)
      }

      function E(O) {
        C("next", O)
      }

      function N(O) {
        C("throw", O)
      }

      function q(O, R) {
        if (O(R), F.shift(), F.length) C(F[0][0], F[0][1])
      }
    }, A10 = function(Z) {
      var D, Y;
      return D = {}, W("next"), W("throw", function(J) {
        throw J
      }), W("return"), D[Symbol.iterator] = function() {
        return this
      }, D;

      function W(J, F) {
        D[J] = Z[J] ? function(X) {
          return (Y = !Y) ? {
            value: Mb(Z[J](X)),
            done: !1
          } : F ? F(X) : X
        } : F
      }
    }, B10 = function(Z) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var D = Z[Symbol.asyncIterator],
        Y;
      return D ? D.call(Z) : (Z = typeof b71 === "function" ? b71(Z) : Z[Symbol.iterator](), Y = {}, W("next"), W("throw"), W("return"), Y[Symbol.asyncIterator] = function() {
        return this
      }, Y);

      function W(F) {
        Y[F] = Z[F] && function(X) {
          return new Promise(function(V, C) {
            X = Z[F](X), J(V, C, X.done, X.value)
          })
        }
      }

      function J(F, X, V, C) {
        Promise.resolve(C).then(function(K) {
          F({
            value: K,
            done: V
          })
        }, X)
      }
    }, Q10 = function(Z, D) {
      if (Object.defineProperty) Object.defineProperty(Z, "raw", {
        value: D
      });
      else Z.raw = D;
      return Z
    };
    var Q = Object.create ? function(Z, D) {
        Object.defineProperty(Z, "default", {
          enumerable: !0,
          value: D
        })
      } : function(Z, D) {
        Z.default = D
      },
      I = function(Z) {
        return I = Object.getOwnPropertyNames || function(D) {
          var Y = [];
          for (var W in D)
            if (Object.prototype.hasOwnProperty.call(D, W)) Y[Y.length] = W;
          return Y
        }, I(Z)
      };
    I10 = function(Z) {
      if (Z && Z.__esModule) return Z;
      var D = {};
      if (Z != null) {
        for (var Y = I(Z), W = 0; W < Y.length; W++)
          if (Y[W] !== "default") g71(D, Z, Y[W])
      }
      return Q(D, Z), D
    }, G10 = function(Z) {
      return Z && Z.__esModule ? Z : {
        default: Z
      }
    }, Z10 = function(Z, D, Y, W) {
      if (Y === "a" && !W) throw new TypeError("Private accessor was defined without a getter");
      if (typeof D === "function" ? Z !== D || !W : !D.has(Z)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
      return Y === "m" ? W : Y === "a" ? W.call(Z) : W ? W.value : D.get(Z)
    }, D10 = function(Z, D, Y, W, J) {
      if (W === "m") throw new TypeError("Private method is not writable");
      if (W === "a" && !J) throw new TypeError("Private accessor was defined without a setter");
      if (typeof D === "function" ? Z !== D || !J : !D.has(Z)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
      return W === "a" ? J.call(Z, Y) : J ? J.value = Y : D.set(Z, Y), Y
    }, Y10 = function(Z, D) {
      if (D === null || typeof D !== "object" && typeof D !== "function") throw new TypeError("Cannot use 'in' operator on non-object");
      return typeof Z === "function" ? D === Z : Z.has(D)
    }, W10 = function(Z, D, Y) {
      if (D !== null && D !== void 0) {
        if (typeof D !== "object" && typeof D !== "function") throw new TypeError("Object expected.");
        var W, J;
        if (Y) {
          if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
          W = D[Symbol.asyncDispose]
        }
        if (W === void 0) {
          if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
          if (W = D[Symbol.dispose], Y) J = W
        }
        if (typeof W !== "function") throw new TypeError("Object not disposable.");
        if (J) W = function() {
          try {
            J.call(this)
          } catch (F) {
            return Promise.reject(F)
          }
        };
        Z.stack.push({
          value: D,
          dispose: W,
          async: Y
        })
      } else if (Y) Z.stack.push({
        async: !0
      });
      return D
    };
    var G = typeof SuppressedError === "function" ? SuppressedError : function(Z, D, Y) {
      var W = new Error(Y);
      return W.name = "SuppressedError", W.error = Z, W.suppressed = D, W
    };
    J10 = function(Z) {
      function D(F) {
        Z.error = Z.hasError ? new G(F, Z.error, "An error was suppressed during disposal.") : F, Z.hasError = !0
      }
      var Y, W = 0;

      function J() {
        while (Y = Z.stack.pop()) try {
          if (!Y.async && W === 1) return W = 0, Z.stack.push(Y), Promise.resolve().then(J);
          if (Y.dispose) {
            var F = Y.dispose.call(Y.value);
            if (Y.async) return W |= 2, Promise.resolve(F).then(J, function(X) {
              return D(X), J()
            })
          } else W |= 1
        } catch (X) {
          D(X)
        }
        if (W === 1) return Z.hasError ? Promise.reject(Z.error) : Promise.resolve();
        if (Z.hasError) throw Z.error
      }
      return J()
    }, F10 = function(Z, D) {
      if (typeof Z === "string" && /^\.\.?\//.test(Z)) return Z.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(Y, W, J, F, X) {
        return W ? D ? ".jsx" : ".js" : J && (!F || !X) ? Y : J + F + "." + X.toLowerCase() + "js"
      });
      return Z
    }, A("__extends", beA), A("__assign", geA), A("__rest", heA), A("__decorate", meA), A("__param", deA), A("__esDecorate", ueA), A("__runInitializers", peA), A("__propKey", ceA), A("__setFunctionName", leA), A("__metadata", ieA), A("__awaiter", neA), A("__generator", aeA), A("__exportStar", seA), A("__createBinding", g71), A("__values", b71), A("__read", Hy1), A("__spread", reA), A("__spreadArrays", oeA), A("__spreadArray", teA), A("__await", Mb), A("__asyncGenerator", eeA), A("__asyncDelegator", A10), A("__asyncValues", B10), A("__makeTemplateObject", Q10), A("__importStar", I10), A("__importDefault", G10), A("__classPrivateFieldGet", Z10), A("__classPrivateFieldSet", D10), A("__classPrivateFieldIn", Y10), A("__addDisposableResource", W10), A("__disposeResources", J10), A("__rewriteRelativeImportExtension", F10)
  })
})
// @from(Start 3454087, End 3457802)
V10 = z((jI8, jV4) => {
  jV4.exports = {
    name: "@aws-sdk/client-bedrock",
    description: "AWS SDK for JavaScript Bedrock Client for Node.js, Browser and React Native",
    version: "3.797.0",
    scripts: {
      build: "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
      "build:cjs": "node ../../scripts/compilation/inline client-bedrock",
      "build:es": "tsc -p tsconfig.es.json",
      "build:include:deps": "lerna run --scope $npm_package_name --include-dependencies build",
      "build:types": "tsc -p tsconfig.types.json",
      "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
      clean: "rimraf ./dist-* && rimraf *.tsbuildinfo",
      "extract:docs": "api-extractor run --local",
      "generate:client": "node ../../scripts/generate-clients/single-service --solo bedrock"
    },
    main: "./dist-cjs/index.js",
    types: "./dist-types/index.d.ts",
    module: "./dist-es/index.js",
    sideEffects: !1,
    dependencies: {
      "@aws-crypto/sha256-browser": "5.2.0",
      "@aws-crypto/sha256-js": "5.2.0",
      "@aws-sdk/core": "3.796.0",
      "@aws-sdk/credential-provider-node": "3.797.0",
      "@aws-sdk/middleware-host-header": "3.775.0",
      "@aws-sdk/middleware-logger": "3.775.0",
      "@aws-sdk/middleware-recursion-detection": "3.775.0",
      "@aws-sdk/middleware-user-agent": "3.796.0",
      "@aws-sdk/region-config-resolver": "3.775.0",
      "@aws-sdk/types": "3.775.0",
      "@aws-sdk/util-endpoints": "3.787.0",
      "@aws-sdk/util-user-agent-browser": "3.775.0",
      "@aws-sdk/util-user-agent-node": "3.796.0",
      "@smithy/config-resolver": "^4.1.0",
      "@smithy/core": "^3.2.0",
      "@smithy/fetch-http-handler": "^5.0.2",
      "@smithy/hash-node": "^4.0.2",
      "@smithy/invalid-dependency": "^4.0.2",
      "@smithy/middleware-content-length": "^4.0.2",
      "@smithy/middleware-endpoint": "^4.1.0",
      "@smithy/middleware-retry": "^4.1.0",
      "@smithy/middleware-serde": "^4.0.3",
      "@smithy/middleware-stack": "^4.0.2",
      "@smithy/node-config-provider": "^4.0.2",
      "@smithy/node-http-handler": "^4.0.4",
      "@smithy/protocol-http": "^5.1.0",
      "@smithy/smithy-client": "^4.2.0",
      "@smithy/types": "^4.2.0",
      "@smithy/url-parser": "^4.0.2",
      "@smithy/util-base64": "^4.0.0",
      "@smithy/util-body-length-browser": "^4.0.0",
      "@smithy/util-body-length-node": "^4.0.0",
      "@smithy/util-defaults-mode-browser": "^4.0.8",
      "@smithy/util-defaults-mode-node": "^4.0.8",
      "@smithy/util-endpoints": "^3.0.2",
      "@smithy/util-middleware": "^4.0.2",
      "@smithy/util-retry": "^4.0.2",
      "@smithy/util-utf8": "^4.0.0",
      "@types/uuid": "^9.0.1",
      tslib: "^2.6.2",
      uuid: "^9.0.1"
    },
    devDependencies: {
      "@tsconfig/node18": "18.2.4",
      "@types/node": "^18.19.69",
      concurrently: "7.0.0",
      "downlevel-dts": "0.10.1",
      rimraf: "3.0.2",
      typescript: "~5.2.2"
    },
    engines: {
      node: ">=18.0.0"
    },
    typesVersions: {
      "<4.0": {
        "dist-types/*": ["dist-types/ts3.4/*"]
      }
    },
    files: ["dist-*/**"],
    author: {
      name: "AWS SDK for JavaScript Team",
      url: "https://aws.amazon.com/javascript/"
    },
    license: "Apache-2.0",
    browser: {
      "./dist-es/runtimeConfig": "./dist-es/runtimeConfig.browser"
    },
    "react-native": {
      "./dist-es/runtimeConfig": "./dist-es/runtimeConfig.native"
    },
    homepage: "https://github.com/aws/aws-sdk-js-v3/tree/main/clients/client-bedrock",
    repository: {
      type: "git",
      url: "https://github.com/aws/aws-sdk-js-v3.git",
      directory: "clients/client-bedrock"
    }
  }
})
// @from(Start 3457808, End 3459876)
d71 = z((yI8, N10) => {
  var {
    defineProperty: m71,
    getOwnPropertyDescriptor: yV4,
    getOwnPropertyNames: kV4
  } = Object, xV4 = Object.prototype.hasOwnProperty, fV4 = (A, B) => m71(A, "name", {
    value: B,
    configurable: !0
  }), vV4 = (A, B) => {
    for (var Q in B) m71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, bV4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of kV4(B))
        if (!xV4.call(A, G) && G !== Q) m71(A, G, {
          get: () => B[G],
          enumerable: !(I = yV4(B, G)) || I.enumerable
        })
    }
    return A
  }, gV4 = (A) => bV4(m71({}, "__esModule", {
    value: !0
  }), A), C10 = {};
  vV4(C10, {
    ENV_ACCOUNT_ID: () => U10,
    ENV_CREDENTIAL_SCOPE: () => E10,
    ENV_EXPIRATION: () => w10,
    ENV_KEY: () => K10,
    ENV_SECRET: () => H10,
    ENV_SESSION: () => z10,
    fromEnv: () => dV4
  });
  N10.exports = gV4(C10);
  var hV4 = NC(),
    mV4 = $I(),
    K10 = "AWS_ACCESS_KEY_ID",
    H10 = "AWS_SECRET_ACCESS_KEY",
    z10 = "AWS_SESSION_TOKEN",
    w10 = "AWS_CREDENTIAL_EXPIRATION",
    E10 = "AWS_CREDENTIAL_SCOPE",
    U10 = "AWS_ACCOUNT_ID",
    dV4 = fV4((A) => async () => {
      A?.logger?.debug("@aws-sdk/credential-provider-env - fromEnv");
      let B = process.env[K10],
        Q = process.env[H10],
        I = process.env[z10],
        G = process.env[w10],
        Z = process.env[E10],
        D = process.env[U10];
      if (B && Q) {
        let Y = {
          accessKeyId: B,
          secretAccessKey: Q,
          ...I && {
            sessionToken: I
          },
          ...G && {
            expiration: new Date(G)
          },
          ...Z && {
            credentialScope: Z
          },
          ...D && {
            accountId: D
          }
        };
        return hV4.setCredentialFeature(Y, "CREDENTIALS_ENV_VARS", "g"), Y
      }
      throw new mV4.CredentialsProviderError("Unable to find environment variable credentials.", {
        logger: A?.logger
      })
    }, "fromEnv")
})
// @from(Start 3459882, End 3471484)
B_ = z((kI8, k10) => {
  var {
    defineProperty: c71,
    getOwnPropertyDescriptor: uV4,
    getOwnPropertyNames: pV4
  } = Object, cV4 = Object.prototype.hasOwnProperty, Y7 = (A, B) => c71(A, "name", {
    value: B,
    configurable: !0
  }), lV4 = (A, B) => {
    for (var Q in B) c71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, iV4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of pV4(B))
        if (!cV4.call(A, G) && G !== Q) c71(A, G, {
          get: () => B[G],
          enumerable: !(I = uV4(B, G)) || I.enumerable
        })
    }
    return A
  }, nV4 = (A) => iV4(c71({}, "__esModule", {
    value: !0
  }), A), L10 = {};
  lV4(L10, {
    DEFAULT_MAX_RETRIES: () => P10,
    DEFAULT_TIMEOUT: () => T10,
    ENV_CMDS_AUTH_TOKEN: () => Ey1,
    ENV_CMDS_FULL_URI: () => u71,
    ENV_CMDS_RELATIVE_URI: () => p71,
    Endpoint: () => S10,
    fromContainerMetadata: () => oV4,
    fromInstanceMetadata: () => EC4,
    getInstanceMetadataEndpoint: () => j10,
    httpRequest: () => Lb,
    providerConfigFromInit: () => Uy1
  });
  k10.exports = nV4(L10);
  var aV4 = Z1("url"),
    dz = $I(),
    sV4 = Z1("buffer"),
    rV4 = Z1("http");

  function Lb(A) {
    return new Promise((B, Q) => {
      let I = rV4.request({
        method: "GET",
        ...A,
        hostname: A.hostname?.replace(/^\[(.+)\]$/, "$1")
      });
      I.on("error", (G) => {
        Q(Object.assign(new dz.ProviderError("Unable to connect to instance metadata service"), G)), I.destroy()
      }), I.on("timeout", () => {
        Q(new dz.ProviderError("TimeoutError from instance metadata service")), I.destroy()
      }), I.on("response", (G) => {
        let {
          statusCode: Z = 400
        } = G;
        if (Z < 200 || 300 <= Z) Q(Object.assign(new dz.ProviderError("Error response received from instance metadata service"), {
          statusCode: Z
        })), I.destroy();
        let D = [];
        G.on("data", (Y) => {
          D.push(Y)
        }), G.on("end", () => {
          B(sV4.Buffer.concat(D)), I.destroy()
        })
      }), I.end()
    })
  }
  Y7(Lb, "httpRequest");
  var R10 = Y7((A) => Boolean(A) && typeof A === "object" && typeof A.AccessKeyId === "string" && typeof A.SecretAccessKey === "string" && typeof A.Token === "string" && typeof A.Expiration === "string", "isImdsCredentials"),
    O10 = Y7((A) => ({
      accessKeyId: A.AccessKeyId,
      secretAccessKey: A.SecretAccessKey,
      sessionToken: A.Token,
      expiration: new Date(A.Expiration),
      ...A.AccountId && {
        accountId: A.AccountId
      }
    }), "fromImdsCredentials"),
    T10 = 1000,
    P10 = 0,
    Uy1 = Y7(({
      maxRetries: A = P10,
      timeout: B = T10
    }) => ({
      maxRetries: A,
      timeout: B
    }), "providerConfigFromInit"),
    wy1 = Y7((A, B) => {
      let Q = A();
      for (let I = 0; I < B; I++) Q = Q.catch(A);
      return Q
    }, "retry"),
    u71 = "AWS_CONTAINER_CREDENTIALS_FULL_URI",
    p71 = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI",
    Ey1 = "AWS_CONTAINER_AUTHORIZATION_TOKEN",
    oV4 = Y7((A = {}) => {
      let {
        timeout: B,
        maxRetries: Q
      } = Uy1(A);
      return () => wy1(async () => {
        let I = await QC4({
            logger: A.logger
          }),
          G = JSON.parse(await tV4(B, I));
        if (!R10(G)) throw new dz.CredentialsProviderError("Invalid response received from instance metadata service.", {
          logger: A.logger
        });
        return O10(G)
      }, Q)
    }, "fromContainerMetadata"),
    tV4 = Y7(async (A, B) => {
      if (process.env[Ey1]) B.headers = {
        ...B.headers,
        Authorization: process.env[Ey1]
      };
      return (await Lb({
        ...B,
        timeout: A
      })).toString()
    }, "requestFromEcsImds"),
    eV4 = "169.254.170.2",
    AC4 = {
      localhost: !0,
      "127.0.0.1": !0
    },
    BC4 = {
      "http:": !0,
      "https:": !0
    },
    QC4 = Y7(async ({
      logger: A
    }) => {
      if (process.env[p71]) return {
        hostname: eV4,
        path: process.env[p71]
      };
      if (process.env[u71]) {
        let B = aV4.parse(process.env[u71]);
        if (!B.hostname || !(B.hostname in AC4)) throw new dz.CredentialsProviderError(`${B.hostname} is not a valid container metadata service hostname`, {
          tryNextLink: !1,
          logger: A
        });
        if (!B.protocol || !(B.protocol in BC4)) throw new dz.CredentialsProviderError(`${B.protocol} is not a valid container metadata service protocol`, {
          tryNextLink: !1,
          logger: A
        });
        return {
          ...B,
          port: B.port ? parseInt(B.port, 10) : void 0
        }
      }
      throw new dz.CredentialsProviderError(`The container metadata credential provider cannot be used unless the ${p71} or ${u71} environment variable is set`, {
        tryNextLink: !1,
        logger: A
      })
    }, "getCmdsUri"),
    IC4 = class A extends dz.CredentialsProviderError {
      constructor(B, Q = !0) {
        super(B, Q);
        this.tryNextLink = Q, this.name = "InstanceMetadataV1FallbackError", Object.setPrototypeOf(this, A.prototype)
      }
      static {
        Y7(this, "InstanceMetadataV1FallbackError")
      }
    },
    Ny1 = qC(),
    GC4 = FN(),
    S10 = ((A) => {
      return A.IPv4 = "http://169.254.169.254", A.IPv6 = "http://[fd00:ec2::254]", A
    })(S10 || {}),
    ZC4 = "AWS_EC2_METADATA_SERVICE_ENDPOINT",
    DC4 = "ec2_metadata_service_endpoint",
    YC4 = {
      environmentVariableSelector: (A) => A[ZC4],
      configFileSelector: (A) => A[DC4],
      default: void 0
    },
    _10 = ((A) => {
      return A.IPv4 = "IPv4", A.IPv6 = "IPv6", A
    })(_10 || {}),
    WC4 = "AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE",
    JC4 = "ec2_metadata_service_endpoint_mode",
    FC4 = {
      environmentVariableSelector: (A) => A[WC4],
      configFileSelector: (A) => A[JC4],
      default: "IPv4"
    },
    j10 = Y7(async () => GC4.parseUrl(await XC4() || await VC4()), "getInstanceMetadataEndpoint"),
    XC4 = Y7(async () => Ny1.loadConfig(YC4)(), "getFromEndpointConfig"),
    VC4 = Y7(async () => {
      let A = await Ny1.loadConfig(FC4)();
      switch (A) {
        case "IPv4":
          return "http://169.254.169.254";
        case "IPv6":
          return "http://[fd00:ec2::254]";
        default:
          throw new Error(`Unsupported endpoint mode: ${A}. Select from ${Object.values(_10)}`)
      }
    }, "getFromEndpointModeConfig"),
    CC4 = 300,
    KC4 = 300,
    HC4 = "https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html",
    $10 = Y7((A, B) => {
      let Q = CC4 + Math.floor(Math.random() * KC4),
        I = new Date(Date.now() + Q * 1000);
      B.warn(`Attempting credential expiration extension due to a credential service availability issue. A refresh of these credentials will be attempted after ${new Date(I)}.
For more information, please visit: ` + HC4);
      let G = A.originalExpiration ?? A.expiration;
      return {
        ...A,
        ...G ? {
          originalExpiration: G
        } : {},
        expiration: I
      }
    }, "getExtendedInstanceMetadataCredentials"),
    zC4 = Y7((A, B = {}) => {
      let Q = B?.logger || console,
        I;
      return async () => {
        let G;
        try {
          if (G = await A(), G.expiration && G.expiration.getTime() < Date.now()) G = $10(G, Q)
        } catch (Z) {
          if (I) Q.warn("Credential renew failed: ", Z), G = $10(I, Q);
          else throw Z
        }
        return I = G, G
      }
    }, "staticStabilityProvider"),
    y10 = "/latest/meta-data/iam/security-credentials/",
    wC4 = "/latest/api/token",
    zy1 = "AWS_EC2_METADATA_V1_DISABLED",
    q10 = "ec2_metadata_v1_disabled",
    M10 = "x-aws-ec2-metadata-token",
    EC4 = Y7((A = {}) => zC4(UC4(A), {
      logger: A.logger
    }), "fromInstanceMetadata"),
    UC4 = Y7((A = {}) => {
      let B = !1,
        {
          logger: Q,
          profile: I
        } = A,
        {
          timeout: G,
          maxRetries: Z
        } = Uy1(A),
        D = Y7(async (Y, W) => {
          if (B || W.headers?.[M10] == null) {
            let X = !1,
              V = !1,
              C = await Ny1.loadConfig({
                environmentVariableSelector: (K) => {
                  let E = K[zy1];
                  if (V = !!E && E !== "false", E === void 0) throw new dz.CredentialsProviderError(`${zy1} not set in env, checking config file next.`, {
                    logger: A.logger
                  });
                  return V
                },
                configFileSelector: (K) => {
                  let E = K[q10];
                  return X = !!E && E !== "false", X
                },
                default: !1
              }, {
                profile: I
              })();
            if (A.ec2MetadataV1Disabled || C) {
              let K = [];
              if (A.ec2MetadataV1Disabled) K.push("credential provider initialization (runtime option ec2MetadataV1Disabled)");
              if (X) K.push(`config file profile (${q10})`);
              if (V) K.push(`process environment variable (${zy1})`);
              throw new IC4(`AWS EC2 Metadata v1 fallback has been blocked by AWS SDK configuration in the following: [${K.join(", ")}].`)
            }
          }
          let F = (await wy1(async () => {
            let X;
            try {
              X = await $C4(W)
            } catch (V) {
              if (V.statusCode === 401) B = !1;
              throw V
            }
            return X
          }, Y)).trim();
          return wy1(async () => {
            let X;
            try {
              X = await qC4(F, W, A)
            } catch (V) {
              if (V.statusCode === 401) B = !1;
              throw V
            }
            return X
          }, Y)
        }, "getCredentials");
      return async () => {
        let Y = await j10();
        if (B) return Q?.debug("AWS SDK Instance Metadata", "using v1 fallback (no token fetch)"), D(Z, {
          ...Y,
          timeout: G
        });
        else {
          let W;
          try {
            W = (await NC4({
              ...Y,
              timeout: G
            })).toString()
          } catch (J) {
            if (J?.statusCode === 400) throw Object.assign(J, {
              message: "EC2 Metadata token request returned error"
            });
            else if (J.message === "TimeoutError" || [403, 404, 405].includes(J.statusCode)) B = !0;
            return Q?.debug("AWS SDK Instance Metadata", "using v1 fallback (initial)"), D(Z, {
              ...Y,
              timeout: G
            })
          }
          return D(Z, {
            ...Y,
            headers: {
              [M10]: W
            },
            timeout: G
          })
        }
      }
    }, "getInstanceMetadataProvider"),
    NC4 = Y7(async (A) => Lb({
      ...A,
      path: wC4,
      method: "PUT",
      headers: {
        "x-aws-ec2-metadata-token-ttl-seconds": "21600"
      }
    }), "getMetadataToken"),
    $C4 = Y7(async (A) => (await Lb({
      ...A,
      path: y10
    })).toString(), "getProfile"),
    qC4 = Y7(async (A, B, Q) => {
      let I = JSON.parse((await Lb({
        ...B,
        path: y10 + A
      })).toString());
      if (!R10(I)) throw new dz.CredentialsProviderError("Invalid response received from instance metadata service.", {
        logger: Q.logger
      });
      return O10(I)
    }, "getCredentialsFromProfile")
})
// @from(Start 3471490, End 3488810)
WA0 = z((xI8, n71) => {
  var x10, f10, v10, b10, g10, h10, m10, d10, u10, p10, c10, l10, i10, l71, $y1, n10, a10, s10, Rb, r10, o10, t10, e10, AA0, BA0, QA0, IA0, GA0, i71, ZA0, DA0, YA0;
  (function(A) {
    var B = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
    if (typeof define === "function" && define.amd) define("tslib", ["exports"], function(I) {
      A(Q(B, Q(I)))
    });
    else if (typeof n71 === "object" && typeof xI8 === "object") A(Q(B, Q(xI8)));
    else A(Q(B));

    function Q(I, G) {
      if (I !== B)
        if (typeof Object.create === "function") Object.defineProperty(I, "__esModule", {
          value: !0
        });
        else I.__esModule = !0;
      return function(Z, D) {
        return I[Z] = G ? G(Z, D) : D
      }
    }
  })(function(A) {
    var B = Object.setPrototypeOf || {
      __proto__: []
    }
    instanceof Array && function(Z, D) {
      Z.__proto__ = D
    } || function(Z, D) {
      for (var Y in D)
        if (Object.prototype.hasOwnProperty.call(D, Y)) Z[Y] = D[Y]
    };
    x10 = function(Z, D) {
      if (typeof D !== "function" && D !== null) throw new TypeError("Class extends value " + String(D) + " is not a constructor or null");
      B(Z, D);

      function Y() {
        this.constructor = Z
      }
      Z.prototype = D === null ? Object.create(D) : (Y.prototype = D.prototype, new Y)
    }, f10 = Object.assign || function(Z) {
      for (var D, Y = 1, W = arguments.length; Y < W; Y++) {
        D = arguments[Y];
        for (var J in D)
          if (Object.prototype.hasOwnProperty.call(D, J)) Z[J] = D[J]
      }
      return Z
    }, v10 = function(Z, D) {
      var Y = {};
      for (var W in Z)
        if (Object.prototype.hasOwnProperty.call(Z, W) && D.indexOf(W) < 0) Y[W] = Z[W];
      if (Z != null && typeof Object.getOwnPropertySymbols === "function") {
        for (var J = 0, W = Object.getOwnPropertySymbols(Z); J < W.length; J++)
          if (D.indexOf(W[J]) < 0 && Object.prototype.propertyIsEnumerable.call(Z, W[J])) Y[W[J]] = Z[W[J]]
      }
      return Y
    }, b10 = function(Z, D, Y, W) {
      var J = arguments.length,
        F = J < 3 ? D : W === null ? W = Object.getOwnPropertyDescriptor(D, Y) : W,
        X;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") F = Reflect.decorate(Z, D, Y, W);
      else
        for (var V = Z.length - 1; V >= 0; V--)
          if (X = Z[V]) F = (J < 3 ? X(F) : J > 3 ? X(D, Y, F) : X(D, Y)) || F;
      return J > 3 && F && Object.defineProperty(D, Y, F), F
    }, g10 = function(Z, D) {
      return function(Y, W) {
        D(Y, W, Z)
      }
    }, h10 = function(Z, D, Y, W, J, F) {
      function X(_) {
        if (_ !== void 0 && typeof _ !== "function") throw new TypeError("Function expected");
        return _
      }
      var V = W.kind,
        C = V === "getter" ? "get" : V === "setter" ? "set" : "value",
        K = !D && Z ? W.static ? Z : Z.prototype : null,
        E = D || (K ? Object.getOwnPropertyDescriptor(K, W.name) : {}),
        N, q = !1;
      for (var O = Y.length - 1; O >= 0; O--) {
        var R = {};
        for (var T in W) R[T] = T === "access" ? {} : W[T];
        for (var T in W.access) R.access[T] = W.access[T];
        R.addInitializer = function(_) {
          if (q) throw new TypeError("Cannot add initializers after decoration has completed");
          F.push(X(_ || null))
        };
        var L = Y[O](V === "accessor" ? {
          get: E.get,
          set: E.set
        } : E[C], R);
        if (V === "accessor") {
          if (L === void 0) continue;
          if (L === null || typeof L !== "object") throw new TypeError("Object expected");
          if (N = X(L.get)) E.get = N;
          if (N = X(L.set)) E.set = N;
          if (N = X(L.init)) J.unshift(N)
        } else if (N = X(L))
          if (V === "field") J.unshift(N);
          else E[C] = N
      }
      if (K) Object.defineProperty(K, W.name, E);
      q = !0
    }, m10 = function(Z, D, Y) {
      var W = arguments.length > 2;
      for (var J = 0; J < D.length; J++) Y = W ? D[J].call(Z, Y) : D[J].call(Z);
      return W ? Y : void 0
    }, d10 = function(Z) {
      return typeof Z === "symbol" ? Z : "".concat(Z)
    }, u10 = function(Z, D, Y) {
      if (typeof D === "symbol") D = D.description ? "[".concat(D.description, "]") : "";
      return Object.defineProperty(Z, "name", {
        configurable: !0,
        value: Y ? "".concat(Y, " ", D) : D
      })
    }, p10 = function(Z, D) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(Z, D)
    }, c10 = function(Z, D, Y, W) {
      function J(F) {
        return F instanceof Y ? F : new Y(function(X) {
          X(F)
        })
      }
      return new(Y || (Y = Promise))(function(F, X) {
        function V(E) {
          try {
            K(W.next(E))
          } catch (N) {
            X(N)
          }
        }

        function C(E) {
          try {
            K(W.throw(E))
          } catch (N) {
            X(N)
          }
        }

        function K(E) {
          E.done ? F(E.value) : J(E.value).then(V, C)
        }
        K((W = W.apply(Z, D || [])).next())
      })
    }, l10 = function(Z, D) {
      var Y = {
          label: 0,
          sent: function() {
            if (F[0] & 1) throw F[1];
            return F[1]
          },
          trys: [],
          ops: []
        },
        W, J, F, X = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
      return X.next = V(0), X.throw = V(1), X.return = V(2), typeof Symbol === "function" && (X[Symbol.iterator] = function() {
        return this
      }), X;

      function V(K) {
        return function(E) {
          return C([K, E])
        }
      }

      function C(K) {
        if (W) throw new TypeError("Generator is already executing.");
        while (X && (X = 0, K[0] && (Y = 0)), Y) try {
          if (W = 1, J && (F = K[0] & 2 ? J.return : K[0] ? J.throw || ((F = J.return) && F.call(J), 0) : J.next) && !(F = F.call(J, K[1])).done) return F;
          if (J = 0, F) K = [K[0] & 2, F.value];
          switch (K[0]) {
            case 0:
            case 1:
              F = K;
              break;
            case 4:
              return Y.label++, {
                value: K[1],
                done: !1
              };
            case 5:
              Y.label++, J = K[1], K = [0];
              continue;
            case 7:
              K = Y.ops.pop(), Y.trys.pop();
              continue;
            default:
              if ((F = Y.trys, !(F = F.length > 0 && F[F.length - 1])) && (K[0] === 6 || K[0] === 2)) {
                Y = 0;
                continue
              }
              if (K[0] === 3 && (!F || K[1] > F[0] && K[1] < F[3])) {
                Y.label = K[1];
                break
              }
              if (K[0] === 6 && Y.label < F[1]) {
                Y.label = F[1], F = K;
                break
              }
              if (F && Y.label < F[2]) {
                Y.label = F[2], Y.ops.push(K);
                break
              }
              if (F[2]) Y.ops.pop();
              Y.trys.pop();
              continue
          }
          K = D.call(Z, Y)
        } catch (E) {
          K = [6, E], J = 0
        } finally {
          W = F = 0
        }
        if (K[0] & 5) throw K[1];
        return {
          value: K[0] ? K[1] : void 0,
          done: !0
        }
      }
    }, i10 = function(Z, D) {
      for (var Y in Z)
        if (Y !== "default" && !Object.prototype.hasOwnProperty.call(D, Y)) i71(D, Z, Y)
    }, i71 = Object.create ? function(Z, D, Y, W) {
      if (W === void 0) W = Y;
      var J = Object.getOwnPropertyDescriptor(D, Y);
      if (!J || ("get" in J ? !D.__esModule : J.writable || J.configurable)) J = {
        enumerable: !0,
        get: function() {
          return D[Y]
        }
      };
      Object.defineProperty(Z, W, J)
    } : function(Z, D, Y, W) {
      if (W === void 0) W = Y;
      Z[W] = D[Y]
    }, l71 = function(Z) {
      var D = typeof Symbol === "function" && Symbol.iterator,
        Y = D && Z[D],
        W = 0;
      if (Y) return Y.call(Z);
      if (Z && typeof Z.length === "number") return {
        next: function() {
          if (Z && W >= Z.length) Z = void 0;
          return {
            value: Z && Z[W++],
            done: !Z
          }
        }
      };
      throw new TypeError(D ? "Object is not iterable." : "Symbol.iterator is not defined.")
    }, $y1 = function(Z, D) {
      var Y = typeof Symbol === "function" && Z[Symbol.iterator];
      if (!Y) return Z;
      var W = Y.call(Z),
        J, F = [],
        X;
      try {
        while ((D === void 0 || D-- > 0) && !(J = W.next()).done) F.push(J.value)
      } catch (V) {
        X = {
          error: V
        }
      } finally {
        try {
          if (J && !J.done && (Y = W.return)) Y.call(W)
        } finally {
          if (X) throw X.error
        }
      }
      return F
    }, n10 = function() {
      for (var Z = [], D = 0; D < arguments.length; D++) Z = Z.concat($y1(arguments[D]));
      return Z
    }, a10 = function() {
      for (var Z = 0, D = 0, Y = arguments.length; D < Y; D++) Z += arguments[D].length;
      for (var W = Array(Z), J = 0, D = 0; D < Y; D++)
        for (var F = arguments[D], X = 0, V = F.length; X < V; X++, J++) W[J] = F[X];
      return W
    }, s10 = function(Z, D, Y) {
      if (Y || arguments.length === 2) {
        for (var W = 0, J = D.length, F; W < J; W++)
          if (F || !(W in D)) {
            if (!F) F = Array.prototype.slice.call(D, 0, W);
            F[W] = D[W]
          }
      }
      return Z.concat(F || Array.prototype.slice.call(D))
    }, Rb = function(Z) {
      return this instanceof Rb ? (this.v = Z, this) : new Rb(Z)
    }, r10 = function(Z, D, Y) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var W = Y.apply(Z, D || []),
        J, F = [];
      return J = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), V("next"), V("throw"), V("return", X), J[Symbol.asyncIterator] = function() {
        return this
      }, J;

      function X(O) {
        return function(R) {
          return Promise.resolve(R).then(O, N)
        }
      }

      function V(O, R) {
        if (W[O]) {
          if (J[O] = function(T) {
              return new Promise(function(L, _) {
                F.push([O, T, L, _]) > 1 || C(O, T)
              })
            }, R) J[O] = R(J[O])
        }
      }

      function C(O, R) {
        try {
          K(W[O](R))
        } catch (T) {
          q(F[0][3], T)
        }
      }

      function K(O) {
        O.value instanceof Rb ? Promise.resolve(O.value.v).then(E, N) : q(F[0][2], O)
      }

      function E(O) {
        C("next", O)
      }

      function N(O) {
        C("throw", O)
      }

      function q(O, R) {
        if (O(R), F.shift(), F.length) C(F[0][0], F[0][1])
      }
    }, o10 = function(Z) {
      var D, Y;
      return D = {}, W("next"), W("throw", function(J) {
        throw J
      }), W("return"), D[Symbol.iterator] = function() {
        return this
      }, D;

      function W(J, F) {
        D[J] = Z[J] ? function(X) {
          return (Y = !Y) ? {
            value: Rb(Z[J](X)),
            done: !1
          } : F ? F(X) : X
        } : F
      }
    }, t10 = function(Z) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var D = Z[Symbol.asyncIterator],
        Y;
      return D ? D.call(Z) : (Z = typeof l71 === "function" ? l71(Z) : Z[Symbol.iterator](), Y = {}, W("next"), W("throw"), W("return"), Y[Symbol.asyncIterator] = function() {
        return this
      }, Y);

      function W(F) {
        Y[F] = Z[F] && function(X) {
          return new Promise(function(V, C) {
            X = Z[F](X), J(V, C, X.done, X.value)
          })
        }
      }

      function J(F, X, V, C) {
        Promise.resolve(C).then(function(K) {
          F({
            value: K,
            done: V
          })
        }, X)
      }
    }, e10 = function(Z, D) {
      if (Object.defineProperty) Object.defineProperty(Z, "raw", {
        value: D
      });
      else Z.raw = D;
      return Z
    };
    var Q = Object.create ? function(Z, D) {
        Object.defineProperty(Z, "default", {
          enumerable: !0,
          value: D
        })
      } : function(Z, D) {
        Z.default = D
      },
      I = function(Z) {
        return I = Object.getOwnPropertyNames || function(D) {
          var Y = [];
          for (var W in D)
            if (Object.prototype.hasOwnProperty.call(D, W)) Y[Y.length] = W;
          return Y
        }, I(Z)
      };
    AA0 = function(Z) {
      if (Z && Z.__esModule) return Z;
      var D = {};
      if (Z != null) {
        for (var Y = I(Z), W = 0; W < Y.length; W++)
          if (Y[W] !== "default") i71(D, Z, Y[W])
      }
      return Q(D, Z), D
    }, BA0 = function(Z) {
      return Z && Z.__esModule ? Z : {
        default: Z
      }
    }, QA0 = function(Z, D, Y, W) {
      if (Y === "a" && !W) throw new TypeError("Private accessor was defined without a getter");
      if (typeof D === "function" ? Z !== D || !W : !D.has(Z)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
      return Y === "m" ? W : Y === "a" ? W.call(Z) : W ? W.value : D.get(Z)
    }, IA0 = function(Z, D, Y, W, J) {
      if (W === "m") throw new TypeError("Private method is not writable");
      if (W === "a" && !J) throw new TypeError("Private accessor was defined without a setter");
      if (typeof D === "function" ? Z !== D || !J : !D.has(Z)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
      return W === "a" ? J.call(Z, Y) : J ? J.value = Y : D.set(Z, Y), Y
    }, GA0 = function(Z, D) {
      if (D === null || typeof D !== "object" && typeof D !== "function") throw new TypeError("Cannot use 'in' operator on non-object");
      return typeof Z === "function" ? D === Z : Z.has(D)
    }, ZA0 = function(Z, D, Y) {
      if (D !== null && D !== void 0) {
        if (typeof D !== "object" && typeof D !== "function") throw new TypeError("Object expected.");
        var W, J;
        if (Y) {
          if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
          W = D[Symbol.asyncDispose]
        }
        if (W === void 0) {
          if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
          if (W = D[Symbol.dispose], Y) J = W
        }
        if (typeof W !== "function") throw new TypeError("Object not disposable.");
        if (J) W = function() {
          try {
            J.call(this)
          } catch (F) {
            return Promise.reject(F)
          }
        };
        Z.stack.push({
          value: D,
          dispose: W,
          async: Y
        })
      } else if (Y) Z.stack.push({
        async: !0
      });
      return D
    };
    var G = typeof SuppressedError === "function" ? SuppressedError : function(Z, D, Y) {
      var W = new Error(Y);
      return W.name = "SuppressedError", W.error = Z, W.suppressed = D, W
    };
    DA0 = function(Z) {
      function D(F) {
        Z.error = Z.hasError ? new G(F, Z.error, "An error was suppressed during disposal.") : F, Z.hasError = !0
      }
      var Y, W = 0;

      function J() {
        while (Y = Z.stack.pop()) try {
          if (!Y.async && W === 1) return W = 0, Z.stack.push(Y), Promise.resolve().then(J);
          if (Y.dispose) {
            var F = Y.dispose.call(Y.value);
            if (Y.async) return W |= 2, Promise.resolve(F).then(J, function(X) {
              return D(X), J()
            })
          } else W |= 1
        } catch (X) {
          D(X)
        }
        if (W === 1) return Z.hasError ? Promise.reject(Z.error) : Promise.resolve();
        if (Z.hasError) throw Z.error
      }
      return J()
    }, YA0 = function(Z, D) {
      if (typeof Z === "string" && /^\.\.?\//.test(Z)) return Z.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(Y, W, J, F, X) {
        return W ? D ? ".jsx" : ".js" : J && (!F || !X) ? Y : J + F + "." + X.toLowerCase() + "js"
      });
      return Z
    }, A("__extends", x10), A("__assign", f10), A("__rest", v10), A("__decorate", b10), A("__param", g10), A("__esDecorate", h10), A("__runInitializers", m10), A("__propKey", d10), A("__setFunctionName", u10), A("__metadata", p10), A("__awaiter", c10), A("__generator", l10), A("__exportStar", i10), A("__createBinding", i71), A("__values", l71), A("__read", $y1), A("__spread", n10), A("__spreadArrays", a10), A("__spreadArray", s10), A("__await", Rb), A("__asyncGenerator", r10), A("__asyncDelegator", o10), A("__asyncValues", t10), A("__makeTemplateObject", e10), A("__importStar", AA0), A("__importDefault", BA0), A("__classPrivateFieldGet", QA0), A("__classPrivateFieldSet", IA0), A("__classPrivateFieldIn", GA0), A("__addDisposableResource", ZA0), A("__disposeResources", DA0), A("__rewriteRelativeImportExtension", YA0)
  })
})
// @from(Start 3488816, End 3489939)
XA0 = z((JA0) => {
  Object.defineProperty(JA0, "__esModule", {
    value: !0
  });
  JA0.checkUrl = void 0;
  var MC4 = $I(),
    LC4 = "169.254.170.2",
    RC4 = "169.254.170.23",
    OC4 = "[fd00:ec2::23]",
    TC4 = (A, B) => {
      if (A.protocol === "https:") return;
      if (A.hostname === LC4 || A.hostname === RC4 || A.hostname === OC4) return;
      if (A.hostname.includes("[")) {
        if (A.hostname === "[::1]" || A.hostname === "[0000:0000:0000:0000:0000:0000:0000:0001]") return
      } else {
        if (A.hostname === "localhost") return;
        let Q = A.hostname.split("."),
          I = (G) => {
            let Z = parseInt(G, 10);
            return 0 <= Z && Z <= 255
          };
        if (Q[0] === "127" && I(Q[1]) && I(Q[2]) && I(Q[3]) && Q.length === 4) return
      }
      throw new MC4.CredentialsProviderError(`URL not accepted. It must either be HTTPS or match one of the following:
  - loopback CIDR 127.0.0.0/8 or [::1/128]
  - ECS container host 169.254.170.2
  - EKS container host 169.254.170.23 or [fd00:ec2::23]`, {
        logger: B
      })
    };
  JA0.checkUrl = TC4
})
// @from(Start 3489945, End 3492728)
qy1 = z((vI8, NA0) => {
  var {
    defineProperty: a71,
    getOwnPropertyDescriptor: PC4,
    getOwnPropertyNames: SC4
  } = Object, _C4 = Object.prototype.hasOwnProperty, s71 = (A, B) => a71(A, "name", {
    value: B,
    configurable: !0
  }), jC4 = (A, B) => {
    for (var Q in B) a71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, yC4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of SC4(B))
        if (!_C4.call(A, G) && G !== Q) a71(A, G, {
          get: () => B[G],
          enumerable: !(I = PC4(B, G)) || I.enumerable
        })
    }
    return A
  }, kC4 = (A) => yC4(a71({}, "__esModule", {
    value: !0
  }), A), VA0 = {};
  jC4(VA0, {
    AlgorithmId: () => zA0,
    EndpointURLScheme: () => HA0,
    FieldPosition: () => wA0,
    HttpApiKeyAuthLocation: () => KA0,
    HttpAuthLocation: () => CA0,
    IniSectionType: () => EA0,
    RequestHandlerProtocol: () => UA0,
    SMITHY_CONTEXT_KEY: () => gC4,
    getDefaultClientConfiguration: () => vC4,
    resolveDefaultRuntimeConfig: () => bC4
  });
  NA0.exports = kC4(VA0);
  var CA0 = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(CA0 || {}),
    KA0 = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(KA0 || {}),
    HA0 = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(HA0 || {}),
    zA0 = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(zA0 || {}),
    xC4 = s71((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    fC4 = s71((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    vC4 = s71((A) => {
      return xC4(A)
    }, "getDefaultClientConfiguration"),
    bC4 = s71((A) => {
      return fC4(A)
    }, "resolveDefaultRuntimeConfig"),
    wA0 = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(wA0 || {}),
    gC4 = "__smithy_context",
    EA0 = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(EA0 || {}),
    UA0 = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(UA0 || {})
})
// @from(Start 3492734, End 3497241)
OA0 = z((bI8, RA0) => {
  var {
    defineProperty: r71,
    getOwnPropertyDescriptor: hC4,
    getOwnPropertyNames: mC4
  } = Object, dC4 = Object.prototype.hasOwnProperty, gL = (A, B) => r71(A, "name", {
    value: B,
    configurable: !0
  }), uC4 = (A, B) => {
    for (var Q in B) r71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, pC4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of mC4(B))
        if (!dC4.call(A, G) && G !== Q) r71(A, G, {
          get: () => B[G],
          enumerable: !(I = hC4(B, G)) || I.enumerable
        })
    }
    return A
  }, cC4 = (A) => pC4(r71({}, "__esModule", {
    value: !0
  }), A), $A0 = {};
  uC4($A0, {
    Field: () => nC4,
    Fields: () => aC4,
    HttpRequest: () => sC4,
    HttpResponse: () => rC4,
    IHttpRequest: () => qA0.HttpRequest,
    getHttpHandlerExtensionConfiguration: () => lC4,
    isValidHostname: () => LA0,
    resolveHttpHandlerRuntimeConfig: () => iC4
  });
  RA0.exports = cC4($A0);
  var lC4 = gL((A) => {
      return {
        setHttpHandler(B) {
          A.httpHandler = B
        },
        httpHandler() {
          return A.httpHandler
        },
        updateHttpClientConfig(B, Q) {
          A.httpHandler?.updateHttpClientConfig(B, Q)
        },
        httpHandlerConfigs() {
          return A.httpHandler.httpHandlerConfigs()
        }
      }
    }, "getHttpHandlerExtensionConfiguration"),
    iC4 = gL((A) => {
      return {
        httpHandler: A.httpHandler()
      }
    }, "resolveHttpHandlerRuntimeConfig"),
    qA0 = qy1(),
    nC4 = class {
      static {
        gL(this, "Field")
      }
      constructor({
        name: A,
        kind: B = qA0.FieldPosition.HEADER,
        values: Q = []
      }) {
        this.name = A, this.kind = B, this.values = Q
      }
      add(A) {
        this.values.push(A)
      }
      set(A) {
        this.values = A
      }
      remove(A) {
        this.values = this.values.filter((B) => B !== A)
      }
      toString() {
        return this.values.map((A) => A.includes(",") || A.includes(" ") ? `"${A}"` : A).join(", ")
      }
      get() {
        return this.values
      }
    },
    aC4 = class {
      constructor({
        fields: A = [],
        encoding: B = "utf-8"
      }) {
        this.entries = {}, A.forEach(this.setField.bind(this)), this.encoding = B
      }
      static {
        gL(this, "Fields")
      }
      setField(A) {
        this.entries[A.name.toLowerCase()] = A
      }
      getField(A) {
        return this.entries[A.toLowerCase()]
      }
      removeField(A) {
        delete this.entries[A.toLowerCase()]
      }
      getByType(A) {
        return Object.values(this.entries).filter((B) => B.kind === A)
      }
    },
    sC4 = class A {
      static {
        gL(this, "HttpRequest")
      }
      constructor(B) {
        this.method = B.method || "GET", this.hostname = B.hostname || "localhost", this.port = B.port, this.query = B.query || {}, this.headers = B.headers || {}, this.body = B.body, this.protocol = B.protocol ? B.protocol.slice(-1) !== ":" ? `${B.protocol}:` : B.protocol : "https:", this.path = B.path ? B.path.charAt(0) !== "/" ? `/${B.path}` : B.path : "/", this.username = B.username, this.password = B.password, this.fragment = B.fragment
      }
      static clone(B) {
        let Q = new A({
          ...B,
          headers: {
            ...B.headers
          }
        });
        if (Q.query) Q.query = MA0(Q.query);
        return Q
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return "method" in Q && "protocol" in Q && "hostname" in Q && "path" in Q && typeof Q.query === "object" && typeof Q.headers === "object"
      }
      clone() {
        return A.clone(this)
      }
    };

  function MA0(A) {
    return Object.keys(A).reduce((B, Q) => {
      let I = A[Q];
      return {
        ...B,
        [Q]: Array.isArray(I) ? [...I] : I
      }
    }, {})
  }
  gL(MA0, "cloneQuery");
  var rC4 = class {
    static {
      gL(this, "HttpResponse")
    }
    constructor(A) {
      this.statusCode = A.statusCode, this.reason = A.reason, this.headers = A.headers || {}, this.body = A.body
    }
    static isInstance(A) {
      if (!A) return !1;
      let B = A;
      return typeof B.statusCode === "number" && typeof B.headers === "object"
    }
  };

  function LA0(A) {
    return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(A)
  }
  gL(LA0, "isValidHostname")
})
// @from(Start 3497247, End 3525785)
lA0 = z((dI8, cA0) => {
  var {
    defineProperty: e71,
    getOwnPropertyDescriptor: oC4,
    getOwnPropertyNames: tC4
  } = Object, eC4 = Object.prototype.hasOwnProperty, t0 = (A, B) => e71(A, "name", {
    value: B,
    configurable: !0
  }), AK4 = (A, B) => {
    for (var Q in B) e71(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, BK4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of tC4(B))
        if (!eC4.call(A, G) && G !== Q) e71(A, G, {
          get: () => B[G],
          enumerable: !(I = oC4(B, G)) || I.enumerable
        })
    }
    return A
  }, QK4 = (A) => BK4(e71({}, "__esModule", {
    value: !0
  }), A), PA0 = {};
  AK4(PA0, {
    Client: () => IK4,
    Command: () => _A0,
    LazyJsonString: () => Q_,
    NoOpLogger: () => eK4,
    SENSITIVE_STRING: () => ZK4,
    ServiceException: () => mK4,
    _json: () => Sy1,
    collectBody: () => My1.collectBody,
    convertMap: () => AH4,
    createAggregatedClient: () => DK4,
    dateToUtcString: () => vA0,
    decorateServiceException: () => bA0,
    emitWarningIfUnsupportedVersion: () => cK4,
    expectBoolean: () => WK4,
    expectByte: () => Py1,
    expectFloat32: () => o71,
    expectInt: () => FK4,
    expectInt32: () => Oy1,
    expectLong: () => Ka,
    expectNonNull: () => VK4,
    expectNumber: () => Ca,
    expectObject: () => jA0,
    expectShort: () => Ty1,
    expectString: () => CK4,
    expectUnion: () => KK4,
    extendedEncodeURIComponent: () => My1.extendedEncodeURIComponent,
    getArrayIfSingleItem: () => oK4,
    getDefaultClientConfiguration: () => sK4,
    getDefaultExtensionConfiguration: () => hA0,
    getValueFromTextNode: () => mA0,
    handleFloat: () => wK4,
    isSerializableHeaderValue: () => tK4,
    limitedParseDouble: () => yy1,
    limitedParseFloat: () => EK4,
    limitedParseFloat32: () => UK4,
    loadConfigsForDefaultMode: () => pK4,
    logger: () => Ha,
    map: () => xy1,
    parseBoolean: () => YK4,
    parseEpochTimestamp: () => jK4,
    parseRfc3339DateTime: () => LK4,
    parseRfc3339DateTimeWithOffset: () => OK4,
    parseRfc7231DateTime: () => _K4,
    quoteHeader: () => uA0,
    resolveDefaultRuntimeConfig: () => rK4,
    resolvedPath: () => My1.resolvedPath,
    serializeDateTime: () => DH4,
    serializeFloat: () => ZH4,
    splitEvery: () => pA0,
    splitHeader: () => YH4,
    strictParseByte: () => fA0,
    strictParseDouble: () => jy1,
    strictParseFloat: () => HK4,
    strictParseFloat32: () => yA0,
    strictParseInt: () => NK4,
    strictParseInt32: () => $K4,
    strictParseLong: () => xA0,
    strictParseShort: () => Ob,
    take: () => BH4,
    throwDefaultError: () => gA0,
    withBaseException: () => dK4
  });
  cA0.exports = QK4(PA0);
  var SA0 = WN(),
    IK4 = class {
      constructor(A) {
        this.config = A, this.middlewareStack = SA0.constructStack()
      }
      static {
        t0(this, "Client")
      }
      send(A, B, Q) {
        let I = typeof B !== "function" ? B : void 0,
          G = typeof B === "function" ? B : Q,
          Z = I === void 0 && this.config.cacheMiddleware === !0,
          D;
        if (Z) {
          if (!this.handlers) this.handlers = new WeakMap;
          let Y = this.handlers;
          if (Y.has(A.constructor)) D = Y.get(A.constructor);
          else D = A.resolveMiddleware(this.middlewareStack, this.config, I), Y.set(A.constructor, D)
        } else delete this.handlers, D = A.resolveMiddleware(this.middlewareStack, this.config, I);
        if (G) D(A).then((Y) => G(null, Y.output), (Y) => G(Y)).catch(() => {});
        else return D(A).then((Y) => Y.output)
      }
      destroy() {
        this.config?.requestHandler?.destroy?.(), delete this.handlers
      }
    },
    My1 = vz(),
    Ry1 = qy1(),
    _A0 = class {
      constructor() {
        this.middlewareStack = SA0.constructStack()
      }
      static {
        t0(this, "Command")
      }
      static classBuilder() {
        return new GK4
      }
      resolveMiddlewareWithContext(A, B, Q, {
        middlewareFn: I,
        clientName: G,
        commandName: Z,
        inputFilterSensitiveLog: D,
        outputFilterSensitiveLog: Y,
        smithyContext: W,
        additionalContext: J,
        CommandCtor: F
      }) {
        for (let E of I.bind(this)(F, A, B, Q)) this.middlewareStack.use(E);
        let X = A.concat(this.middlewareStack),
          {
            logger: V
          } = B,
          C = {
            logger: V,
            clientName: G,
            commandName: Z,
            inputFilterSensitiveLog: D,
            outputFilterSensitiveLog: Y,
            [Ry1.SMITHY_CONTEXT_KEY]: {
              commandInstance: this,
              ...W
            },
            ...J
          },
          {
            requestHandler: K
          } = B;
        return X.resolve((E) => K.handle(E.request, Q || {}), C)
      }
    },
    GK4 = class {
      constructor() {
        this._init = () => {}, this._ep = {}, this._middlewareFn = () => [], this._commandName = "", this._clientName = "", this._additionalContext = {}, this._smithyContext = {}, this._inputFilterSensitiveLog = (A) => A, this._outputFilterSensitiveLog = (A) => A, this._serializer = null, this._deserializer = null
      }
      static {
        t0(this, "ClassBuilder")
      }
      init(A) {
        this._init = A
      }
      ep(A) {
        return this._ep = A, this
      }
      m(A) {
        return this._middlewareFn = A, this
      }
      s(A, B, Q = {}) {
        return this._smithyContext = {
          service: A,
          operation: B,
          ...Q
        }, this
      }
      c(A = {}) {
        return this._additionalContext = A, this
      }
      n(A, B) {
        return this._clientName = A, this._commandName = B, this
      }
      f(A = (Q) => Q, B = (Q) => Q) {
        return this._inputFilterSensitiveLog = A, this._outputFilterSensitiveLog = B, this
      }
      ser(A) {
        return this._serializer = A, this
      }
      de(A) {
        return this._deserializer = A, this
      }
      build() {
        let A = this,
          B;
        return B = class extends _A0 {
          constructor(...[Q]) {
            super();
            this.serialize = A._serializer, this.deserialize = A._deserializer, this.input = Q ?? {}, A._init(this)
          }
          static {
            t0(this, "CommandRef")
          }
          static getEndpointParameterInstructions() {
            return A._ep
          }
          resolveMiddleware(Q, I, G) {
            return this.resolveMiddlewareWithContext(Q, I, G, {
              CommandCtor: B,
              middlewareFn: A._middlewareFn,
              clientName: A._clientName,
              commandName: A._commandName,
              inputFilterSensitiveLog: A._inputFilterSensitiveLog,
              outputFilterSensitiveLog: A._outputFilterSensitiveLog,
              smithyContext: A._smithyContext,
              additionalContext: A._additionalContext
            })
          }
        }
      }
    },
    ZK4 = "***SensitiveInformation***",
    DK4 = t0((A, B) => {
      for (let Q of Object.keys(A)) {
        let I = A[Q],
          G = t0(async function(D, Y, W) {
            let J = new I(D);
            if (typeof Y === "function") this.send(J, Y);
            else if (typeof W === "function") {
              if (typeof Y !== "object") throw new Error(`Expected http options but got ${typeof Y}`);
              this.send(J, Y || {}, W)
            } else return this.send(J, Y)
          }, "methodImpl"),
          Z = (Q[0].toLowerCase() + Q.slice(1)).replace(/Command$/, "");
        B.prototype[Z] = G
      }
    }, "createAggregatedClient"),
    YK4 = t0((A) => {
      switch (A) {
        case "true":
          return !0;
        case "false":
          return !1;
        default:
          throw new Error(`Unable to parse boolean value "${A}"`)
      }
    }, "parseBoolean"),
    WK4 = t0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "number") {
        if (A === 0 || A === 1) Ha.warn(t71(`Expected boolean, got ${typeof A}: ${A}`));
        if (A === 0) return !1;
        if (A === 1) return !0
      }
      if (typeof A === "string") {
        let B = A.toLowerCase();
        if (B === "false" || B === "true") Ha.warn(t71(`Expected boolean, got ${typeof A}: ${A}`));
        if (B === "false") return !1;
        if (B === "true") return !0
      }
      if (typeof A === "boolean") return A;
      throw new TypeError(`Expected boolean, got ${typeof A}: ${A}`)
    }, "expectBoolean"),
    Ca = t0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "string") {
        let B = parseFloat(A);
        if (!Number.isNaN(B)) {
          if (String(B) !== String(A)) Ha.warn(t71(`Expected number but observed string: ${A}`));
          return B
        }
      }
      if (typeof A === "number") return A;
      throw new TypeError(`Expected number, got ${typeof A}: ${A}`)
    }, "expectNumber"),
    JK4 = Math.ceil(340282346638528860000000000000000000000),
    o71 = t0((A) => {
      let B = Ca(A);
      if (B !== void 0 && !Number.isNaN(B) && B !== 1 / 0 && B !== -1 / 0) {
        if (Math.abs(B) > JK4) throw new TypeError(`Expected 32-bit float, got ${A}`)
      }
      return B
    }, "expectFloat32"),
    Ka = t0((A) => {
      if (A === null || A === void 0) return;
      if (Number.isInteger(A) && !Number.isNaN(A)) return A;
      throw new TypeError(`Expected integer, got ${typeof A}: ${A}`)
    }, "expectLong"),
    FK4 = Ka,
    Oy1 = t0((A) => _y1(A, 32), "expectInt32"),
    Ty1 = t0((A) => _y1(A, 16), "expectShort"),
    Py1 = t0((A) => _y1(A, 8), "expectByte"),
    _y1 = t0((A, B) => {
      let Q = Ka(A);
      if (Q !== void 0 && XK4(Q, B) !== Q) throw new TypeError(`Expected ${B}-bit integer, got ${A}`);
      return Q
    }, "expectSizedInt"),
    XK4 = t0((A, B) => {
      switch (B) {
        case 32:
          return Int32Array.of(A)[0];
        case 16:
          return Int16Array.of(A)[0];
        case 8:
          return Int8Array.of(A)[0]
      }
    }, "castInt"),
    VK4 = t0((A, B) => {
      if (A === null || A === void 0) {
        if (B) throw new TypeError(`Expected a non-null value for ${B}`);
        throw new TypeError("Expected a non-null value")
      }
      return A
    }, "expectNonNull"),
    jA0 = t0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "object" && !Array.isArray(A)) return A;
      let B = Array.isArray(A) ? "array" : typeof A;
      throw new TypeError(`Expected object, got ${B}: ${A}`)
    }, "expectObject"),
    CK4 = t0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "string") return A;
      if (["boolean", "number", "bigint"].includes(typeof A)) return Ha.warn(t71(`Expected string, got ${typeof A}: ${A}`)), String(A);
      throw new TypeError(`Expected string, got ${typeof A}: ${A}`)
    }, "expectString"),
    KK4 = t0((A) => {
      if (A === null || A === void 0) return;
      let B = jA0(A),
        Q = Object.entries(B).filter(([, I]) => I != null).map(([I]) => I);
      if (Q.length === 0) throw new TypeError("Unions must have exactly one non-null member. None were found.");
      if (Q.length > 1) throw new TypeError(`Unions must have exactly one non-null member. Keys ${Q} were not null.`);
      return B
    }, "expectUnion"),
    jy1 = t0((A) => {
      if (typeof A == "string") return Ca(Pb(A));
      return Ca(A)
    }, "strictParseDouble"),
    HK4 = jy1,
    yA0 = t0((A) => {
      if (typeof A == "string") return o71(Pb(A));
      return o71(A)
    }, "strictParseFloat32"),
    zK4 = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g,
    Pb = t0((A) => {
      let B = A.match(zK4);
      if (B === null || B[0].length !== A.length) throw new TypeError("Expected real number, got implicit NaN");
      return parseFloat(A)
    }, "parseNumber"),
    yy1 = t0((A) => {
      if (typeof A == "string") return kA0(A);
      return Ca(A)
    }, "limitedParseDouble"),
    wK4 = yy1,
    EK4 = yy1,
    UK4 = t0((A) => {
      if (typeof A == "string") return kA0(A);
      return o71(A)
    }, "limitedParseFloat32"),
    kA0 = t0((A) => {
      switch (A) {
        case "NaN":
          return NaN;
        case "Infinity":
          return 1 / 0;
        case "-Infinity":
          return -1 / 0;
        default:
          throw new Error(`Unable to parse float value: ${A}`)
      }
    }, "parseFloatString"),
    xA0 = t0((A) => {
      if (typeof A === "string") return Ka(Pb(A));
      return Ka(A)
    }, "strictParseLong"),
    NK4 = xA0,
    $K4 = t0((A) => {
      if (typeof A === "string") return Oy1(Pb(A));
      return Oy1(A)
    }, "strictParseInt32"),
    Ob = t0((A) => {
      if (typeof A === "string") return Ty1(Pb(A));
      return Ty1(A)
    }, "strictParseShort"),
    fA0 = t0((A) => {
      if (typeof A === "string") return Py1(Pb(A));
      return Py1(A)
    }, "strictParseByte"),
    t71 = t0((A) => {
      return String(new TypeError(A).stack || A).split(`
`).slice(0, 5).filter((B) => !B.includes("stackTraceWarning")).join(`
`)
    }, "stackTraceWarning"),
    Ha = {
      warn: console.warn
    },
    qK4 = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
    ky1 = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];

  function vA0(A) {
    let B = A.getUTCFullYear(),
      Q = A.getUTCMonth(),
      I = A.getUTCDay(),
      G = A.getUTCDate(),
      Z = A.getUTCHours(),
      D = A.getUTCMinutes(),
      Y = A.getUTCSeconds(),
      W = G < 10 ? `0${G}` : `${G}`,
      J = Z < 10 ? `0${Z}` : `${Z}`,
      F = D < 10 ? `0${D}` : `${D}`,
      X = Y < 10 ? `0${Y}` : `${Y}`;
    return `${qK4[I]}, ${W} ${ky1[Q]} ${B} ${J}:${F}:${X} GMT`
  }
  t0(vA0, "dateToUtcString");
  var MK4 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/),
    LK4 = t0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-3339 date-times must be expressed as strings");
      let B = MK4.exec(A);
      if (!B) throw new TypeError("Invalid RFC-3339 date-time value");
      let [Q, I, G, Z, D, Y, W, J] = B, F = Ob(Tb(I)), X = uz(G, "month", 1, 12), V = uz(Z, "day", 1, 31);
      return Va(F, X, V, {
        hours: D,
        minutes: Y,
        seconds: W,
        fractionalMilliseconds: J
      })
    }, "parseRfc3339DateTime"),
    RK4 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/),
    OK4 = t0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-3339 date-times must be expressed as strings");
      let B = RK4.exec(A);
      if (!B) throw new TypeError("Invalid RFC-3339 date-time value");
      let [Q, I, G, Z, D, Y, W, J, F] = B, X = Ob(Tb(I)), V = uz(G, "month", 1, 12), C = uz(Z, "day", 1, 31), K = Va(X, V, C, {
        hours: D,
        minutes: Y,
        seconds: W,
        fractionalMilliseconds: J
      });
      if (F.toUpperCase() != "Z") K.setTime(K.getTime() - hK4(F));
      return K
    }, "parseRfc3339DateTimeWithOffset"),
    TK4 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/),
    PK4 = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/),
    SK4 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/),
    _K4 = t0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-7231 date-times must be expressed as strings");
      let B = TK4.exec(A);
      if (B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return Va(Ob(Tb(Z)), Ly1(G), uz(I, "day", 1, 31), {
          hours: D,
          minutes: Y,
          seconds: W,
          fractionalMilliseconds: J
        })
      }
      if (B = PK4.exec(A), B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return xK4(Va(yK4(Z), Ly1(G), uz(I, "day", 1, 31), {
          hours: D,
          minutes: Y,
          seconds: W,
          fractionalMilliseconds: J
        }))
      }
      if (B = SK4.exec(A), B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return Va(Ob(Tb(J)), Ly1(I), uz(G.trimLeft(), "day", 1, 31), {
          hours: Z,
          minutes: D,
          seconds: Y,
          fractionalMilliseconds: W
        })
      }
      throw new TypeError("Invalid RFC-7231 date-time value")
    }, "parseRfc7231DateTime"),
    jK4 = t0((A) => {
      if (A === null || A === void 0) return;
      let B;
      if (typeof A === "number") B = A;
      else if (typeof A === "string") B = jy1(A);
      else if (typeof A === "object" && A.tag === 1) B = A.value;
      else throw new TypeError("Epoch timestamps must be expressed as floating point numbers or their string representation");
      if (Number.isNaN(B) || B === 1 / 0 || B === -1 / 0) throw new TypeError("Epoch timestamps must be valid, non-Infinite, non-NaN numerics");
      return new Date(Math.round(B * 1000))
    }, "parseEpochTimestamp"),
    Va = t0((A, B, Q, I) => {
      let G = B - 1;
      return vK4(A, G, Q), new Date(Date.UTC(A, G, Q, uz(I.hours, "hour", 0, 23), uz(I.minutes, "minute", 0, 59), uz(I.seconds, "seconds", 0, 60), gK4(I.fractionalMilliseconds)))
    }, "buildDate"),
    yK4 = t0((A) => {
      let B = new Date().getUTCFullYear(),
        Q = Math.floor(B / 100) * 100 + Ob(Tb(A));
      if (Q < B) return Q + 100;
      return Q
    }, "parseTwoDigitYear"),
    kK4 = 1576800000000,
    xK4 = t0((A) => {
      if (A.getTime() - new Date().getTime() > kK4) return new Date(Date.UTC(A.getUTCFullYear() - 100, A.getUTCMonth(), A.getUTCDate(), A.getUTCHours(), A.getUTCMinutes(), A.getUTCSeconds(), A.getUTCMilliseconds()));
      return A
    }, "adjustRfc850Year"),
    Ly1 = t0((A) => {
      let B = ky1.indexOf(A);
      if (B < 0) throw new TypeError(`Invalid month: ${A}`);
      return B + 1
    }, "parseMonthByShortName"),
    fK4 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
    vK4 = t0((A, B, Q) => {
      let I = fK4[B];
      if (B === 1 && bK4(A)) I = 29;
      if (Q > I) throw new TypeError(`Invalid day for ${ky1[B]} in ${A}: ${Q}`)
    }, "validateDayOfMonth"),
    bK4 = t0((A) => {
      return A % 4 === 0 && (A % 100 !== 0 || A % 400 === 0)
    }, "isLeapYear"),
    uz = t0((A, B, Q, I) => {
      let G = fA0(Tb(A));
      if (G < Q || G > I) throw new TypeError(`${B} must be between ${Q} and ${I}, inclusive`);
      return G
    }, "parseDateValue"),
    gK4 = t0((A) => {
      if (A === null || A === void 0) return 0;
      return yA0("0." + A) * 1000
    }, "parseMilliseconds"),
    hK4 = t0((A) => {
      let B = A[0],
        Q = 1;
      if (B == "+") Q = 1;
      else if (B == "-") Q = -1;
      else throw new TypeError(`Offset direction, ${B}, must be "+" or "-"`);
      let I = Number(A.substring(1, 3)),
        G = Number(A.substring(4, 6));
      return Q * (I * 60 + G) * 60 * 1000
    }, "parseOffsetToMilliseconds"),
    Tb = t0((A) => {
      let B = 0;
      while (B < A.length - 1 && A.charAt(B) === "0") B++;
      if (B === 0) return A;
      return A.slice(B)
    }, "stripLeadingZeroes"),
    mK4 = class A extends Error {
      static {
        t0(this, "ServiceException")
      }
      constructor(B) {
        super(B.message);
        Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype), this.name = B.name, this.$fault = B.$fault, this.$metadata = B.$metadata
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return A.prototype.isPrototypeOf(Q) || Boolean(Q.$fault) && Boolean(Q.$metadata) && (Q.$fault === "client" || Q.$fault === "server")
      }
      static[Symbol.hasInstance](B) {
        if (!B) return !1;
        let Q = B;
        if (this === A) return A.isInstance(B);
        if (A.isInstance(B)) {
          if (Q.name && this.name) return this.prototype.isPrototypeOf(B) || Q.name === this.name;
          return this.prototype.isPrototypeOf(B)
        }
        return !1
      }
    },
    bA0 = t0((A, B = {}) => {
      Object.entries(B).filter(([, I]) => I !== void 0).forEach(([I, G]) => {
        if (A[I] == null || A[I] === "") A[I] = G
      });
      let Q = A.message || A.Message || "UnknownError";
      return A.message = Q, delete A.Message, A
    }, "decorateServiceException"),
    gA0 = t0(({
      output: A,
      parsedBody: B,
      exceptionCtor: Q,
      errorCode: I
    }) => {
      let G = uK4(A),
        Z = G.httpStatusCode ? G.httpStatusCode + "" : void 0,
        D = new Q({
          name: B?.code || B?.Code || I || Z || "UnknownError",
          $fault: "client",
          $metadata: G
        });
      throw bA0(D, B)
    }, "throwDefaultError"),
    dK4 = t0((A) => {
      return ({
        output: B,
        parsedBody: Q,
        errorCode: I
      }) => {
        gA0({
          output: B,
          parsedBody: Q,
          exceptionCtor: A,
          errorCode: I
        })
      }
    }, "withBaseException"),
    uK4 = t0((A) => ({
      httpStatusCode: A.statusCode,
      requestId: A.headers["x-amzn-requestid"] ?? A.headers["x-amzn-request-id"] ?? A.headers["x-amz-request-id"],
      extendedRequestId: A.headers["x-amz-id-2"],
      cfId: A.headers["x-amz-cf-id"]
    }), "deserializeMetadata"),
    pK4 = t0((A) => {
      switch (A) {
        case "standard":
          return {
            retryMode: "standard", connectionTimeout: 3100
          };
        case "in-region":
          return {
            retryMode: "standard", connectionTimeout: 1100
          };
        case "cross-region":
          return {
            retryMode: "standard", connectionTimeout: 3100
          };
        case "mobile":
          return {
            retryMode: "standard", connectionTimeout: 30000
          };
        default:
          return {}
      }
    }, "loadConfigsForDefaultMode"),
    TA0 = !1,
    cK4 = t0((A) => {
      if (A && !TA0 && parseInt(A.substring(1, A.indexOf("."))) < 16) TA0 = !0
    }, "emitWarningIfUnsupportedVersion"),
    lK4 = t0((A) => {
      let B = [];
      for (let Q in Ry1.AlgorithmId) {
        let I = Ry1.AlgorithmId[Q];
        if (A[I] === void 0) continue;
        B.push({
          algorithmId: () => I,
          checksumConstructor: () => A[I]
        })
      }
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    iK4 = t0((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    nK4 = t0((A) => {
      return {
        setRetryStrategy(B) {
          A.retryStrategy = B
        },
        retryStrategy() {
          return A.retryStrategy
        }
      }
    }, "getRetryConfiguration"),
    aK4 = t0((A) => {
      let B = {};
      return B.retryStrategy = A.retryStrategy(), B
    }, "resolveRetryRuntimeConfig"),
    hA0 = t0((A) => {
      return Object.assign(lK4(A), nK4(A))
    }, "getDefaultExtensionConfiguration"),
    sK4 = hA0,
    rK4 = t0((A) => {
      return Object.assign(iK4(A), aK4(A))
    }, "resolveDefaultRuntimeConfig"),
    oK4 = t0((A) => Array.isArray(A) ? A : [A], "getArrayIfSingleItem"),
    mA0 = t0((A) => {
      for (let Q in A)
        if (A.hasOwnProperty(Q) && A[Q]["#text"] !== void 0) A[Q] = A[Q]["#text"];
        else if (typeof A[Q] === "object" && A[Q] !== null) A[Q] = mA0(A[Q]);
      return A
    }, "getValueFromTextNode"),
    tK4 = t0((A) => {
      return A != null
    }, "isSerializableHeaderValue"),
    Q_ = t0(function A(B) {
      return Object.assign(new String(B), {
        deserializeJSON() {
          return JSON.parse(String(B))
        },
        toString() {
          return String(B)
        },
        toJSON() {
          return String(B)
        }
      })
    }, "LazyJsonString");
  Q_.from = (A) => {
    if (A && typeof A === "object" && (A instanceof Q_ || ("deserializeJSON" in A))) return A;
    else if (typeof A === "string" || Object.getPrototypeOf(A) === String.prototype) return Q_(String(A));
    return Q_(JSON.stringify(A))
  };
  Q_.fromObject = Q_.from;
  var eK4 = class {
    static {
      t0(this, "NoOpLogger")
    }
    trace() {}
    debug() {}
    info() {}
    warn() {}
    error() {}
  };

  function xy1(A, B, Q) {
    let I, G, Z;
    if (typeof B === "undefined" && typeof Q === "undefined") I = {}, Z = A;
    else if (I = A, typeof B === "function") return G = B, Z = Q, QH4(I, G, Z);
    else Z = B;
    for (let D of Object.keys(Z)) {
      if (!Array.isArray(Z[D])) {
        I[D] = Z[D];
        continue
      }
      dA0(I, null, Z, D)
    }
    return I
  }
  t0(xy1, "map");
  var AH4 = t0((A) => {
      let B = {};
      for (let [Q, I] of Object.entries(A || {})) B[Q] = [, I];
      return B
    }, "convertMap"),
    BH4 = t0((A, B) => {
      let Q = {};
      for (let I in B) dA0(Q, A, B, I);
      return Q
    }, "take"),
    QH4 = t0((A, B, Q) => {
      return xy1(A, Object.entries(Q).reduce((I, [G, Z]) => {
        if (Array.isArray(Z)) I[G] = Z;
        else if (typeof Z === "function") I[G] = [B, Z()];
        else I[G] = [B, Z];
        return I
      }, {}))
    }, "mapWithFilter"),
    dA0 = t0((A, B, Q, I) => {
      if (B !== null) {
        let D = Q[I];
        if (typeof D === "function") D = [, D];
        let [Y = IH4, W = GH4, J = I] = D;
        if (typeof Y === "function" && Y(B[J]) || typeof Y !== "function" && !!Y) A[I] = W(B[J]);
        return
      }
      let [G, Z] = Q[I];
      if (typeof Z === "function") {
        let D, Y = G === void 0 && (D = Z()) != null,
          W = typeof G === "function" && !!G(void 0) || typeof G !== "function" && !!G;
        if (Y) A[I] = D;
        else if (W) A[I] = Z()
      } else {
        let D = G === void 0 && Z != null,
          Y = typeof G === "function" && !!G(Z) || typeof G !== "function" && !!G;
        if (D || Y) A[I] = Z
      }
    }, "applyInstruction"),
    IH4 = t0((A) => A != null, "nonNullish"),
    GH4 = t0((A) => A, "pass");

  function uA0(A) {
    if (A.includes(",") || A.includes('"')) A = `"${A.replace(/"/g,"\\\"")}"`;
    return A
  }
  t0(uA0, "quoteHeader");
  var ZH4 = t0((A) => {
      if (A !== A) return "NaN";
      switch (A) {
        case 1 / 0:
          return "Infinity";
        case -1 / 0:
          return "-Infinity";
        default:
          return A
      }
    }, "serializeFloat"),
    DH4 = t0((A) => A.toISOString().replace(".000Z", "Z"), "serializeDateTime"),
    Sy1 = t0((A) => {
      if (A == null) return {};
      if (Array.isArray(A)) return A.filter((B) => B != null).map(Sy1);
      if (typeof A === "object") {
        let B = {};
        for (let Q of Object.keys(A)) {
          if (A[Q] == null) continue;
          B[Q] = Sy1(A[Q])
        }
        return B
      }
      return A
    }, "_json");

  function pA0(A, B, Q) {
    if (Q <= 0 || !Number.isInteger(Q)) throw new Error("Invalid number of delimiters (" + Q + ") for splitEvery.");
    let I = A.split(B);
    if (Q === 1) return I;
    let G = [],
      Z = "";
    for (let D = 0; D < I.length; D++) {
      if (Z === "") Z = I[D];
      else Z += B + I[D];
      if ((D + 1) % Q === 0) G.push(Z), Z = ""
    }
    if (Z !== "") G.push(Z);
    return G
  }
  t0(pA0, "splitEvery");
  var YH4 = t0((A) => {
    let B = A.length,
      Q = [],
      I = !1,
      G = void 0,
      Z = 0;
    for (let D = 0; D < B; ++D) {
      let Y = A[D];
      switch (Y) {
        case '"':
          if (G !== "\\") I = !I;
          break;
        case ",":
          if (!I) Q.push(A.slice(Z, D)), Z = D + 1;
          break;
        default:
      }
      G = Y
    }
    return Q.push(A.slice(Z)), Q.map((D) => {
      D = D.trim();
      let Y = D.length;
      if (Y < 2) return D;
      if (D[0] === '"' && D[Y - 1] === '"') D = D.slice(1, Y - 1);
      return D.replace(/\\"/g, '"')
    })
  }, "splitHeader")
})
// @from(Start 3525791, End 3527578)
aA0 = z((iA0) => {
  Object.defineProperty(iA0, "__esModule", {
    value: !0
  });
  iA0.getCredentials = iA0.createGetRequest = void 0;
  var fy1 = $I(),
    WH4 = OA0(),
    JH4 = lA0(),
    FH4 = f_1();

  function XH4(A) {
    return new WH4.HttpRequest({
      protocol: A.protocol,
      hostname: A.hostname,
      port: Number(A.port),
      path: A.pathname,
      query: Array.from(A.searchParams.entries()).reduce((B, [Q, I]) => {
        return B[Q] = I, B
      }, {}),
      fragment: A.hash
    })
  }
  iA0.createGetRequest = XH4;
  async function VH4(A, B) {
    let I = await FH4.sdkStreamMixin(A.body).transformToString();
    if (A.statusCode === 200) {
      let G = JSON.parse(I);
      if (typeof G.AccessKeyId !== "string" || typeof G.SecretAccessKey !== "string" || typeof G.Token !== "string" || typeof G.Expiration !== "string") throw new fy1.CredentialsProviderError("HTTP credential provider response not of the required format, an object matching: { AccessKeyId: string, SecretAccessKey: string, Token: string, Expiration: string(rfc3339) }", {
        logger: B
      });
      return {
        accessKeyId: G.AccessKeyId,
        secretAccessKey: G.SecretAccessKey,
        sessionToken: G.Token,
        expiration: JH4.parseRfc3339DateTime(G.Expiration)
      }
    }
    if (A.statusCode >= 400 && A.statusCode < 500) {
      let G = {};
      try {
        G = JSON.parse(I)
      } catch (Z) {}
      throw Object.assign(new fy1.CredentialsProviderError(`Server responded with status: ${A.statusCode}`, {
        logger: B
      }), {
        Code: G.Code,
        Message: G.Message
      })
    }
    throw new fy1.CredentialsProviderError(`Server responded with status: ${A.statusCode}`, {
      logger: B
    })
  }
  iA0.getCredentials = VH4
})
// @from(Start 3527584, End 3527954)
oA0 = z((sA0) => {
  Object.defineProperty(sA0, "__esModule", {
    value: !0
  });
  sA0.retryWrapper = void 0;
  var KH4 = (A, B, Q) => {
    return async () => {
      for (let I = 0; I < B; ++I) try {
        return await A()
      } catch (G) {
        await new Promise((Z) => setTimeout(Z, Q))
      }
      return await A()
    }
  };
  sA0.retryWrapper = KH4
})
// @from(Start 3527960, End 3530423)
Q00 = z((A00) => {
  Object.defineProperty(A00, "__esModule", {
    value: !0
  });
  A00.fromHttp = void 0;
  var HH4 = WA0(),
    zH4 = NC(),
    wH4 = DN(),
    tA0 = $I(),
    EH4 = HH4.__importDefault(Z1("fs/promises")),
    UH4 = XA0(),
    eA0 = aA0(),
    NH4 = oA0(),
    $H4 = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI",
    qH4 = "http://169.254.170.2",
    MH4 = "AWS_CONTAINER_CREDENTIALS_FULL_URI",
    LH4 = "AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE",
    RH4 = "AWS_CONTAINER_AUTHORIZATION_TOKEN",
    OH4 = (A = {}) => {
      A.logger?.debug("@aws-sdk/credential-provider-http - fromHttp");
      let B, Q = A.awsContainerCredentialsRelativeUri ?? process.env[$H4],
        I = A.awsContainerCredentialsFullUri ?? process.env[MH4],
        G = A.awsContainerAuthorizationToken ?? process.env[RH4],
        Z = A.awsContainerAuthorizationTokenFile ?? process.env[LH4],
        D = A.logger?.constructor?.name === "NoOpLogger" || !A.logger ? console.warn : A.logger.warn;
      if (Q && I) D("@aws-sdk/credential-provider-http: you have set both awsContainerCredentialsRelativeUri and awsContainerCredentialsFullUri."), D("awsContainerCredentialsFullUri will take precedence.");
      if (G && Z) D("@aws-sdk/credential-provider-http: you have set both awsContainerAuthorizationToken and awsContainerAuthorizationTokenFile."), D("awsContainerAuthorizationToken will take precedence.");
      if (I) B = I;
      else if (Q) B = `${qH4}${Q}`;
      else throw new tA0.CredentialsProviderError(`No HTTP credential provider host provided.
Set AWS_CONTAINER_CREDENTIALS_FULL_URI or AWS_CONTAINER_CREDENTIALS_RELATIVE_URI.`, {
        logger: A.logger
      });
      let Y = new URL(B);
      UH4.checkUrl(Y, A.logger);
      let W = new wH4.NodeHttpHandler({
        requestTimeout: A.timeout ?? 1000,
        connectionTimeout: A.timeout ?? 1000
      });
      return NH4.retryWrapper(async () => {
        let J = eA0.createGetRequest(Y);
        if (G) J.headers.Authorization = G;
        else if (Z) J.headers.Authorization = (await EH4.default.readFile(Z)).toString();
        try {
          let F = await W.handle(J);
          return eA0.getCredentials(F.response).then((X) => zH4.setCredentialFeature(X, "CREDENTIALS_HTTP", "z"))
        } catch (F) {
          throw new tA0.CredentialsProviderError(String(F), {
            logger: A.logger
          })
        }
      }, A.maxRetries ?? 3, A.timeout ?? 1000)
    };
  A00.fromHttp = OH4
})
// @from(Start 3530429, End 3530681)
AI1 = z((vy1) => {
  Object.defineProperty(vy1, "__esModule", {
    value: !0
  });
  vy1.fromHttp = void 0;
  var TH4 = Q00();
  Object.defineProperty(vy1, "fromHttp", {
    enumerable: !0,
    get: function() {
      return TH4.fromHttp
    }
  })
})
// @from(Start 3530687, End 3532359)
gy1 = z((I00) => {
  Object.defineProperty(I00, "__esModule", {
    value: !0
  });
  I00.resolveHttpAuthSchemeConfig = I00.defaultSSOHttpAuthSchemeProvider = I00.defaultSSOHttpAuthSchemeParametersProvider = void 0;
  var SH4 = IB(),
    by1 = ZX(),
    _H4 = async (A, B, Q) => {
      return {
        operation: by1.getSmithyContext(B).operation,
        region: await by1.normalizeProvider(A.region)() || (() => {
          throw new Error("expected `region` to be configured for `aws.auth#sigv4`")
        })()
      }
    };
  I00.defaultSSOHttpAuthSchemeParametersProvider = _H4;

  function jH4(A) {
    return {
      schemeId: "aws.auth#sigv4",
      signingProperties: {
        name: "awsssoportal",
        region: A.region
      },
      propertiesExtractor: (B, Q) => ({
        signingProperties: {
          config: B,
          context: Q
        }
      })
    }
  }

  function BI1(A) {
    return {
      schemeId: "smithy.api#noAuth"
    }
  }
  var yH4 = (A) => {
    let B = [];
    switch (A.operation) {
      case "GetRoleCredentials": {
        B.push(BI1(A));
        break
      }
      case "ListAccountRoles": {
        B.push(BI1(A));
        break
      }
      case "ListAccounts": {
        B.push(BI1(A));
        break
      }
      case "Logout": {
        B.push(BI1(A));
        break
      }
      default:
        B.push(jH4(A))
    }
    return B
  };
  I00.defaultSSOHttpAuthSchemeProvider = yH4;
  var kH4 = (A) => {
    let B = SH4.resolveAwsSdkSigV4Config(A);
    return Object.assign(B, {
      authSchemePreference: by1.normalizeProvider(A.authSchemePreference ?? [])
    })
  };
  I00.resolveHttpAuthSchemeConfig = kH4
})
// @from(Start 3532365, End 3549685)
k00 = z((tI8, GI1) => {
  var Z00, D00, Y00, W00, J00, F00, X00, V00, C00, K00, H00, z00, w00, QI1, hy1, E00, U00, N00, Sb, $00, q00, M00, L00, R00, O00, T00, P00, S00, II1, _00, j00, y00;
  (function(A) {
    var B = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
    if (typeof define === "function" && define.amd) define("tslib", ["exports"], function(I) {
      A(Q(B, Q(I)))
    });
    else if (typeof GI1 === "object" && typeof tI8 === "object") A(Q(B, Q(tI8)));
    else A(Q(B));

    function Q(I, G) {
      if (I !== B)
        if (typeof Object.create === "function") Object.defineProperty(I, "__esModule", {
          value: !0
        });
        else I.__esModule = !0;
      return function(Z, D) {
        return I[Z] = G ? G(Z, D) : D
      }
    }
  })(function(A) {
    var B = Object.setPrototypeOf || {
      __proto__: []
    }
    instanceof Array && function(Z, D) {
      Z.__proto__ = D
    } || function(Z, D) {
      for (var Y in D)
        if (Object.prototype.hasOwnProperty.call(D, Y)) Z[Y] = D[Y]
    };
    Z00 = function(Z, D) {
      if (typeof D !== "function" && D !== null) throw new TypeError("Class extends value " + String(D) + " is not a constructor or null");
      B(Z, D);

      function Y() {
        this.constructor = Z
      }
      Z.prototype = D === null ? Object.create(D) : (Y.prototype = D.prototype, new Y)
    }, D00 = Object.assign || function(Z) {
      for (var D, Y = 1, W = arguments.length; Y < W; Y++) {
        D = arguments[Y];
        for (var J in D)
          if (Object.prototype.hasOwnProperty.call(D, J)) Z[J] = D[J]
      }
      return Z
    }, Y00 = function(Z, D) {
      var Y = {};
      for (var W in Z)
        if (Object.prototype.hasOwnProperty.call(Z, W) && D.indexOf(W) < 0) Y[W] = Z[W];
      if (Z != null && typeof Object.getOwnPropertySymbols === "function") {
        for (var J = 0, W = Object.getOwnPropertySymbols(Z); J < W.length; J++)
          if (D.indexOf(W[J]) < 0 && Object.prototype.propertyIsEnumerable.call(Z, W[J])) Y[W[J]] = Z[W[J]]
      }
      return Y
    }, W00 = function(Z, D, Y, W) {
      var J = arguments.length,
        F = J < 3 ? D : W === null ? W = Object.getOwnPropertyDescriptor(D, Y) : W,
        X;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") F = Reflect.decorate(Z, D, Y, W);
      else
        for (var V = Z.length - 1; V >= 0; V--)
          if (X = Z[V]) F = (J < 3 ? X(F) : J > 3 ? X(D, Y, F) : X(D, Y)) || F;
      return J > 3 && F && Object.defineProperty(D, Y, F), F
    }, J00 = function(Z, D) {
      return function(Y, W) {
        D(Y, W, Z)
      }
    }, F00 = function(Z, D, Y, W, J, F) {
      function X(_) {
        if (_ !== void 0 && typeof _ !== "function") throw new TypeError("Function expected");
        return _
      }
      var V = W.kind,
        C = V === "getter" ? "get" : V === "setter" ? "set" : "value",
        K = !D && Z ? W.static ? Z : Z.prototype : null,
        E = D || (K ? Object.getOwnPropertyDescriptor(K, W.name) : {}),
        N, q = !1;
      for (var O = Y.length - 1; O >= 0; O--) {
        var R = {};
        for (var T in W) R[T] = T === "access" ? {} : W[T];
        for (var T in W.access) R.access[T] = W.access[T];
        R.addInitializer = function(_) {
          if (q) throw new TypeError("Cannot add initializers after decoration has completed");
          F.push(X(_ || null))
        };
        var L = Y[O](V === "accessor" ? {
          get: E.get,
          set: E.set
        } : E[C], R);
        if (V === "accessor") {
          if (L === void 0) continue;
          if (L === null || typeof L !== "object") throw new TypeError("Object expected");
          if (N = X(L.get)) E.get = N;
          if (N = X(L.set)) E.set = N;
          if (N = X(L.init)) J.unshift(N)
        } else if (N = X(L))
          if (V === "field") J.unshift(N);
          else E[C] = N
      }
      if (K) Object.defineProperty(K, W.name, E);
      q = !0
    }, X00 = function(Z, D, Y) {
      var W = arguments.length > 2;
      for (var J = 0; J < D.length; J++) Y = W ? D[J].call(Z, Y) : D[J].call(Z);
      return W ? Y : void 0
    }, V00 = function(Z) {
      return typeof Z === "symbol" ? Z : "".concat(Z)
    }, C00 = function(Z, D, Y) {
      if (typeof D === "symbol") D = D.description ? "[".concat(D.description, "]") : "";
      return Object.defineProperty(Z, "name", {
        configurable: !0,
        value: Y ? "".concat(Y, " ", D) : D
      })
    }, K00 = function(Z, D) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(Z, D)
    }, H00 = function(Z, D, Y, W) {
      function J(F) {
        return F instanceof Y ? F : new Y(function(X) {
          X(F)
        })
      }
      return new(Y || (Y = Promise))(function(F, X) {
        function V(E) {
          try {
            K(W.next(E))
          } catch (N) {
            X(N)
          }
        }

        function C(E) {
          try {
            K(W.throw(E))
          } catch (N) {
            X(N)
          }
        }

        function K(E) {
          E.done ? F(E.value) : J(E.value).then(V, C)
        }
        K((W = W.apply(Z, D || [])).next())
      })
    }, z00 = function(Z, D) {
      var Y = {
          label: 0,
          sent: function() {
            if (F[0] & 1) throw F[1];
            return F[1]
          },
          trys: [],
          ops: []
        },
        W, J, F, X = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
      return X.next = V(0), X.throw = V(1), X.return = V(2), typeof Symbol === "function" && (X[Symbol.iterator] = function() {
        return this
      }), X;

      function V(K) {
        return function(E) {
          return C([K, E])
        }
      }

      function C(K) {
        if (W) throw new TypeError("Generator is already executing.");
        while (X && (X = 0, K[0] && (Y = 0)), Y) try {
          if (W = 1, J && (F = K[0] & 2 ? J.return : K[0] ? J.throw || ((F = J.return) && F.call(J), 0) : J.next) && !(F = F.call(J, K[1])).done) return F;
          if (J = 0, F) K = [K[0] & 2, F.value];
          switch (K[0]) {
            case 0:
            case 1:
              F = K;
              break;
            case 4:
              return Y.label++, {
                value: K[1],
                done: !1
              };
            case 5:
              Y.label++, J = K[1], K = [0];
              continue;
            case 7:
              K = Y.ops.pop(), Y.trys.pop();
              continue;
            default:
              if ((F = Y.trys, !(F = F.length > 0 && F[F.length - 1])) && (K[0] === 6 || K[0] === 2)) {
                Y = 0;
                continue
              }
              if (K[0] === 3 && (!F || K[1] > F[0] && K[1] < F[3])) {
                Y.label = K[1];
                break
              }
              if (K[0] === 6 && Y.label < F[1]) {
                Y.label = F[1], F = K;
                break
              }
              if (F && Y.label < F[2]) {
                Y.label = F[2], Y.ops.push(K);
                break
              }
              if (F[2]) Y.ops.pop();
              Y.trys.pop();
              continue
          }
          K = D.call(Z, Y)
        } catch (E) {
          K = [6, E], J = 0
        } finally {
          W = F = 0
        }
        if (K[0] & 5) throw K[1];
        return {
          value: K[0] ? K[1] : void 0,
          done: !0
        }
      }
    }, w00 = function(Z, D) {
      for (var Y in Z)
        if (Y !== "default" && !Object.prototype.hasOwnProperty.call(D, Y)) II1(D, Z, Y)
    }, II1 = Object.create ? function(Z, D, Y, W) {
      if (W === void 0) W = Y;
      var J = Object.getOwnPropertyDescriptor(D, Y);
      if (!J || ("get" in J ? !D.__esModule : J.writable || J.configurable)) J = {
        enumerable: !0,
        get: function() {
          return D[Y]
        }
      };
      Object.defineProperty(Z, W, J)
    } : function(Z, D, Y, W) {
      if (W === void 0) W = Y;
      Z[W] = D[Y]
    }, QI1 = function(Z) {
      var D = typeof Symbol === "function" && Symbol.iterator,
        Y = D && Z[D],
        W = 0;
      if (Y) return Y.call(Z);
      if (Z && typeof Z.length === "number") return {
        next: function() {
          if (Z && W >= Z.length) Z = void 0;
          return {
            value: Z && Z[W++],
            done: !Z
          }
        }
      };
      throw new TypeError(D ? "Object is not iterable." : "Symbol.iterator is not defined.")
    }, hy1 = function(Z, D) {
      var Y = typeof Symbol === "function" && Z[Symbol.iterator];
      if (!Y) return Z;
      var W = Y.call(Z),
        J, F = [],
        X;
      try {
        while ((D === void 0 || D-- > 0) && !(J = W.next()).done) F.push(J.value)
      } catch (V) {
        X = {
          error: V
        }
      } finally {
        try {
          if (J && !J.done && (Y = W.return)) Y.call(W)
        } finally {
          if (X) throw X.error
        }
      }
      return F
    }, E00 = function() {
      for (var Z = [], D = 0; D < arguments.length; D++) Z = Z.concat(hy1(arguments[D]));
      return Z
    }, U00 = function() {
      for (var Z = 0, D = 0, Y = arguments.length; D < Y; D++) Z += arguments[D].length;
      for (var W = Array(Z), J = 0, D = 0; D < Y; D++)
        for (var F = arguments[D], X = 0, V = F.length; X < V; X++, J++) W[J] = F[X];
      return W
    }, N00 = function(Z, D, Y) {
      if (Y || arguments.length === 2) {
        for (var W = 0, J = D.length, F; W < J; W++)
          if (F || !(W in D)) {
            if (!F) F = Array.prototype.slice.call(D, 0, W);
            F[W] = D[W]
          }
      }
      return Z.concat(F || Array.prototype.slice.call(D))
    }, Sb = function(Z) {
      return this instanceof Sb ? (this.v = Z, this) : new Sb(Z)
    }, $00 = function(Z, D, Y) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var W = Y.apply(Z, D || []),
        J, F = [];
      return J = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), V("next"), V("throw"), V("return", X), J[Symbol.asyncIterator] = function() {
        return this
      }, J;

      function X(O) {
        return function(R) {
          return Promise.resolve(R).then(O, N)
        }
      }

      function V(O, R) {
        if (W[O]) {
          if (J[O] = function(T) {
              return new Promise(function(L, _) {
                F.push([O, T, L, _]) > 1 || C(O, T)
              })
            }, R) J[O] = R(J[O])
        }
      }

      function C(O, R) {
        try {
          K(W[O](R))
        } catch (T) {
          q(F[0][3], T)
        }
      }

      function K(O) {
        O.value instanceof Sb ? Promise.resolve(O.value.v).then(E, N) : q(F[0][2], O)
      }

      function E(O) {
        C("next", O)
      }

      function N(O) {
        C("throw", O)
      }

      function q(O, R) {
        if (O(R), F.shift(), F.length) C(F[0][0], F[0][1])
      }
    }, q00 = function(Z) {
      var D, Y;
      return D = {}, W("next"), W("throw", function(J) {
        throw J
      }), W("return"), D[Symbol.iterator] = function() {
        return this
      }, D;

      function W(J, F) {
        D[J] = Z[J] ? function(X) {
          return (Y = !Y) ? {
            value: Sb(Z[J](X)),
            done: !1
          } : F ? F(X) : X
        } : F
      }
    }, M00 = function(Z) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var D = Z[Symbol.asyncIterator],
        Y;
      return D ? D.call(Z) : (Z = typeof QI1 === "function" ? QI1(Z) : Z[Symbol.iterator](), Y = {}, W("next"), W("throw"), W("return"), Y[Symbol.asyncIterator] = function() {
        return this
      }, Y);

      function W(F) {
        Y[F] = Z[F] && function(X) {
          return new Promise(function(V, C) {
            X = Z[F](X), J(V, C, X.done, X.value)
          })
        }
      }

      function J(F, X, V, C) {
        Promise.resolve(C).then(function(K) {
          F({
            value: K,
            done: V
          })
        }, X)
      }
    }, L00 = function(Z, D) {
      if (Object.defineProperty) Object.defineProperty(Z, "raw", {
        value: D
      });
      else Z.raw = D;
      return Z
    };
    var Q = Object.create ? function(Z, D) {
        Object.defineProperty(Z, "default", {
          enumerable: !0,
          value: D
        })
      } : function(Z, D) {
        Z.default = D
      },
      I = function(Z) {
        return I = Object.getOwnPropertyNames || function(D) {
          var Y = [];
          for (var W in D)
            if (Object.prototype.hasOwnProperty.call(D, W)) Y[Y.length] = W;
          return Y
        }, I(Z)
      };
    R00 = function(Z) {
      if (Z && Z.__esModule) return Z;
      var D = {};
      if (Z != null) {
        for (var Y = I(Z), W = 0; W < Y.length; W++)
          if (Y[W] !== "default") II1(D, Z, Y[W])
      }
      return Q(D, Z), D
    }, O00 = function(Z) {
      return Z && Z.__esModule ? Z : {
        default: Z
      }
    }, T00 = function(Z, D, Y, W) {
      if (Y === "a" && !W) throw new TypeError("Private accessor was defined without a getter");
      if (typeof D === "function" ? Z !== D || !W : !D.has(Z)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
      return Y === "m" ? W : Y === "a" ? W.call(Z) : W ? W.value : D.get(Z)
    }, P00 = function(Z, D, Y, W, J) {
      if (W === "m") throw new TypeError("Private method is not writable");
      if (W === "a" && !J) throw new TypeError("Private accessor was defined without a setter");
      if (typeof D === "function" ? Z !== D || !J : !D.has(Z)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
      return W === "a" ? J.call(Z, Y) : J ? J.value = Y : D.set(Z, Y), Y
    }, S00 = function(Z, D) {
      if (D === null || typeof D !== "object" && typeof D !== "function") throw new TypeError("Cannot use 'in' operator on non-object");
      return typeof Z === "function" ? D === Z : Z.has(D)
    }, _00 = function(Z, D, Y) {
      if (D !== null && D !== void 0) {
        if (typeof D !== "object" && typeof D !== "function") throw new TypeError("Object expected.");
        var W, J;
        if (Y) {
          if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
          W = D[Symbol.asyncDispose]
        }
        if (W === void 0) {
          if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
          if (W = D[Symbol.dispose], Y) J = W
        }
        if (typeof W !== "function") throw new TypeError("Object not disposable.");
        if (J) W = function() {
          try {
            J.call(this)
          } catch (F) {
            return Promise.reject(F)
          }
        };
        Z.stack.push({
          value: D,
          dispose: W,
          async: Y
        })
      } else if (Y) Z.stack.push({
        async: !0
      });
      return D
    };
    var G = typeof SuppressedError === "function" ? SuppressedError : function(Z, D, Y) {
      var W = new Error(Y);
      return W.name = "SuppressedError", W.error = Z, W.suppressed = D, W
    };
    j00 = function(Z) {
      function D(F) {
        Z.error = Z.hasError ? new G(F, Z.error, "An error was suppressed during disposal.") : F, Z.hasError = !0
      }
      var Y, W = 0;

      function J() {
        while (Y = Z.stack.pop()) try {
          if (!Y.async && W === 1) return W = 0, Z.stack.push(Y), Promise.resolve().then(J);
          if (Y.dispose) {
            var F = Y.dispose.call(Y.value);
            if (Y.async) return W |= 2, Promise.resolve(F).then(J, function(X) {
              return D(X), J()
            })
          } else W |= 1
        } catch (X) {
          D(X)
        }
        if (W === 1) return Z.hasError ? Promise.reject(Z.error) : Promise.resolve();
        if (Z.hasError) throw Z.error
      }
      return J()
    }, y00 = function(Z, D) {
      if (typeof Z === "string" && /^\.\.?\//.test(Z)) return Z.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(Y, W, J, F, X) {
        return W ? D ? ".jsx" : ".js" : J && (!F || !X) ? Y : J + F + "." + X.toLowerCase() + "js"
      });
      return Z
    }, A("__extends", Z00), A("__assign", D00), A("__rest", Y00), A("__decorate", W00), A("__param", J00), A("__esDecorate", F00), A("__runInitializers", X00), A("__propKey", V00), A("__setFunctionName", C00), A("__metadata", K00), A("__awaiter", H00), A("__generator", z00), A("__exportStar", w00), A("__createBinding", II1), A("__values", QI1), A("__read", hy1), A("__spread", E00), A("__spreadArrays", U00), A("__spreadArray", N00), A("__await", Sb), A("__asyncGenerator", $00), A("__asyncDelegator", q00), A("__asyncValues", M00), A("__makeTemplateObject", L00), A("__importStar", R00), A("__importDefault", O00), A("__classPrivateFieldGet", T00), A("__classPrivateFieldSet", P00), A("__classPrivateFieldIn", S00), A("__addDisposableResource", _00), A("__disposeResources", j00), A("__rewriteRelativeImportExtension", y00)
  })
})
// @from(Start 3549691, End 3553275)
x00 = z((eI8, vH4) => {
  vH4.exports = {
    name: "@aws-sdk/client-sso",
    description: "AWS SDK for JavaScript Sso Client for Node.js, Browser and React Native",
    version: "3.797.0",
    scripts: {
      build: "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
      "build:cjs": "node ../../scripts/compilation/inline client-sso",
      "build:es": "tsc -p tsconfig.es.json",
      "build:include:deps": "lerna run --scope $npm_package_name --include-dependencies build",
      "build:types": "tsc -p tsconfig.types.json",
      "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
      clean: "rimraf ./dist-* && rimraf *.tsbuildinfo",
      "extract:docs": "api-extractor run --local",
      "generate:client": "node ../../scripts/generate-clients/single-service --solo sso"
    },
    main: "./dist-cjs/index.js",
    types: "./dist-types/index.d.ts",
    module: "./dist-es/index.js",
    sideEffects: !1,
    dependencies: {
      "@aws-crypto/sha256-browser": "5.2.0",
      "@aws-crypto/sha256-js": "5.2.0",
      "@aws-sdk/core": "3.796.0",
      "@aws-sdk/middleware-host-header": "3.775.0",
      "@aws-sdk/middleware-logger": "3.775.0",
      "@aws-sdk/middleware-recursion-detection": "3.775.0",
      "@aws-sdk/middleware-user-agent": "3.796.0",
      "@aws-sdk/region-config-resolver": "3.775.0",
      "@aws-sdk/types": "3.775.0",
      "@aws-sdk/util-endpoints": "3.787.0",
      "@aws-sdk/util-user-agent-browser": "3.775.0",
      "@aws-sdk/util-user-agent-node": "3.796.0",
      "@smithy/config-resolver": "^4.1.0",
      "@smithy/core": "^3.2.0",
      "@smithy/fetch-http-handler": "^5.0.2",
      "@smithy/hash-node": "^4.0.2",
      "@smithy/invalid-dependency": "^4.0.2",
      "@smithy/middleware-content-length": "^4.0.2",
      "@smithy/middleware-endpoint": "^4.1.0",
      "@smithy/middleware-retry": "^4.1.0",
      "@smithy/middleware-serde": "^4.0.3",
      "@smithy/middleware-stack": "^4.0.2",
      "@smithy/node-config-provider": "^4.0.2",
      "@smithy/node-http-handler": "^4.0.4",
      "@smithy/protocol-http": "^5.1.0",
      "@smithy/smithy-client": "^4.2.0",
      "@smithy/types": "^4.2.0",
      "@smithy/url-parser": "^4.0.2",
      "@smithy/util-base64": "^4.0.0",
      "@smithy/util-body-length-browser": "^4.0.0",
      "@smithy/util-body-length-node": "^4.0.0",
      "@smithy/util-defaults-mode-browser": "^4.0.8",
      "@smithy/util-defaults-mode-node": "^4.0.8",
      "@smithy/util-endpoints": "^3.0.2",
      "@smithy/util-middleware": "^4.0.2",
      "@smithy/util-retry": "^4.0.2",
      "@smithy/util-utf8": "^4.0.0",
      tslib: "^2.6.2"
    },
    devDependencies: {
      "@tsconfig/node18": "18.2.4",
      "@types/node": "^18.19.69",
      concurrently: "7.0.0",
      "downlevel-dts": "0.10.1",
      rimraf: "3.0.2",
      typescript: "~5.2.2"
    },
    engines: {
      node: ">=18.0.0"
    },
    typesVersions: {
      "<4.0": {
        "dist-types/*": ["dist-types/ts3.4/*"]
      }
    },
    files: ["dist-*/**"],
    author: {
      name: "AWS SDK for JavaScript Team",
      url: "https://aws.amazon.com/javascript/"
    },
    license: "Apache-2.0",
    browser: {
      "./dist-es/runtimeConfig": "./dist-es/runtimeConfig.browser"
    },
    "react-native": {
      "./dist-es/runtimeConfig": "./dist-es/runtimeConfig.native"
    },
    homepage: "https://github.com/aws/aws-sdk-js-v3/tree/main/clients/client-sso",
    repository: {
      type: "git",
      url: "https://github.com/aws/aws-sdk-js-v3.git",
      directory: "clients/client-sso"
    }
  }
})
// @from(Start 3553281, End 3555446)
I_ = z((AG8, d00) => {
  var {
    defineProperty: DI1,
    getOwnPropertyDescriptor: bH4,
    getOwnPropertyNames: gH4
  } = Object, hH4 = Object.prototype.hasOwnProperty, ZI1 = (A, B) => DI1(A, "name", {
    value: B,
    configurable: !0
  }), mH4 = (A, B) => {
    for (var Q in B) DI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, dH4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of gH4(B))
        if (!hH4.call(A, G) && G !== Q) DI1(A, G, {
          get: () => B[G],
          enumerable: !(I = bH4(B, G)) || I.enumerable
        })
    }
    return A
  }, uH4 = (A) => dH4(DI1({}, "__esModule", {
    value: !0
  }), A), v00 = {};
  mH4(v00, {
    NODE_APP_ID_CONFIG_OPTIONS: () => nH4,
    UA_APP_ID_ENV_NAME: () => h00,
    UA_APP_ID_INI_NAME: () => m00,
    createDefaultUserAgentProvider: () => g00,
    crtAvailability: () => b00,
    defaultUserAgent: () => cH4
  });
  d00.exports = uH4(v00);
  var f00 = Z1("os"),
    my1 = Z1("process"),
    b00 = {
      isCrtAvailable: !1
    },
    pH4 = ZI1(() => {
      if (b00.isCrtAvailable) return ["md/crt-avail"];
      return null
    }, "isCrtAvailable"),
    g00 = ZI1(({
      serviceId: A,
      clientVersion: B
    }) => {
      return async (Q) => {
        let I = [
            ["aws-sdk-js", B],
            ["ua", "2.1"],
            [`os/${f00.platform()}`, f00.release()],
            ["lang/js"],
            ["md/nodejs", `${my1.versions.node}`]
          ],
          G = pH4();
        if (G) I.push(G);
        if (A) I.push([`api/${A}`, B]);
        if (my1.env.AWS_EXECUTION_ENV) I.push([`exec-env/${my1.env.AWS_EXECUTION_ENV}`]);
        let Z = await Q?.userAgentAppId?.();
        return Z ? [...I, [`app/${Z}`]] : [...I]
      }
    }, "createDefaultUserAgentProvider"),
    cH4 = g00,
    lH4 = jL(),
    h00 = "AWS_SDK_UA_APP_ID",
    m00 = "sdk_ua_app_id",
    iH4 = "sdk-ua-app-id",
    nH4 = {
      environmentVariableSelector: ZI1((A) => A[h00], "environmentVariableSelector"),
      configFileSelector: ZI1((A) => A[m00] ?? A[iH4], "configFileSelector"),
      default: lH4.DEFAULT_UA_APP_ID
    }
})
// @from(Start 3555452, End 3557095)
G_ = z((BG8, l00) => {
  var {
    defineProperty: YI1,
    getOwnPropertyDescriptor: aH4,
    getOwnPropertyNames: sH4
  } = Object, rH4 = Object.prototype.hasOwnProperty, p00 = (A, B) => YI1(A, "name", {
    value: B,
    configurable: !0
  }), oH4 = (A, B) => {
    for (var Q in B) YI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, tH4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of sH4(B))
        if (!rH4.call(A, G) && G !== Q) YI1(A, G, {
          get: () => B[G],
          enumerable: !(I = aH4(B, G)) || I.enumerable
        })
    }
    return A
  }, eH4 = (A) => tH4(YI1({}, "__esModule", {
    value: !0
  }), A), c00 = {};
  oH4(c00, {
    Hash: () => Qz4
  });
  l00.exports = eH4(c00);
  var dy1 = MZ(),
    Az4 = RQ(),
    Bz4 = Z1("buffer"),
    u00 = Z1("crypto"),
    Qz4 = class {
      static {
        p00(this, "Hash")
      }
      constructor(A, B) {
        this.algorithmIdentifier = A, this.secret = B, this.reset()
      }
      update(A, B) {
        this.hash.update(Az4.toUint8Array(uy1(A, B)))
      }
      digest() {
        return Promise.resolve(this.hash.digest())
      }
      reset() {
        this.hash = this.secret ? u00.createHmac(this.algorithmIdentifier, uy1(this.secret)) : u00.createHash(this.algorithmIdentifier)
      }
    };

  function uy1(A, B) {
    if (Bz4.Buffer.isBuffer(A)) return A;
    if (typeof A === "string") return dy1.fromString(A, B);
    if (ArrayBuffer.isView(A)) return dy1.fromArrayBuffer(A.buffer, A.byteOffset, A.byteLength);
    return dy1.fromArrayBuffer(A)
  }
  p00(uy1, "castSourceData")
})
// @from(Start 3557101, End 3558526)
Z_ = z((IG8, a00) => {
  var {
    defineProperty: WI1,
    getOwnPropertyDescriptor: Iz4,
    getOwnPropertyNames: Gz4
  } = Object, Zz4 = Object.prototype.hasOwnProperty, Dz4 = (A, B) => WI1(A, "name", {
    value: B,
    configurable: !0
  }), Yz4 = (A, B) => {
    for (var Q in B) WI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, Wz4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of Gz4(B))
        if (!Zz4.call(A, G) && G !== Q) WI1(A, G, {
          get: () => B[G],
          enumerable: !(I = Iz4(B, G)) || I.enumerable
        })
    }
    return A
  }, Jz4 = (A) => Wz4(WI1({}, "__esModule", {
    value: !0
  }), A), n00 = {};
  Yz4(n00, {
    calculateBodyLength: () => Fz4
  });
  a00.exports = Jz4(n00);
  var i00 = Z1("fs"),
    Fz4 = Dz4((A) => {
      if (!A) return 0;
      if (typeof A === "string") return Buffer.byteLength(A);
      else if (typeof A.byteLength === "number") return A.byteLength;
      else if (typeof A.size === "number") return A.size;
      else if (typeof A.start === "number" && typeof A.end === "number") return A.end + 1 - A.start;
      else if (typeof A.path === "string" || Buffer.isBuffer(A.path)) return i00.lstatSync(A.path).size;
      else if (typeof A.fd === "number") return i00.fstatSync(A.fd).size;
      throw new Error(`Body Length computation failed for ${A}`)
    }, "calculateBodyLength")
})
// @from(Start 3558532, End 3561315)
py1 = z((GG8, I20) => {
  var {
    defineProperty: JI1,
    getOwnPropertyDescriptor: Xz4,
    getOwnPropertyNames: Vz4
  } = Object, Cz4 = Object.prototype.hasOwnProperty, FI1 = (A, B) => JI1(A, "name", {
    value: B,
    configurable: !0
  }), Kz4 = (A, B) => {
    for (var Q in B) JI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, Hz4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of Vz4(B))
        if (!Cz4.call(A, G) && G !== Q) JI1(A, G, {
          get: () => B[G],
          enumerable: !(I = Xz4(B, G)) || I.enumerable
        })
    }
    return A
  }, zz4 = (A) => Hz4(JI1({}, "__esModule", {
    value: !0
  }), A), s00 = {};
  Kz4(s00, {
    AlgorithmId: () => e00,
    EndpointURLScheme: () => t00,
    FieldPosition: () => A20,
    HttpApiKeyAuthLocation: () => o00,
    HttpAuthLocation: () => r00,
    IniSectionType: () => B20,
    RequestHandlerProtocol: () => Q20,
    SMITHY_CONTEXT_KEY: () => $z4,
    getDefaultClientConfiguration: () => Uz4,
    resolveDefaultRuntimeConfig: () => Nz4
  });
  I20.exports = zz4(s00);
  var r00 = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(r00 || {}),
    o00 = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(o00 || {}),
    t00 = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(t00 || {}),
    e00 = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(e00 || {}),
    wz4 = FI1((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    Ez4 = FI1((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    Uz4 = FI1((A) => {
      return wz4(A)
    }, "getDefaultClientConfiguration"),
    Nz4 = FI1((A) => {
      return Ez4(A)
    }, "resolveDefaultRuntimeConfig"),
    A20 = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(A20 || {}),
    $z4 = "__smithy_context",
    B20 = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(B20 || {}),
    Q20 = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(Q20 || {})
})
// @from(Start 3561321, End 3589858)
Na = z((ZG8, $20) => {
  var {
    defineProperty: CI1,
    getOwnPropertyDescriptor: qz4,
    getOwnPropertyNames: Mz4
  } = Object, Lz4 = Object.prototype.hasOwnProperty, e0 = (A, B) => CI1(A, "name", {
    value: B,
    configurable: !0
  }), Rz4 = (A, B) => {
    for (var Q in B) CI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, Oz4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of Mz4(B))
        if (!Lz4.call(A, G) && G !== Q) CI1(A, G, {
          get: () => B[G],
          enumerable: !(I = qz4(B, G)) || I.enumerable
        })
    }
    return A
  }, Tz4 = (A) => Oz4(CI1({}, "__esModule", {
    value: !0
  }), A), Z20 = {};
  Rz4(Z20, {
    Client: () => Pz4,
    Command: () => Y20,
    LazyJsonString: () => D_,
    NoOpLogger: () => Lw4,
    SENSITIVE_STRING: () => _z4,
    ServiceException: () => Xw4,
    _json: () => ry1,
    collectBody: () => cy1.collectBody,
    convertMap: () => Rw4,
    createAggregatedClient: () => jz4,
    dateToUtcString: () => C20,
    decorateServiceException: () => K20,
    emitWarningIfUnsupportedVersion: () => Hw4,
    expectBoolean: () => kz4,
    expectByte: () => sy1,
    expectFloat32: () => XI1,
    expectInt: () => fz4,
    expectInt32: () => ny1,
    expectLong: () => Ea,
    expectNonNull: () => bz4,
    expectNumber: () => wa,
    expectObject: () => W20,
    expectShort: () => ay1,
    expectString: () => gz4,
    expectUnion: () => hz4,
    extendedEncodeURIComponent: () => cy1.extendedEncodeURIComponent,
    getArrayIfSingleItem: () => qw4,
    getDefaultClientConfiguration: () => Nw4,
    getDefaultExtensionConfiguration: () => z20,
    getValueFromTextNode: () => w20,
    handleFloat: () => uz4,
    isSerializableHeaderValue: () => Mw4,
    limitedParseDouble: () => ey1,
    limitedParseFloat: () => pz4,
    limitedParseFloat32: () => cz4,
    loadConfigsForDefaultMode: () => Kw4,
    logger: () => Ua,
    map: () => Bk1,
    parseBoolean: () => yz4,
    parseEpochTimestamp: () => Qw4,
    parseRfc3339DateTime: () => sz4,
    parseRfc3339DateTimeWithOffset: () => oz4,
    parseRfc7231DateTime: () => Bw4,
    quoteHeader: () => U20,
    resolveDefaultRuntimeConfig: () => $w4,
    resolvedPath: () => cy1.resolvedPath,
    serializeDateTime: () => jw4,
    serializeFloat: () => _w4,
    splitEvery: () => N20,
    splitHeader: () => yw4,
    strictParseByte: () => V20,
    strictParseDouble: () => ty1,
    strictParseFloat: () => mz4,
    strictParseFloat32: () => J20,
    strictParseInt: () => lz4,
    strictParseInt32: () => iz4,
    strictParseLong: () => X20,
    strictParseShort: () => _b,
    take: () => Ow4,
    throwDefaultError: () => H20,
    withBaseException: () => Vw4
  });
  $20.exports = Tz4(Z20);
  var D20 = WN(),
    Pz4 = class {
      constructor(A) {
        this.config = A, this.middlewareStack = D20.constructStack()
      }
      static {
        e0(this, "Client")
      }
      send(A, B, Q) {
        let I = typeof B !== "function" ? B : void 0,
          G = typeof B === "function" ? B : Q,
          Z = I === void 0 && this.config.cacheMiddleware === !0,
          D;
        if (Z) {
          if (!this.handlers) this.handlers = new WeakMap;
          let Y = this.handlers;
          if (Y.has(A.constructor)) D = Y.get(A.constructor);
          else D = A.resolveMiddleware(this.middlewareStack, this.config, I), Y.set(A.constructor, D)
        } else delete this.handlers, D = A.resolveMiddleware(this.middlewareStack, this.config, I);
        if (G) D(A).then((Y) => G(null, Y.output), (Y) => G(Y)).catch(() => {});
        else return D(A).then((Y) => Y.output)
      }
      destroy() {
        this.config?.requestHandler?.destroy?.(), delete this.handlers
      }
    },
    cy1 = vz(),
    iy1 = py1(),
    Y20 = class {
      constructor() {
        this.middlewareStack = D20.constructStack()
      }
      static {
        e0(this, "Command")
      }
      static classBuilder() {
        return new Sz4
      }
      resolveMiddlewareWithContext(A, B, Q, {
        middlewareFn: I,
        clientName: G,
        commandName: Z,
        inputFilterSensitiveLog: D,
        outputFilterSensitiveLog: Y,
        smithyContext: W,
        additionalContext: J,
        CommandCtor: F
      }) {
        for (let E of I.bind(this)(F, A, B, Q)) this.middlewareStack.use(E);
        let X = A.concat(this.middlewareStack),
          {
            logger: V
          } = B,
          C = {
            logger: V,
            clientName: G,
            commandName: Z,
            inputFilterSensitiveLog: D,
            outputFilterSensitiveLog: Y,
            [iy1.SMITHY_CONTEXT_KEY]: {
              commandInstance: this,
              ...W
            },
            ...J
          },
          {
            requestHandler: K
          } = B;
        return X.resolve((E) => K.handle(E.request, Q || {}), C)
      }
    },
    Sz4 = class {
      constructor() {
        this._init = () => {}, this._ep = {}, this._middlewareFn = () => [], this._commandName = "", this._clientName = "", this._additionalContext = {}, this._smithyContext = {}, this._inputFilterSensitiveLog = (A) => A, this._outputFilterSensitiveLog = (A) => A, this._serializer = null, this._deserializer = null
      }
      static {
        e0(this, "ClassBuilder")
      }
      init(A) {
        this._init = A
      }
      ep(A) {
        return this._ep = A, this
      }
      m(A) {
        return this._middlewareFn = A, this
      }
      s(A, B, Q = {}) {
        return this._smithyContext = {
          service: A,
          operation: B,
          ...Q
        }, this
      }
      c(A = {}) {
        return this._additionalContext = A, this
      }
      n(A, B) {
        return this._clientName = A, this._commandName = B, this
      }
      f(A = (Q) => Q, B = (Q) => Q) {
        return this._inputFilterSensitiveLog = A, this._outputFilterSensitiveLog = B, this
      }
      ser(A) {
        return this._serializer = A, this
      }
      de(A) {
        return this._deserializer = A, this
      }
      build() {
        let A = this,
          B;
        return B = class extends Y20 {
          constructor(...[Q]) {
            super();
            this.serialize = A._serializer, this.deserialize = A._deserializer, this.input = Q ?? {}, A._init(this)
          }
          static {
            e0(this, "CommandRef")
          }
          static getEndpointParameterInstructions() {
            return A._ep
          }
          resolveMiddleware(Q, I, G) {
            return this.resolveMiddlewareWithContext(Q, I, G, {
              CommandCtor: B,
              middlewareFn: A._middlewareFn,
              clientName: A._clientName,
              commandName: A._commandName,
              inputFilterSensitiveLog: A._inputFilterSensitiveLog,
              outputFilterSensitiveLog: A._outputFilterSensitiveLog,
              smithyContext: A._smithyContext,
              additionalContext: A._additionalContext
            })
          }
        }
      }
    },
    _z4 = "***SensitiveInformation***",
    jz4 = e0((A, B) => {
      for (let Q of Object.keys(A)) {
        let I = A[Q],
          G = e0(async function(D, Y, W) {
            let J = new I(D);
            if (typeof Y === "function") this.send(J, Y);
            else if (typeof W === "function") {
              if (typeof Y !== "object") throw new Error(`Expected http options but got ${typeof Y}`);
              this.send(J, Y || {}, W)
            } else return this.send(J, Y)
          }, "methodImpl"),
          Z = (Q[0].toLowerCase() + Q.slice(1)).replace(/Command$/, "");
        B.prototype[Z] = G
      }
    }, "createAggregatedClient"),
    yz4 = e0((A) => {
      switch (A) {
        case "true":
          return !0;
        case "false":
          return !1;
        default:
          throw new Error(`Unable to parse boolean value "${A}"`)
      }
    }, "parseBoolean"),
    kz4 = e0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "number") {
        if (A === 0 || A === 1) Ua.warn(VI1(`Expected boolean, got ${typeof A}: ${A}`));
        if (A === 0) return !1;
        if (A === 1) return !0
      }
      if (typeof A === "string") {
        let B = A.toLowerCase();
        if (B === "false" || B === "true") Ua.warn(VI1(`Expected boolean, got ${typeof A}: ${A}`));
        if (B === "false") return !1;
        if (B === "true") return !0
      }
      if (typeof A === "boolean") return A;
      throw new TypeError(`Expected boolean, got ${typeof A}: ${A}`)
    }, "expectBoolean"),
    wa = e0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "string") {
        let B = parseFloat(A);
        if (!Number.isNaN(B)) {
          if (String(B) !== String(A)) Ua.warn(VI1(`Expected number but observed string: ${A}`));
          return B
        }
      }
      if (typeof A === "number") return A;
      throw new TypeError(`Expected number, got ${typeof A}: ${A}`)
    }, "expectNumber"),
    xz4 = Math.ceil(340282346638528860000000000000000000000),
    XI1 = e0((A) => {
      let B = wa(A);
      if (B !== void 0 && !Number.isNaN(B) && B !== 1 / 0 && B !== -1 / 0) {
        if (Math.abs(B) > xz4) throw new TypeError(`Expected 32-bit float, got ${A}`)
      }
      return B
    }, "expectFloat32"),
    Ea = e0((A) => {
      if (A === null || A === void 0) return;
      if (Number.isInteger(A) && !Number.isNaN(A)) return A;
      throw new TypeError(`Expected integer, got ${typeof A}: ${A}`)
    }, "expectLong"),
    fz4 = Ea,
    ny1 = e0((A) => oy1(A, 32), "expectInt32"),
    ay1 = e0((A) => oy1(A, 16), "expectShort"),
    sy1 = e0((A) => oy1(A, 8), "expectByte"),
    oy1 = e0((A, B) => {
      let Q = Ea(A);
      if (Q !== void 0 && vz4(Q, B) !== Q) throw new TypeError(`Expected ${B}-bit integer, got ${A}`);
      return Q
    }, "expectSizedInt"),
    vz4 = e0((A, B) => {
      switch (B) {
        case 32:
          return Int32Array.of(A)[0];
        case 16:
          return Int16Array.of(A)[0];
        case 8:
          return Int8Array.of(A)[0]
      }
    }, "castInt"),
    bz4 = e0((A, B) => {
      if (A === null || A === void 0) {
        if (B) throw new TypeError(`Expected a non-null value for ${B}`);
        throw new TypeError("Expected a non-null value")
      }
      return A
    }, "expectNonNull"),
    W20 = e0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "object" && !Array.isArray(A)) return A;
      let B = Array.isArray(A) ? "array" : typeof A;
      throw new TypeError(`Expected object, got ${B}: ${A}`)
    }, "expectObject"),
    gz4 = e0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "string") return A;
      if (["boolean", "number", "bigint"].includes(typeof A)) return Ua.warn(VI1(`Expected string, got ${typeof A}: ${A}`)), String(A);
      throw new TypeError(`Expected string, got ${typeof A}: ${A}`)
    }, "expectString"),
    hz4 = e0((A) => {
      if (A === null || A === void 0) return;
      let B = W20(A),
        Q = Object.entries(B).filter(([, I]) => I != null).map(([I]) => I);
      if (Q.length === 0) throw new TypeError("Unions must have exactly one non-null member. None were found.");
      if (Q.length > 1) throw new TypeError(`Unions must have exactly one non-null member. Keys ${Q} were not null.`);
      return B
    }, "expectUnion"),
    ty1 = e0((A) => {
      if (typeof A == "string") return wa(yb(A));
      return wa(A)
    }, "strictParseDouble"),
    mz4 = ty1,
    J20 = e0((A) => {
      if (typeof A == "string") return XI1(yb(A));
      return XI1(A)
    }, "strictParseFloat32"),
    dz4 = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g,
    yb = e0((A) => {
      let B = A.match(dz4);
      if (B === null || B[0].length !== A.length) throw new TypeError("Expected real number, got implicit NaN");
      return parseFloat(A)
    }, "parseNumber"),
    ey1 = e0((A) => {
      if (typeof A == "string") return F20(A);
      return wa(A)
    }, "limitedParseDouble"),
    uz4 = ey1,
    pz4 = ey1,
    cz4 = e0((A) => {
      if (typeof A == "string") return F20(A);
      return XI1(A)
    }, "limitedParseFloat32"),
    F20 = e0((A) => {
      switch (A) {
        case "NaN":
          return NaN;
        case "Infinity":
          return 1 / 0;
        case "-Infinity":
          return -1 / 0;
        default:
          throw new Error(`Unable to parse float value: ${A}`)
      }
    }, "parseFloatString"),
    X20 = e0((A) => {
      if (typeof A === "string") return Ea(yb(A));
      return Ea(A)
    }, "strictParseLong"),
    lz4 = X20,
    iz4 = e0((A) => {
      if (typeof A === "string") return ny1(yb(A));
      return ny1(A)
    }, "strictParseInt32"),
    _b = e0((A) => {
      if (typeof A === "string") return ay1(yb(A));
      return ay1(A)
    }, "strictParseShort"),
    V20 = e0((A) => {
      if (typeof A === "string") return sy1(yb(A));
      return sy1(A)
    }, "strictParseByte"),
    VI1 = e0((A) => {
      return String(new TypeError(A).stack || A).split(`
`).slice(0, 5).filter((B) => !B.includes("stackTraceWarning")).join(`
`)
    }, "stackTraceWarning"),
    Ua = {
      warn: console.warn
    },
    nz4 = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
    Ak1 = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];

  function C20(A) {
    let B = A.getUTCFullYear(),
      Q = A.getUTCMonth(),
      I = A.getUTCDay(),
      G = A.getUTCDate(),
      Z = A.getUTCHours(),
      D = A.getUTCMinutes(),
      Y = A.getUTCSeconds(),
      W = G < 10 ? `0${G}` : `${G}`,
      J = Z < 10 ? `0${Z}` : `${Z}`,
      F = D < 10 ? `0${D}` : `${D}`,
      X = Y < 10 ? `0${Y}` : `${Y}`;
    return `${nz4[I]}, ${W} ${Ak1[Q]} ${B} ${J}:${F}:${X} GMT`
  }
  e0(C20, "dateToUtcString");
  var az4 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/),
    sz4 = e0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-3339 date-times must be expressed as strings");
      let B = az4.exec(A);
      if (!B) throw new TypeError("Invalid RFC-3339 date-time value");
      let [Q, I, G, Z, D, Y, W, J] = B, F = _b(jb(I)), X = pz(G, "month", 1, 12), V = pz(Z, "day", 1, 31);
      return za(F, X, V, {
        hours: D,
        minutes: Y,
        seconds: W,
        fractionalMilliseconds: J
      })
    }, "parseRfc3339DateTime"),
    rz4 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/),
    oz4 = e0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-3339 date-times must be expressed as strings");
      let B = rz4.exec(A);
      if (!B) throw new TypeError("Invalid RFC-3339 date-time value");
      let [Q, I, G, Z, D, Y, W, J, F] = B, X = _b(jb(I)), V = pz(G, "month", 1, 12), C = pz(Z, "day", 1, 31), K = za(X, V, C, {
        hours: D,
        minutes: Y,
        seconds: W,
        fractionalMilliseconds: J
      });
      if (F.toUpperCase() != "Z") K.setTime(K.getTime() - Fw4(F));
      return K
    }, "parseRfc3339DateTimeWithOffset"),
    tz4 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/),
    ez4 = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/),
    Aw4 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/),
    Bw4 = e0((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-7231 date-times must be expressed as strings");
      let B = tz4.exec(A);
      if (B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return za(_b(jb(Z)), ly1(G), pz(I, "day", 1, 31), {
          hours: D,
          minutes: Y,
          seconds: W,
          fractionalMilliseconds: J
        })
      }
      if (B = ez4.exec(A), B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return Zw4(za(Iw4(Z), ly1(G), pz(I, "day", 1, 31), {
          hours: D,
          minutes: Y,
          seconds: W,
          fractionalMilliseconds: J
        }))
      }
      if (B = Aw4.exec(A), B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return za(_b(jb(J)), ly1(I), pz(G.trimLeft(), "day", 1, 31), {
          hours: Z,
          minutes: D,
          seconds: Y,
          fractionalMilliseconds: W
        })
      }
      throw new TypeError("Invalid RFC-7231 date-time value")
    }, "parseRfc7231DateTime"),
    Qw4 = e0((A) => {
      if (A === null || A === void 0) return;
      let B;
      if (typeof A === "number") B = A;
      else if (typeof A === "string") B = ty1(A);
      else if (typeof A === "object" && A.tag === 1) B = A.value;
      else throw new TypeError("Epoch timestamps must be expressed as floating point numbers or their string representation");
      if (Number.isNaN(B) || B === 1 / 0 || B === -1 / 0) throw new TypeError("Epoch timestamps must be valid, non-Infinite, non-NaN numerics");
      return new Date(Math.round(B * 1000))
    }, "parseEpochTimestamp"),
    za = e0((A, B, Q, I) => {
      let G = B - 1;
      return Yw4(A, G, Q), new Date(Date.UTC(A, G, Q, pz(I.hours, "hour", 0, 23), pz(I.minutes, "minute", 0, 59), pz(I.seconds, "seconds", 0, 60), Jw4(I.fractionalMilliseconds)))
    }, "buildDate"),
    Iw4 = e0((A) => {
      let B = new Date().getUTCFullYear(),
        Q = Math.floor(B / 100) * 100 + _b(jb(A));
      if (Q < B) return Q + 100;
      return Q
    }, "parseTwoDigitYear"),
    Gw4 = 1576800000000,
    Zw4 = e0((A) => {
      if (A.getTime() - new Date().getTime() > Gw4) return new Date(Date.UTC(A.getUTCFullYear() - 100, A.getUTCMonth(), A.getUTCDate(), A.getUTCHours(), A.getUTCMinutes(), A.getUTCSeconds(), A.getUTCMilliseconds()));
      return A
    }, "adjustRfc850Year"),
    ly1 = e0((A) => {
      let B = Ak1.indexOf(A);
      if (B < 0) throw new TypeError(`Invalid month: ${A}`);
      return B + 1
    }, "parseMonthByShortName"),
    Dw4 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
    Yw4 = e0((A, B, Q) => {
      let I = Dw4[B];
      if (B === 1 && Ww4(A)) I = 29;
      if (Q > I) throw new TypeError(`Invalid day for ${Ak1[B]} in ${A}: ${Q}`)
    }, "validateDayOfMonth"),
    Ww4 = e0((A) => {
      return A % 4 === 0 && (A % 100 !== 0 || A % 400 === 0)
    }, "isLeapYear"),
    pz = e0((A, B, Q, I) => {
      let G = V20(jb(A));
      if (G < Q || G > I) throw new TypeError(`${B} must be between ${Q} and ${I}, inclusive`);
      return G
    }, "parseDateValue"),
    Jw4 = e0((A) => {
      if (A === null || A === void 0) return 0;
      return J20("0." + A) * 1000
    }, "parseMilliseconds"),
    Fw4 = e0((A) => {
      let B = A[0],
        Q = 1;
      if (B == "+") Q = 1;
      else if (B == "-") Q = -1;
      else throw new TypeError(`Offset direction, ${B}, must be "+" or "-"`);
      let I = Number(A.substring(1, 3)),
        G = Number(A.substring(4, 6));
      return Q * (I * 60 + G) * 60 * 1000
    }, "parseOffsetToMilliseconds"),
    jb = e0((A) => {
      let B = 0;
      while (B < A.length - 1 && A.charAt(B) === "0") B++;
      if (B === 0) return A;
      return A.slice(B)
    }, "stripLeadingZeroes"),
    Xw4 = class A extends Error {
      static {
        e0(this, "ServiceException")
      }
      constructor(B) {
        super(B.message);
        Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype), this.name = B.name, this.$fault = B.$fault, this.$metadata = B.$metadata
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return A.prototype.isPrototypeOf(Q) || Boolean(Q.$fault) && Boolean(Q.$metadata) && (Q.$fault === "client" || Q.$fault === "server")
      }
      static[Symbol.hasInstance](B) {
        if (!B) return !1;
        let Q = B;
        if (this === A) return A.isInstance(B);
        if (A.isInstance(B)) {
          if (Q.name && this.name) return this.prototype.isPrototypeOf(B) || Q.name === this.name;
          return this.prototype.isPrototypeOf(B)
        }
        return !1
      }
    },
    K20 = e0((A, B = {}) => {
      Object.entries(B).filter(([, I]) => I !== void 0).forEach(([I, G]) => {
        if (A[I] == null || A[I] === "") A[I] = G
      });
      let Q = A.message || A.Message || "UnknownError";
      return A.message = Q, delete A.Message, A
    }, "decorateServiceException"),
    H20 = e0(({
      output: A,
      parsedBody: B,
      exceptionCtor: Q,
      errorCode: I
    }) => {
      let G = Cw4(A),
        Z = G.httpStatusCode ? G.httpStatusCode + "" : void 0,
        D = new Q({
          name: B?.code || B?.Code || I || Z || "UnknownError",
          $fault: "client",
          $metadata: G
        });
      throw K20(D, B)
    }, "throwDefaultError"),
    Vw4 = e0((A) => {
      return ({
        output: B,
        parsedBody: Q,
        errorCode: I
      }) => {
        H20({
          output: B,
          parsedBody: Q,
          exceptionCtor: A,
          errorCode: I
        })
      }
    }, "withBaseException"),
    Cw4 = e0((A) => ({
      httpStatusCode: A.statusCode,
      requestId: A.headers["x-amzn-requestid"] ?? A.headers["x-amzn-request-id"] ?? A.headers["x-amz-request-id"],
      extendedRequestId: A.headers["x-amz-id-2"],
      cfId: A.headers["x-amz-cf-id"]
    }), "deserializeMetadata"),
    Kw4 = e0((A) => {
      switch (A) {
        case "standard":
          return {
            retryMode: "standard", connectionTimeout: 3100
          };
        case "in-region":
          return {
            retryMode: "standard", connectionTimeout: 1100
          };
        case "cross-region":
          return {
            retryMode: "standard", connectionTimeout: 3100
          };
        case "mobile":
          return {
            retryMode: "standard", connectionTimeout: 30000
          };
        default:
          return {}
      }
    }, "loadConfigsForDefaultMode"),
    G20 = !1,
    Hw4 = e0((A) => {
      if (A && !G20 && parseInt(A.substring(1, A.indexOf("."))) < 16) G20 = !0
    }, "emitWarningIfUnsupportedVersion"),
    zw4 = e0((A) => {
      let B = [];
      for (let Q in iy1.AlgorithmId) {
        let I = iy1.AlgorithmId[Q];
        if (A[I] === void 0) continue;
        B.push({
          algorithmId: () => I,
          checksumConstructor: () => A[I]
        })
      }
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    ww4 = e0((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    Ew4 = e0((A) => {
      return {
        setRetryStrategy(B) {
          A.retryStrategy = B
        },
        retryStrategy() {
          return A.retryStrategy
        }
      }
    }, "getRetryConfiguration"),
    Uw4 = e0((A) => {
      let B = {};
      return B.retryStrategy = A.retryStrategy(), B
    }, "resolveRetryRuntimeConfig"),
    z20 = e0((A) => {
      return Object.assign(zw4(A), Ew4(A))
    }, "getDefaultExtensionConfiguration"),
    Nw4 = z20,
    $w4 = e0((A) => {
      return Object.assign(ww4(A), Uw4(A))
    }, "resolveDefaultRuntimeConfig"),
    qw4 = e0((A) => Array.isArray(A) ? A : [A], "getArrayIfSingleItem"),
    w20 = e0((A) => {
      for (let Q in A)
        if (A.hasOwnProperty(Q) && A[Q]["#text"] !== void 0) A[Q] = A[Q]["#text"];
        else if (typeof A[Q] === "object" && A[Q] !== null) A[Q] = w20(A[Q]);
      return A
    }, "getValueFromTextNode"),
    Mw4 = e0((A) => {
      return A != null
    }, "isSerializableHeaderValue"),
    D_ = e0(function A(B) {
      return Object.assign(new String(B), {
        deserializeJSON() {
          return JSON.parse(String(B))
        },
        toString() {
          return String(B)
        },
        toJSON() {
          return String(B)
        }
      })
    }, "LazyJsonString");
  D_.from = (A) => {
    if (A && typeof A === "object" && (A instanceof D_ || ("deserializeJSON" in A))) return A;
    else if (typeof A === "string" || Object.getPrototypeOf(A) === String.prototype) return D_(String(A));
    return D_(JSON.stringify(A))
  };
  D_.fromObject = D_.from;
  var Lw4 = class {
    static {
      e0(this, "NoOpLogger")
    }
    trace() {}
    debug() {}
    info() {}
    warn() {}
    error() {}
  };

  function Bk1(A, B, Q) {
    let I, G, Z;
    if (typeof B === "undefined" && typeof Q === "undefined") I = {}, Z = A;
    else if (I = A, typeof B === "function") return G = B, Z = Q, Tw4(I, G, Z);
    else Z = B;
    for (let D of Object.keys(Z)) {
      if (!Array.isArray(Z[D])) {
        I[D] = Z[D];
        continue
      }
      E20(I, null, Z, D)
    }
    return I
  }
  e0(Bk1, "map");
  var Rw4 = e0((A) => {
      let B = {};
      for (let [Q, I] of Object.entries(A || {})) B[Q] = [, I];
      return B
    }, "convertMap"),
    Ow4 = e0((A, B) => {
      let Q = {};
      for (let I in B) E20(Q, A, B, I);
      return Q
    }, "take"),
    Tw4 = e0((A, B, Q) => {
      return Bk1(A, Object.entries(Q).reduce((I, [G, Z]) => {
        if (Array.isArray(Z)) I[G] = Z;
        else if (typeof Z === "function") I[G] = [B, Z()];
        else I[G] = [B, Z];
        return I
      }, {}))
    }, "mapWithFilter"),
    E20 = e0((A, B, Q, I) => {
      if (B !== null) {
        let D = Q[I];
        if (typeof D === "function") D = [, D];
        let [Y = Pw4, W = Sw4, J = I] = D;
        if (typeof Y === "function" && Y(B[J]) || typeof Y !== "function" && !!Y) A[I] = W(B[J]);
        return
      }
      let [G, Z] = Q[I];
      if (typeof Z === "function") {
        let D, Y = G === void 0 && (D = Z()) != null,
          W = typeof G === "function" && !!G(void 0) || typeof G !== "function" && !!G;
        if (Y) A[I] = D;
        else if (W) A[I] = Z()
      } else {
        let D = G === void 0 && Z != null,
          Y = typeof G === "function" && !!G(Z) || typeof G !== "function" && !!G;
        if (D || Y) A[I] = Z
      }
    }, "applyInstruction"),
    Pw4 = e0((A) => A != null, "nonNullish"),
    Sw4 = e0((A) => A, "pass");

  function U20(A) {
    if (A.includes(",") || A.includes('"')) A = `"${A.replace(/"/g,"\\\"")}"`;
    return A
  }
  e0(U20, "quoteHeader");
  var _w4 = e0((A) => {
      if (A !== A) return "NaN";
      switch (A) {
        case 1 / 0:
          return "Infinity";
        case -1 / 0:
          return "-Infinity";
        default:
          return A
      }
    }, "serializeFloat"),
    jw4 = e0((A) => A.toISOString().replace(".000Z", "Z"), "serializeDateTime"),
    ry1 = e0((A) => {
      if (A == null) return {};
      if (Array.isArray(A)) return A.filter((B) => B != null).map(ry1);
      if (typeof A === "object") {
        let B = {};
        for (let Q of Object.keys(A)) {
          if (A[Q] == null) continue;
          B[Q] = ry1(A[Q])
        }
        return B
      }
      return A
    }, "_json");

  function N20(A, B, Q) {
    if (Q <= 0 || !Number.isInteger(Q)) throw new Error("Invalid number of delimiters (" + Q + ") for splitEvery.");
    let I = A.split(B);
    if (Q === 1) return I;
    let G = [],
      Z = "";
    for (let D = 0; D < I.length; D++) {
      if (Z === "") Z = I[D];
      else Z += B + I[D];
      if ((D + 1) % Q === 0) G.push(Z), Z = ""
    }
    if (Z !== "") G.push(Z);
    return G
  }
  e0(N20, "splitEvery");
  var yw4 = e0((A) => {
    let B = A.length,
      Q = [],
      I = !1,
      G = void 0,
      Z = 0;
    for (let D = 0; D < B; ++D) {
      let Y = A[D];
      switch (Y) {
        case '"':
          if (G !== "\\") I = !I;
          break;
        case ",":
          if (!I) Q.push(A.slice(Z, D)), Z = D + 1;
          break;
        default:
      }
      G = Y
    }
    return Q.push(A.slice(Z)), Q.map((D) => {
      D = D.trim();
      let Y = D.length;
      if (Y < 2) return D;
      if (D[0] === '"' && D[Y - 1] === '"') D = D.slice(1, Y - 1);
      return D.replace(/\\"/g, '"')
    })
  }, "splitHeader")
})
// @from(Start 3589864, End 3590354)
L20 = z((q20) => {
  Object.defineProperty(q20, "__esModule", {
    value: !0
  });
  q20.fromBase64 = void 0;
  var kw4 = MZ(),
    xw4 = /^[A-Za-z0-9+/]*={0,2}$/,
    fw4 = (A) => {
      if (A.length * 3 % 4 !== 0) throw new TypeError("Incorrect padding on base64 string.");
      if (!xw4.exec(A)) throw new TypeError("Invalid base64 string.");
      let B = kw4.fromString(A, "base64");
      return new Uint8Array(B.buffer, B.byteOffset, B.byteLength)
    };
  q20.fromBase64 = fw4
})
// @from(Start 3590360, End 3590933)
T20 = z((R20) => {
  Object.defineProperty(R20, "__esModule", {
    value: !0
  });
  R20.toBase64 = void 0;
  var vw4 = MZ(),
    bw4 = RQ(),
    gw4 = (A) => {
      let B;
      if (typeof A === "string") B = bw4.fromUtf8(A);
      else B = A;
      if (typeof B !== "object" || typeof B.byteOffset !== "number" || typeof B.byteLength !== "number") throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
      return vw4.fromArrayBuffer(B.buffer, B.byteOffset, B.byteLength).toString("base64")
    };
  R20.toBase64 = gw4
})
// @from(Start 3590939, End 3591635)
_20 = z((CG8, KI1) => {
  var {
    defineProperty: P20,
    getOwnPropertyDescriptor: hw4,
    getOwnPropertyNames: mw4
  } = Object, dw4 = Object.prototype.hasOwnProperty, Qk1 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of mw4(B))
        if (!dw4.call(A, G) && G !== Q) P20(A, G, {
          get: () => B[G],
          enumerable: !(I = hw4(B, G)) || I.enumerable
        })
    }
    return A
  }, S20 = (A, B, Q) => (Qk1(A, B, "default"), Q && Qk1(Q, B, "default")), uw4 = (A) => Qk1(P20({}, "__esModule", {
    value: !0
  }), A), Ik1 = {};
  KI1.exports = uw4(Ik1);
  S20(Ik1, L20(), KI1.exports);
  S20(Ik1, T20(), KI1.exports)
})
// @from(Start 3591641, End 3596311)
n20 = z((l20) => {
  Object.defineProperty(l20, "__esModule", {
    value: !0
  });
  l20.ruleSet = void 0;
  var d20 = "required",
    JX = "fn",
    FX = "argv",
    fb = "ref",
    j20 = !0,
    y20 = "isSet",
    $a = "booleanEquals",
    kb = "error",
    xb = "endpoint",
    VN = "tree",
    Gk1 = "PartitionResult",
    Zk1 = "getAttr",
    k20 = {
      [d20]: !1,
      type: "String"
    },
    x20 = {
      [d20]: !0,
      default: !1,
      type: "Boolean"
    },
    f20 = {
      [fb]: "Endpoint"
    },
    u20 = {
      [JX]: $a,
      [FX]: [{
        [fb]: "UseFIPS"
      }, !0]
    },
    p20 = {
      [JX]: $a,
      [FX]: [{
        [fb]: "UseDualStack"
      }, !0]
    },
    WX = {},
    v20 = {
      [JX]: Zk1,
      [FX]: [{
        [fb]: Gk1
      }, "supportsFIPS"]
    },
    c20 = {
      [fb]: Gk1
    },
    b20 = {
      [JX]: $a,
      [FX]: [!0, {
        [JX]: Zk1,
        [FX]: [c20, "supportsDualStack"]
      }]
    },
    g20 = [u20],
    h20 = [p20],
    m20 = [{
      [fb]: "Region"
    }],
    pw4 = {
      version: "1.0",
      parameters: {
        Region: k20,
        UseDualStack: x20,
        UseFIPS: x20,
        Endpoint: k20
      },
      rules: [{
        conditions: [{
          [JX]: y20,
          [FX]: [f20]
        }],
        rules: [{
          conditions: g20,
          error: "Invalid Configuration: FIPS and custom endpoint are not supported",
          type: kb
        }, {
          conditions: h20,
          error: "Invalid Configuration: Dualstack and custom endpoint are not supported",
          type: kb
        }, {
          endpoint: {
            url: f20,
            properties: WX,
            headers: WX
          },
          type: xb
        }],
        type: VN
      }, {
        conditions: [{
          [JX]: y20,
          [FX]: m20
        }],
        rules: [{
          conditions: [{
            [JX]: "aws.partition",
            [FX]: m20,
            assign: Gk1
          }],
          rules: [{
            conditions: [u20, p20],
            rules: [{
              conditions: [{
                [JX]: $a,
                [FX]: [j20, v20]
              }, b20],
              rules: [{
                endpoint: {
                  url: "https://portal.sso-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
                  properties: WX,
                  headers: WX
                },
                type: xb
              }],
              type: VN
            }, {
              error: "FIPS and DualStack are enabled, but this partition does not support one or both",
              type: kb
            }],
            type: VN
          }, {
            conditions: g20,
            rules: [{
              conditions: [{
                [JX]: $a,
                [FX]: [v20, j20]
              }],
              rules: [{
                conditions: [{
                  [JX]: "stringEquals",
                  [FX]: [{
                    [JX]: Zk1,
                    [FX]: [c20, "name"]
                  }, "aws-us-gov"]
                }],
                endpoint: {
                  url: "https://portal.sso.{Region}.amazonaws.com",
                  properties: WX,
                  headers: WX
                },
                type: xb
              }, {
                endpoint: {
                  url: "https://portal.sso-fips.{Region}.{PartitionResult#dnsSuffix}",
                  properties: WX,
                  headers: WX
                },
                type: xb
              }],
              type: VN
            }, {
              error: "FIPS is enabled but this partition does not support FIPS",
              type: kb
            }],
            type: VN
          }, {
            conditions: h20,
            rules: [{
              conditions: [b20],
              rules: [{
                endpoint: {
                  url: "https://portal.sso.{Region}.{PartitionResult#dualStackDnsSuffix}",
                  properties: WX,
                  headers: WX
                },
                type: xb
              }],
              type: VN
            }, {
              error: "DualStack is enabled but this partition does not support DualStack",
              type: kb
            }],
            type: VN
          }, {
            endpoint: {
              url: "https://portal.sso.{Region}.{PartitionResult#dnsSuffix}",
              properties: WX,
              headers: WX
            },
            type: xb
          }],
          type: VN
        }],
        type: VN
      }, {
        error: "Invalid Configuration: Missing Region",
        type: kb
      }]
    };
  l20.ruleSet = pw4
})
// @from(Start 3596317, End 3596875)
r20 = z((a20) => {
  Object.defineProperty(a20, "__esModule", {
    value: !0
  });
  a20.defaultEndpointResolver = void 0;
  var cw4 = RL(),
    Dk1 = LL(),
    lw4 = n20(),
    iw4 = new Dk1.EndpointCache({
      size: 50,
      params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
    }),
    nw4 = (A, B = {}) => {
      return iw4.get(A, () => Dk1.resolveEndpoint(lw4.ruleSet, {
        endpointParams: A,
        logger: B.logger
      }))
    };
  a20.defaultEndpointResolver = nw4;
  Dk1.customEndpointFunctions.aws = cw4.awsEndpointFunctions
})
// @from(Start 3596881, End 3598291)
B90 = z((e20) => {
  Object.defineProperty(e20, "__esModule", {
    value: !0
  });
  e20.getRuntimeConfig = void 0;
  var aw4 = IB(),
    sw4 = NI(),
    rw4 = Na(),
    ow4 = FN(),
    o20 = _20(),
    t20 = RQ(),
    tw4 = gy1(),
    ew4 = r20(),
    AE4 = (A) => {
      return {
        apiVersion: "2019-06-10",
        base64Decoder: A?.base64Decoder ?? o20.fromBase64,
        base64Encoder: A?.base64Encoder ?? o20.toBase64,
        disableHostPrefix: A?.disableHostPrefix ?? !1,
        endpointProvider: A?.endpointProvider ?? ew4.defaultEndpointResolver,
        extensions: A?.extensions ?? [],
        httpAuthSchemeProvider: A?.httpAuthSchemeProvider ?? tw4.defaultSSOHttpAuthSchemeProvider,
        httpAuthSchemes: A?.httpAuthSchemes ?? [{
          schemeId: "aws.auth#sigv4",
          identityProvider: (B) => B.getIdentityProvider("aws.auth#sigv4"),
          signer: new aw4.AwsSdkSigV4Signer
        }, {
          schemeId: "smithy.api#noAuth",
          identityProvider: (B) => B.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
          signer: new sw4.NoAuthSigner
        }],
        logger: A?.logger ?? new rw4.NoOpLogger,
        serviceId: A?.serviceId ?? "SSO",
        urlParser: A?.urlParser ?? ow4.parseUrl,
        utf8Decoder: A?.utf8Decoder ?? t20.fromUtf8,
        utf8Encoder: A?.utf8Encoder ?? t20.toUtf8
      }
    };
  e20.getRuntimeConfig = AE4
})
// @from(Start 3598297, End 3601318)
Y_ = z((wG8, Y90) => {
  var {
    create: BE4,
    defineProperty: qa,
    getOwnPropertyDescriptor: QE4,
    getOwnPropertyNames: IE4,
    getPrototypeOf: GE4
  } = Object, ZE4 = Object.prototype.hasOwnProperty, Yk1 = (A, B) => qa(A, "name", {
    value: B,
    configurable: !0
  }), DE4 = (A, B) => {
    for (var Q in B) qa(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, Z90 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of IE4(B))
        if (!ZE4.call(A, G) && G !== Q) qa(A, G, {
          get: () => B[G],
          enumerable: !(I = QE4(B, G)) || I.enumerable
        })
    }
    return A
  }, YE4 = (A, B, Q) => (Q = A != null ? BE4(GE4(A)) : {}, Z90(B || !A || !A.__esModule ? qa(Q, "default", {
    value: A,
    enumerable: !0
  }) : Q, A)), WE4 = (A) => Z90(qa({}, "__esModule", {
    value: !0
  }), A), D90 = {};
  DE4(D90, {
    resolveDefaultsModeConfig: () => EE4
  });
  Y90.exports = WE4(D90);
  var JE4 = _D(),
    Q90 = qC(),
    FE4 = $I(),
    XE4 = "AWS_EXECUTION_ENV",
    I90 = "AWS_REGION",
    G90 = "AWS_DEFAULT_REGION",
    VE4 = "AWS_EC2_METADATA_DISABLED",
    CE4 = ["in-region", "cross-region", "mobile", "standard", "legacy"],
    KE4 = "/latest/meta-data/placement/region",
    HE4 = "AWS_DEFAULTS_MODE",
    zE4 = "defaults_mode",
    wE4 = {
      environmentVariableSelector: (A) => {
        return A[HE4]
      },
      configFileSelector: (A) => {
        return A[zE4]
      },
      default: "legacy"
    },
    EE4 = Yk1(({
      region: A = Q90.loadConfig(JE4.NODE_REGION_CONFIG_OPTIONS),
      defaultsMode: B = Q90.loadConfig(wE4)
    } = {}) => FE4.memoize(async () => {
      let Q = typeof B === "function" ? await B() : B;
      switch (Q?.toLowerCase()) {
        case "auto":
          return UE4(A);
        case "in-region":
        case "cross-region":
        case "mobile":
        case "standard":
        case "legacy":
          return Promise.resolve(Q?.toLocaleLowerCase());
        case void 0:
          return Promise.resolve("legacy");
        default:
          throw new Error(`Invalid parameter for "defaultsMode", expect ${CE4.join(", ")}, got ${Q}`)
      }
    }), "resolveDefaultsModeConfig"),
    UE4 = Yk1(async (A) => {
      if (A) {
        let B = typeof A === "function" ? await A() : A,
          Q = await NE4();
        if (!Q) return "standard";
        if (B === Q) return "in-region";
        else return "cross-region"
      }
      return "standard"
    }, "resolveNodeDefaultsModeAuto"),
    NE4 = Yk1(async () => {
      if (process.env[XE4] && (process.env[I90] || process.env[G90])) return process.env[I90] ?? process.env[G90];
      if (!process.env[VE4]) try {
        let {
          getInstanceMetadataEndpoint: A,
          httpRequest: B
        } = await Promise.resolve().then(() => YE4(B_())), Q = await A();
        return (await B({
          ...Q,
          path: KE4
        })).toString()
      } catch (A) {}
    }, "inferPhysicalRegion")
})
// @from(Start 3601324, End 3603421)
C90 = z((X90) => {
  Object.defineProperty(X90, "__esModule", {
    value: !0
  });
  X90.getRuntimeConfig = void 0;
  var $E4 = k00(),
    qE4 = $E4.__importDefault(x00()),
    ME4 = IB(),
    W90 = I_(),
    HI1 = _D(),
    LE4 = G_(),
    J90 = KJ(),
    vb = qC(),
    F90 = DN(),
    RE4 = Z_(),
    OE4 = vL(),
    TE4 = B90(),
    PE4 = Na(),
    SE4 = Y_(),
    _E4 = Na(),
    jE4 = (A) => {
      _E4.emitWarningIfUnsupportedVersion(process.version);
      let B = SE4.resolveDefaultsModeConfig(A),
        Q = () => B().then(PE4.loadConfigsForDefaultMode),
        I = TE4.getRuntimeConfig(A);
      ME4.emitWarningIfUnsupportedVersion(process.version);
      let G = {
        profile: A?.profile
      };
      return {
        ...I,
        ...A,
        runtime: "node",
        defaultsMode: B,
        bodyLengthChecker: A?.bodyLengthChecker ?? RE4.calculateBodyLength,
        defaultUserAgentProvider: A?.defaultUserAgentProvider ?? W90.createDefaultUserAgentProvider({
          serviceId: I.serviceId,
          clientVersion: qE4.default.version
        }),
        maxAttempts: A?.maxAttempts ?? vb.loadConfig(J90.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, A),
        region: A?.region ?? vb.loadConfig(HI1.NODE_REGION_CONFIG_OPTIONS, {
          ...HI1.NODE_REGION_CONFIG_FILE_OPTIONS,
          ...G
        }),
        requestHandler: F90.NodeHttpHandler.create(A?.requestHandler ?? Q),
        retryMode: A?.retryMode ?? vb.loadConfig({
          ...J90.NODE_RETRY_MODE_CONFIG_OPTIONS,
          default: async () => (await Q()).retryMode || OE4.DEFAULT_RETRY_MODE
        }, A),
        sha256: A?.sha256 ?? LE4.Hash.bind(null, "sha256"),
        streamCollector: A?.streamCollector ?? F90.streamCollector,
        useDualstackEndpoint: A?.useDualstackEndpoint ?? vb.loadConfig(HI1.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, G),
        useFipsEndpoint: A?.useFipsEndpoint ?? vb.loadConfig(HI1.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, G),
        userAgentAppId: A?.userAgentAppId ?? vb.loadConfig(W90.NODE_APP_ID_CONFIG_OPTIONS, G)
      }
    };
  X90.getRuntimeConfig = jE4
})
// @from(Start 3603427, End 3606037)
W_ = z((UG8, U90) => {
  var {
    defineProperty: zI1,
    getOwnPropertyDescriptor: yE4,
    getOwnPropertyNames: kE4
  } = Object, xE4 = Object.prototype.hasOwnProperty, cz = (A, B) => zI1(A, "name", {
    value: B,
    configurable: !0
  }), fE4 = (A, B) => {
    for (var Q in B) zI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, vE4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of kE4(B))
        if (!xE4.call(A, G) && G !== Q) zI1(A, G, {
          get: () => B[G],
          enumerable: !(I = yE4(B, G)) || I.enumerable
        })
    }
    return A
  }, bE4 = (A) => vE4(zI1({}, "__esModule", {
    value: !0
  }), A), H90 = {};
  fE4(H90, {
    NODE_REGION_CONFIG_FILE_OPTIONS: () => dE4,
    NODE_REGION_CONFIG_OPTIONS: () => mE4,
    REGION_ENV_NAME: () => z90,
    REGION_INI_NAME: () => w90,
    getAwsRegionExtensionConfiguration: () => gE4,
    resolveAwsRegionExtensionConfiguration: () => hE4,
    resolveRegionConfig: () => uE4
  });
  U90.exports = bE4(H90);
  var gE4 = cz((A) => {
      return {
        setRegion(B) {
          A.region = B
        },
        region() {
          return A.region
        }
      }
    }, "getAwsRegionExtensionConfiguration"),
    hE4 = cz((A) => {
      return {
        region: A.region()
      }
    }, "resolveAwsRegionExtensionConfiguration"),
    z90 = "AWS_REGION",
    w90 = "region",
    mE4 = {
      environmentVariableSelector: cz((A) => A[z90], "environmentVariableSelector"),
      configFileSelector: cz((A) => A[w90], "configFileSelector"),
      default: cz(() => {
        throw new Error("Region is missing")
      }, "default")
    },
    dE4 = {
      preferredFile: "credentials"
    },
    E90 = cz((A) => typeof A === "string" && (A.startsWith("fips-") || A.endsWith("-fips")), "isFipsRegion"),
    K90 = cz((A) => E90(A) ? ["fips-aws-global", "aws-fips"].includes(A) ? "us-east-1" : A.replace(/fips-(dkr-|prod-)?|-fips/, "") : A, "getRealRegion"),
    uE4 = cz((A) => {
      let {
        region: B,
        useFipsEndpoint: Q
      } = A;
      if (!B) throw new Error("Region is missing");
      return Object.assign(A, {
        region: cz(async () => {
          if (typeof B === "string") return K90(B);
          let I = await B();
          return K90(I)
        }, "region"),
        useFipsEndpoint: cz(async () => {
          let I = typeof B === "string" ? B : await B();
          if (E90(I)) return !0;
          return typeof Q !== "function" ? Promise.resolve(!!Q) : Q()
        }, "useFipsEndpoint")
      })
    }, "resolveRegionConfig")
})
// @from(Start 3606043, End 3610550)
R90 = z((NG8, L90) => {
  var {
    defineProperty: wI1,
    getOwnPropertyDescriptor: pE4,
    getOwnPropertyNames: cE4
  } = Object, lE4 = Object.prototype.hasOwnProperty, hL = (A, B) => wI1(A, "name", {
    value: B,
    configurable: !0
  }), iE4 = (A, B) => {
    for (var Q in B) wI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, nE4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of cE4(B))
        if (!lE4.call(A, G) && G !== Q) wI1(A, G, {
          get: () => B[G],
          enumerable: !(I = pE4(B, G)) || I.enumerable
        })
    }
    return A
  }, aE4 = (A) => nE4(wI1({}, "__esModule", {
    value: !0
  }), A), N90 = {};
  iE4(N90, {
    Field: () => oE4,
    Fields: () => tE4,
    HttpRequest: () => eE4,
    HttpResponse: () => AU4,
    IHttpRequest: () => $90.HttpRequest,
    getHttpHandlerExtensionConfiguration: () => sE4,
    isValidHostname: () => M90,
    resolveHttpHandlerRuntimeConfig: () => rE4
  });
  L90.exports = aE4(N90);
  var sE4 = hL((A) => {
      return {
        setHttpHandler(B) {
          A.httpHandler = B
        },
        httpHandler() {
          return A.httpHandler
        },
        updateHttpClientConfig(B, Q) {
          A.httpHandler?.updateHttpClientConfig(B, Q)
        },
        httpHandlerConfigs() {
          return A.httpHandler.httpHandlerConfigs()
        }
      }
    }, "getHttpHandlerExtensionConfiguration"),
    rE4 = hL((A) => {
      return {
        httpHandler: A.httpHandler()
      }
    }, "resolveHttpHandlerRuntimeConfig"),
    $90 = py1(),
    oE4 = class {
      static {
        hL(this, "Field")
      }
      constructor({
        name: A,
        kind: B = $90.FieldPosition.HEADER,
        values: Q = []
      }) {
        this.name = A, this.kind = B, this.values = Q
      }
      add(A) {
        this.values.push(A)
      }
      set(A) {
        this.values = A
      }
      remove(A) {
        this.values = this.values.filter((B) => B !== A)
      }
      toString() {
        return this.values.map((A) => A.includes(",") || A.includes(" ") ? `"${A}"` : A).join(", ")
      }
      get() {
        return this.values
      }
    },
    tE4 = class {
      constructor({
        fields: A = [],
        encoding: B = "utf-8"
      }) {
        this.entries = {}, A.forEach(this.setField.bind(this)), this.encoding = B
      }
      static {
        hL(this, "Fields")
      }
      setField(A) {
        this.entries[A.name.toLowerCase()] = A
      }
      getField(A) {
        return this.entries[A.toLowerCase()]
      }
      removeField(A) {
        delete this.entries[A.toLowerCase()]
      }
      getByType(A) {
        return Object.values(this.entries).filter((B) => B.kind === A)
      }
    },
    eE4 = class A {
      static {
        hL(this, "HttpRequest")
      }
      constructor(B) {
        this.method = B.method || "GET", this.hostname = B.hostname || "localhost", this.port = B.port, this.query = B.query || {}, this.headers = B.headers || {}, this.body = B.body, this.protocol = B.protocol ? B.protocol.slice(-1) !== ":" ? `${B.protocol}:` : B.protocol : "https:", this.path = B.path ? B.path.charAt(0) !== "/" ? `/${B.path}` : B.path : "/", this.username = B.username, this.password = B.password, this.fragment = B.fragment
      }
      static clone(B) {
        let Q = new A({
          ...B,
          headers: {
            ...B.headers
          }
        });
        if (Q.query) Q.query = q90(Q.query);
        return Q
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return "method" in Q && "protocol" in Q && "hostname" in Q && "path" in Q && typeof Q.query === "object" && typeof Q.headers === "object"
      }
      clone() {
        return A.clone(this)
      }
    };

  function q90(A) {
    return Object.keys(A).reduce((B, Q) => {
      let I = A[Q];
      return {
        ...B,
        [Q]: Array.isArray(I) ? [...I] : I
      }
    }, {})
  }
  hL(q90, "cloneQuery");
  var AU4 = class {
    static {
      hL(this, "HttpResponse")
    }
    constructor(A) {
      this.statusCode = A.statusCode, this.reason = A.reason, this.headers = A.headers || {}, this.body = A.body
    }
    static isInstance(A) {
      if (!A) return !1;
      let B = A;
      return typeof B.statusCode === "number" && typeof B.headers === "object"
    }
  };

  function M90(A) {
    return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(A)
  }
  hL(M90, "isValidHostname")
})
// @from(Start 3610556, End 3626691)
e90 = z((LG8, t90) => {
  var {
    defineProperty: EI1,
    getOwnPropertyDescriptor: BU4,
    getOwnPropertyNames: QU4
  } = Object, IU4 = Object.prototype.hasOwnProperty, j6 = (A, B) => EI1(A, "name", {
    value: B,
    configurable: !0
  }), GU4 = (A, B) => {
    for (var Q in B) EI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, ZU4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of QU4(B))
        if (!IU4.call(A, G) && G !== Q) EI1(A, G, {
          get: () => B[G],
          enumerable: !(I = BU4(B, G)) || I.enumerable
        })
    }
    return A
  }, DU4 = (A) => ZU4(EI1({}, "__esModule", {
    value: !0
  }), A), y90 = {};
  GU4(y90, {
    GetRoleCredentialsCommand: () => s90,
    GetRoleCredentialsRequestFilterSensitiveLog: () => b90,
    GetRoleCredentialsResponseFilterSensitiveLog: () => h90,
    InvalidRequestException: () => k90,
    ListAccountRolesCommand: () => Wk1,
    ListAccountRolesRequestFilterSensitiveLog: () => m90,
    ListAccountsCommand: () => Jk1,
    ListAccountsRequestFilterSensitiveLog: () => d90,
    LogoutCommand: () => r90,
    LogoutRequestFilterSensitiveLog: () => u90,
    ResourceNotFoundException: () => x90,
    RoleCredentialsFilterSensitiveLog: () => g90,
    SSO: () => o90,
    SSOClient: () => NI1,
    SSOServiceException: () => bb,
    TooManyRequestsException: () => f90,
    UnauthorizedException: () => v90,
    __Client: () => f2.Client,
    paginateListAccountRoles: () => yU4,
    paginateListAccounts: () => kU4
  });
  t90.exports = DU4(y90);
  var O90 = cS(),
    YU4 = lS(),
    WU4 = iS(),
    T90 = jL(),
    JU4 = _D(),
    CN = NI(),
    FU4 = tS(),
    La = hz(),
    P90 = KJ(),
    S90 = gy1(),
    XU4 = j6((A) => {
      return Object.assign(A, {
        useDualstackEndpoint: A.useDualstackEndpoint ?? !1,
        useFipsEndpoint: A.useFipsEndpoint ?? !1,
        defaultSigningName: "awsssoportal"
      })
    }, "resolveClientEndpointParameters"),
    UI1 = {
      UseFIPS: {
        type: "builtInParams",
        name: "useFipsEndpoint"
      },
      Endpoint: {
        type: "builtInParams",
        name: "endpoint"
      },
      Region: {
        type: "builtInParams",
        name: "region"
      },
      UseDualStack: {
        type: "builtInParams",
        name: "useDualstackEndpoint"
      }
    },
    VU4 = C90(),
    _90 = W_(),
    j90 = R90(),
    f2 = Na(),
    CU4 = j6((A) => {
      let {
        httpAuthSchemes: B,
        httpAuthSchemeProvider: Q,
        credentials: I
      } = A;
      return {
        setHttpAuthScheme(G) {
          let Z = B.findIndex((D) => D.schemeId === G.schemeId);
          if (Z === -1) B.push(G);
          else B.splice(Z, 1, G)
        },
        httpAuthSchemes() {
          return B
        },
        setHttpAuthSchemeProvider(G) {
          Q = G
        },
        httpAuthSchemeProvider() {
          return Q
        },
        setCredentials(G) {
          I = G
        },
        credentials() {
          return I
        }
      }
    }, "getHttpAuthExtensionConfiguration"),
    KU4 = j6((A) => {
      return {
        httpAuthSchemes: A.httpAuthSchemes(),
        httpAuthSchemeProvider: A.httpAuthSchemeProvider(),
        credentials: A.credentials()
      }
    }, "resolveHttpAuthRuntimeConfig"),
    HU4 = j6((A, B) => {
      let Q = Object.assign(_90.getAwsRegionExtensionConfiguration(A), f2.getDefaultExtensionConfiguration(A), j90.getHttpHandlerExtensionConfiguration(A), CU4(A));
      return B.forEach((I) => I.configure(Q)), Object.assign(A, _90.resolveAwsRegionExtensionConfiguration(Q), f2.resolveDefaultRuntimeConfig(Q), j90.resolveHttpHandlerRuntimeConfig(Q), KU4(Q))
    }, "resolveRuntimeExtensions"),
    NI1 = class extends f2.Client {
      static {
        j6(this, "SSOClient")
      }
      config;
      constructor(...[A]) {
        let B = VU4.getRuntimeConfig(A || {});
        super(B);
        this.initConfig = B;
        let Q = XU4(B),
          I = T90.resolveUserAgentConfig(Q),
          G = P90.resolveRetryConfig(I),
          Z = JU4.resolveRegionConfig(G),
          D = O90.resolveHostHeaderConfig(Z),
          Y = La.resolveEndpointConfig(D),
          W = S90.resolveHttpAuthSchemeConfig(Y),
          J = HU4(W, A?.extensions || []);
        this.config = J, this.middlewareStack.use(T90.getUserAgentPlugin(this.config)), this.middlewareStack.use(P90.getRetryPlugin(this.config)), this.middlewareStack.use(FU4.getContentLengthPlugin(this.config)), this.middlewareStack.use(O90.getHostHeaderPlugin(this.config)), this.middlewareStack.use(YU4.getLoggerPlugin(this.config)), this.middlewareStack.use(WU4.getRecursionDetectionPlugin(this.config)), this.middlewareStack.use(CN.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
          httpAuthSchemeParametersProvider: S90.defaultSSOHttpAuthSchemeParametersProvider,
          identityProviderConfigProvider: j6(async (F) => new CN.DefaultIdentityProviderConfig({
            "aws.auth#sigv4": F.credentials
          }), "identityProviderConfigProvider")
        })), this.middlewareStack.use(CN.getHttpSigningPlugin(this.config))
      }
      destroy() {
        super.destroy()
      }
    },
    $I1 = yz(),
    bb = class A extends f2.ServiceException {
      static {
        j6(this, "SSOServiceException")
      }
      constructor(B) {
        super(B);
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    k90 = class A extends bb {
      static {
        j6(this, "InvalidRequestException")
      }
      name = "InvalidRequestException";
      $fault = "client";
      constructor(B) {
        super({
          name: "InvalidRequestException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    x90 = class A extends bb {
      static {
        j6(this, "ResourceNotFoundException")
      }
      name = "ResourceNotFoundException";
      $fault = "client";
      constructor(B) {
        super({
          name: "ResourceNotFoundException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    f90 = class A extends bb {
      static {
        j6(this, "TooManyRequestsException")
      }
      name = "TooManyRequestsException";
      $fault = "client";
      constructor(B) {
        super({
          name: "TooManyRequestsException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    v90 = class A extends bb {
      static {
        j6(this, "UnauthorizedException")
      }
      name = "UnauthorizedException";
      $fault = "client";
      constructor(B) {
        super({
          name: "UnauthorizedException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    b90 = j6((A) => ({
      ...A,
      ...A.accessToken && {
        accessToken: f2.SENSITIVE_STRING
      }
    }), "GetRoleCredentialsRequestFilterSensitiveLog"),
    g90 = j6((A) => ({
      ...A,
      ...A.secretAccessKey && {
        secretAccessKey: f2.SENSITIVE_STRING
      },
      ...A.sessionToken && {
        sessionToken: f2.SENSITIVE_STRING
      }
    }), "RoleCredentialsFilterSensitiveLog"),
    h90 = j6((A) => ({
      ...A,
      ...A.roleCredentials && {
        roleCredentials: g90(A.roleCredentials)
      }
    }), "GetRoleCredentialsResponseFilterSensitiveLog"),
    m90 = j6((A) => ({
      ...A,
      ...A.accessToken && {
        accessToken: f2.SENSITIVE_STRING
      }
    }), "ListAccountRolesRequestFilterSensitiveLog"),
    d90 = j6((A) => ({
      ...A,
      ...A.accessToken && {
        accessToken: f2.SENSITIVE_STRING
      }
    }), "ListAccountsRequestFilterSensitiveLog"),
    u90 = j6((A) => ({
      ...A,
      ...A.accessToken && {
        accessToken: f2.SENSITIVE_STRING
      }
    }), "LogoutRequestFilterSensitiveLog"),
    Ma = IB(),
    zU4 = j6(async (A, B) => {
      let Q = CN.requestBuilder(A, B),
        I = f2.map({}, f2.isSerializableHeaderValue, {
          [LI1]: A[MI1]
        });
      Q.bp("/federation/credentials");
      let G = f2.map({
          [_U4]: [, f2.expectNonNull(A[SU4], "roleName")],
          [c90]: [, f2.expectNonNull(A[p90], "accountId")]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_GetRoleCredentialsCommand"),
    wU4 = j6(async (A, B) => {
      let Q = CN.requestBuilder(A, B),
        I = f2.map({}, f2.isSerializableHeaderValue, {
          [LI1]: A[MI1]
        });
      Q.bp("/assignment/roles");
      let G = f2.map({
          [a90]: [, A[n90]],
          [i90]: [() => A.maxResults !== void 0, () => A[l90].toString()],
          [c90]: [, f2.expectNonNull(A[p90], "accountId")]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListAccountRolesCommand"),
    EU4 = j6(async (A, B) => {
      let Q = CN.requestBuilder(A, B),
        I = f2.map({}, f2.isSerializableHeaderValue, {
          [LI1]: A[MI1]
        });
      Q.bp("/assignment/accounts");
      let G = f2.map({
          [a90]: [, A[n90]],
          [i90]: [() => A.maxResults !== void 0, () => A[l90].toString()]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListAccountsCommand"),
    UU4 = j6(async (A, B) => {
      let Q = CN.requestBuilder(A, B),
        I = f2.map({}, f2.isSerializableHeaderValue, {
          [LI1]: A[MI1]
        });
      Q.bp("/logout");
      let G;
      return Q.m("POST").h(I).b(G), Q.build()
    }, "se_LogoutCommand"),
    NU4 = j6(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return qI1(A, B);
      let Q = f2.map({
          $metadata: mL(A)
        }),
        I = f2.expectNonNull(f2.expectObject(await Ma.parseJsonBody(A.body, B)), "body"),
        G = f2.take(I, {
          roleCredentials: f2._json
        });
      return Object.assign(Q, G), Q
    }, "de_GetRoleCredentialsCommand"),
    $U4 = j6(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return qI1(A, B);
      let Q = f2.map({
          $metadata: mL(A)
        }),
        I = f2.expectNonNull(f2.expectObject(await Ma.parseJsonBody(A.body, B)), "body"),
        G = f2.take(I, {
          nextToken: f2.expectString,
          roleList: f2._json
        });
      return Object.assign(Q, G), Q
    }, "de_ListAccountRolesCommand"),
    qU4 = j6(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return qI1(A, B);
      let Q = f2.map({
          $metadata: mL(A)
        }),
        I = f2.expectNonNull(f2.expectObject(await Ma.parseJsonBody(A.body, B)), "body"),
        G = f2.take(I, {
          accountList: f2._json,
          nextToken: f2.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_ListAccountsCommand"),
    MU4 = j6(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return qI1(A, B);
      let Q = f2.map({
        $metadata: mL(A)
      });
      return await f2.collectBody(A.body, B), Q
    }, "de_LogoutCommand"),
    qI1 = j6(async (A, B) => {
      let Q = {
          ...A,
          body: await Ma.parseJsonErrorBody(A.body, B)
        },
        I = Ma.loadRestJsonErrorCode(A, Q.body);
      switch (I) {
        case "InvalidRequestException":
        case "com.amazonaws.sso#InvalidRequestException":
          throw await RU4(Q, B);
        case "ResourceNotFoundException":
        case "com.amazonaws.sso#ResourceNotFoundException":
          throw await OU4(Q, B);
        case "TooManyRequestsException":
        case "com.amazonaws.sso#TooManyRequestsException":
          throw await TU4(Q, B);
        case "UnauthorizedException":
        case "com.amazonaws.sso#UnauthorizedException":
          throw await PU4(Q, B);
        default:
          let G = Q.body;
          return LU4({
            output: A,
            parsedBody: G,
            errorCode: I
          })
      }
    }, "de_CommandError"),
    LU4 = f2.withBaseException(bb),
    RU4 = j6(async (A, B) => {
      let Q = f2.map({}),
        I = A.body,
        G = f2.take(I, {
          message: f2.expectString
        });
      Object.assign(Q, G);
      let Z = new k90({
        $metadata: mL(A),
        ...Q
      });
      return f2.decorateServiceException(Z, A.body)
    }, "de_InvalidRequestExceptionRes"),
    OU4 = j6(async (A, B) => {
      let Q = f2.map({}),
        I = A.body,
        G = f2.take(I, {
          message: f2.expectString
        });
      Object.assign(Q, G);
      let Z = new x90({
        $metadata: mL(A),
        ...Q
      });
      return f2.decorateServiceException(Z, A.body)
    }, "de_ResourceNotFoundExceptionRes"),
    TU4 = j6(async (A, B) => {
      let Q = f2.map({}),
        I = A.body,
        G = f2.take(I, {
          message: f2.expectString
        });
      Object.assign(Q, G);
      let Z = new f90({
        $metadata: mL(A),
        ...Q
      });
      return f2.decorateServiceException(Z, A.body)
    }, "de_TooManyRequestsExceptionRes"),
    PU4 = j6(async (A, B) => {
      let Q = f2.map({}),
        I = A.body,
        G = f2.take(I, {
          message: f2.expectString
        });
      Object.assign(Q, G);
      let Z = new v90({
        $metadata: mL(A),
        ...Q
      });
      return f2.decorateServiceException(Z, A.body)
    }, "de_UnauthorizedExceptionRes"),
    mL = j6((A) => ({
      httpStatusCode: A.statusCode,
      requestId: A.headers["x-amzn-requestid"] ?? A.headers["x-amzn-request-id"] ?? A.headers["x-amz-request-id"],
      extendedRequestId: A.headers["x-amz-id-2"],
      cfId: A.headers["x-amz-cf-id"]
    }), "deserializeMetadata"),
    p90 = "accountId",
    MI1 = "accessToken",
    c90 = "account_id",
    l90 = "maxResults",
    i90 = "max_result",
    n90 = "nextToken",
    a90 = "next_token",
    SU4 = "roleName",
    _U4 = "role_name",
    LI1 = "x-amz-sso_bearer_token",
    s90 = class extends f2.Command.classBuilder().ep(UI1).m(function(A, B, Q, I) {
      return [$I1.getSerdePlugin(Q, this.serialize, this.deserialize), La.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("SWBPortalService", "GetRoleCredentials", {}).n("SSOClient", "GetRoleCredentialsCommand").f(b90, h90).ser(zU4).de(NU4).build() {
      static {
        j6(this, "GetRoleCredentialsCommand")
      }
    },
    Wk1 = class extends f2.Command.classBuilder().ep(UI1).m(function(A, B, Q, I) {
      return [$I1.getSerdePlugin(Q, this.serialize, this.deserialize), La.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("SWBPortalService", "ListAccountRoles", {}).n("SSOClient", "ListAccountRolesCommand").f(m90, void 0).ser(wU4).de($U4).build() {
      static {
        j6(this, "ListAccountRolesCommand")
      }
    },
    Jk1 = class extends f2.Command.classBuilder().ep(UI1).m(function(A, B, Q, I) {
      return [$I1.getSerdePlugin(Q, this.serialize, this.deserialize), La.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("SWBPortalService", "ListAccounts", {}).n("SSOClient", "ListAccountsCommand").f(d90, void 0).ser(EU4).de(qU4).build() {
      static {
        j6(this, "ListAccountsCommand")
      }
    },
    r90 = class extends f2.Command.classBuilder().ep(UI1).m(function(A, B, Q, I) {
      return [$I1.getSerdePlugin(Q, this.serialize, this.deserialize), La.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("SWBPortalService", "Logout", {}).n("SSOClient", "LogoutCommand").f(u90, void 0).ser(UU4).de(MU4).build() {
      static {
        j6(this, "LogoutCommand")
      }
    },
    jU4 = {
      GetRoleCredentialsCommand: s90,
      ListAccountRolesCommand: Wk1,
      ListAccountsCommand: Jk1,
      LogoutCommand: r90
    },
    o90 = class extends NI1 {
      static {
        j6(this, "SSO")
      }
    };
  f2.createAggregatedClient(jU4, o90);
  var yU4 = CN.createPaginator(NI1, Wk1, "nextToken", "nextToken", "maxResults"),
    kU4 = CN.createPaginator(NI1, Jk1, "nextToken", "nextToken", "maxResults")
})
// @from(Start 3626697, End 3629480)
Fk1 = z((jG8, W40) => {
  var {
    defineProperty: RI1,
    getOwnPropertyDescriptor: xU4,
    getOwnPropertyNames: fU4
  } = Object, vU4 = Object.prototype.hasOwnProperty, OI1 = (A, B) => RI1(A, "name", {
    value: B,
    configurable: !0
  }), bU4 = (A, B) => {
    for (var Q in B) RI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, gU4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of fU4(B))
        if (!vU4.call(A, G) && G !== Q) RI1(A, G, {
          get: () => B[G],
          enumerable: !(I = xU4(B, G)) || I.enumerable
        })
    }
    return A
  }, hU4 = (A) => gU4(RI1({}, "__esModule", {
    value: !0
  }), A), A40 = {};
  bU4(A40, {
    AlgorithmId: () => G40,
    EndpointURLScheme: () => I40,
    FieldPosition: () => Z40,
    HttpApiKeyAuthLocation: () => Q40,
    HttpAuthLocation: () => B40,
    IniSectionType: () => D40,
    RequestHandlerProtocol: () => Y40,
    SMITHY_CONTEXT_KEY: () => cU4,
    getDefaultClientConfiguration: () => uU4,
    resolveDefaultRuntimeConfig: () => pU4
  });
  W40.exports = hU4(A40);
  var B40 = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(B40 || {}),
    Q40 = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(Q40 || {}),
    I40 = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(I40 || {}),
    G40 = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(G40 || {}),
    mU4 = OI1((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    dU4 = OI1((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    uU4 = OI1((A) => {
      return mU4(A)
    }, "getDefaultClientConfiguration"),
    pU4 = OI1((A) => {
      return dU4(A)
    }, "resolveDefaultRuntimeConfig"),
    Z40 = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(Z40 || {}),
    cU4 = "__smithy_context",
    D40 = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(D40 || {}),
    Y40 = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(Y40 || {})
})
// @from(Start 3629486, End 3658023)
p3 = z((yG8, O40) => {
  var {
    defineProperty: SI1,
    getOwnPropertyDescriptor: lU4,
    getOwnPropertyNames: iU4
  } = Object, nU4 = Object.prototype.hasOwnProperty, A2 = (A, B) => SI1(A, "name", {
    value: B,
    configurable: !0
  }), aU4 = (A, B) => {
    for (var Q in B) SI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, sU4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of iU4(B))
        if (!nU4.call(A, G) && G !== Q) SI1(A, G, {
          get: () => B[G],
          enumerable: !(I = lU4(B, G)) || I.enumerable
        })
    }
    return A
  }, rU4 = (A) => sU4(SI1({}, "__esModule", {
    value: !0
  }), A), F40 = {};
  aU4(F40, {
    Client: () => oU4,
    Command: () => V40,
    LazyJsonString: () => J_,
    NoOpLogger: () => nN4,
    SENSITIVE_STRING: () => eU4,
    ServiceException: () => xN4,
    _json: () => wk1,
    collectBody: () => Xk1.collectBody,
    convertMap: () => aN4,
    createAggregatedClient: () => AN4,
    dateToUtcString: () => E40,
    decorateServiceException: () => U40,
    emitWarningIfUnsupportedVersion: () => gN4,
    expectBoolean: () => QN4,
    expectByte: () => zk1,
    expectFloat32: () => TI1,
    expectInt: () => GN4,
    expectInt32: () => Kk1,
    expectLong: () => Ta,
    expectNonNull: () => DN4,
    expectNumber: () => Oa,
    expectObject: () => C40,
    expectShort: () => Hk1,
    expectString: () => YN4,
    expectUnion: () => WN4,
    extendedEncodeURIComponent: () => Xk1.extendedEncodeURIComponent,
    getArrayIfSingleItem: () => lN4,
    getDefaultClientConfiguration: () => pN4,
    getDefaultExtensionConfiguration: () => $40,
    getValueFromTextNode: () => q40,
    handleFloat: () => XN4,
    isSerializableHeaderValue: () => iN4,
    limitedParseDouble: () => Nk1,
    limitedParseFloat: () => VN4,
    limitedParseFloat32: () => CN4,
    loadConfigsForDefaultMode: () => bN4,
    logger: () => Pa,
    map: () => qk1,
    parseBoolean: () => BN4,
    parseEpochTimestamp: () => RN4,
    parseRfc3339DateTime: () => EN4,
    parseRfc3339DateTimeWithOffset: () => NN4,
    parseRfc7231DateTime: () => LN4,
    quoteHeader: () => L40,
    resolveDefaultRuntimeConfig: () => cN4,
    resolvedPath: () => Xk1.resolvedPath,
    serializeDateTime: () => A$4,
    serializeFloat: () => eN4,
    splitEvery: () => R40,
    splitHeader: () => B$4,
    strictParseByte: () => w40,
    strictParseDouble: () => Uk1,
    strictParseFloat: () => JN4,
    strictParseFloat32: () => K40,
    strictParseInt: () => KN4,
    strictParseInt32: () => HN4,
    strictParseLong: () => z40,
    strictParseShort: () => gb,
    take: () => sN4,
    throwDefaultError: () => N40,
    withBaseException: () => fN4
  });
  O40.exports = rU4(F40);
  var X40 = WN(),
    oU4 = class {
      constructor(A) {
        this.config = A, this.middlewareStack = X40.constructStack()
      }
      static {
        A2(this, "Client")
      }
      send(A, B, Q) {
        let I = typeof B !== "function" ? B : void 0,
          G = typeof B === "function" ? B : Q,
          Z = I === void 0 && this.config.cacheMiddleware === !0,
          D;
        if (Z) {
          if (!this.handlers) this.handlers = new WeakMap;
          let Y = this.handlers;
          if (Y.has(A.constructor)) D = Y.get(A.constructor);
          else D = A.resolveMiddleware(this.middlewareStack, this.config, I), Y.set(A.constructor, D)
        } else delete this.handlers, D = A.resolveMiddleware(this.middlewareStack, this.config, I);
        if (G) D(A).then((Y) => G(null, Y.output), (Y) => G(Y)).catch(() => {});
        else return D(A).then((Y) => Y.output)
      }
      destroy() {
        this.config?.requestHandler?.destroy?.(), delete this.handlers
      }
    },
    Xk1 = vz(),
    Ck1 = Fk1(),
    V40 = class {
      constructor() {
        this.middlewareStack = X40.constructStack()
      }
      static {
        A2(this, "Command")
      }
      static classBuilder() {
        return new tU4
      }
      resolveMiddlewareWithContext(A, B, Q, {
        middlewareFn: I,
        clientName: G,
        commandName: Z,
        inputFilterSensitiveLog: D,
        outputFilterSensitiveLog: Y,
        smithyContext: W,
        additionalContext: J,
        CommandCtor: F
      }) {
        for (let E of I.bind(this)(F, A, B, Q)) this.middlewareStack.use(E);
        let X = A.concat(this.middlewareStack),
          {
            logger: V
          } = B,
          C = {
            logger: V,
            clientName: G,
            commandName: Z,
            inputFilterSensitiveLog: D,
            outputFilterSensitiveLog: Y,
            [Ck1.SMITHY_CONTEXT_KEY]: {
              commandInstance: this,
              ...W
            },
            ...J
          },
          {
            requestHandler: K
          } = B;
        return X.resolve((E) => K.handle(E.request, Q || {}), C)
      }
    },
    tU4 = class {
      constructor() {
        this._init = () => {}, this._ep = {}, this._middlewareFn = () => [], this._commandName = "", this._clientName = "", this._additionalContext = {}, this._smithyContext = {}, this._inputFilterSensitiveLog = (A) => A, this._outputFilterSensitiveLog = (A) => A, this._serializer = null, this._deserializer = null
      }
      static {
        A2(this, "ClassBuilder")
      }
      init(A) {
        this._init = A
      }
      ep(A) {
        return this._ep = A, this
      }
      m(A) {
        return this._middlewareFn = A, this
      }
      s(A, B, Q = {}) {
        return this._smithyContext = {
          service: A,
          operation: B,
          ...Q
        }, this
      }
      c(A = {}) {
        return this._additionalContext = A, this
      }
      n(A, B) {
        return this._clientName = A, this._commandName = B, this
      }
      f(A = (Q) => Q, B = (Q) => Q) {
        return this._inputFilterSensitiveLog = A, this._outputFilterSensitiveLog = B, this
      }
      ser(A) {
        return this._serializer = A, this
      }
      de(A) {
        return this._deserializer = A, this
      }
      build() {
        let A = this,
          B;
        return B = class extends V40 {
          constructor(...[Q]) {
            super();
            this.serialize = A._serializer, this.deserialize = A._deserializer, this.input = Q ?? {}, A._init(this)
          }
          static {
            A2(this, "CommandRef")
          }
          static getEndpointParameterInstructions() {
            return A._ep
          }
          resolveMiddleware(Q, I, G) {
            return this.resolveMiddlewareWithContext(Q, I, G, {
              CommandCtor: B,
              middlewareFn: A._middlewareFn,
              clientName: A._clientName,
              commandName: A._commandName,
              inputFilterSensitiveLog: A._inputFilterSensitiveLog,
              outputFilterSensitiveLog: A._outputFilterSensitiveLog,
              smithyContext: A._smithyContext,
              additionalContext: A._additionalContext
            })
          }
        }
      }
    },
    eU4 = "***SensitiveInformation***",
    AN4 = A2((A, B) => {
      for (let Q of Object.keys(A)) {
        let I = A[Q],
          G = A2(async function(D, Y, W) {
            let J = new I(D);
            if (typeof Y === "function") this.send(J, Y);
            else if (typeof W === "function") {
              if (typeof Y !== "object") throw new Error(`Expected http options but got ${typeof Y}`);
              this.send(J, Y || {}, W)
            } else return this.send(J, Y)
          }, "methodImpl"),
          Z = (Q[0].toLowerCase() + Q.slice(1)).replace(/Command$/, "");
        B.prototype[Z] = G
      }
    }, "createAggregatedClient"),
    BN4 = A2((A) => {
      switch (A) {
        case "true":
          return !0;
        case "false":
          return !1;
        default:
          throw new Error(`Unable to parse boolean value "${A}"`)
      }
    }, "parseBoolean"),
    QN4 = A2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "number") {
        if (A === 0 || A === 1) Pa.warn(PI1(`Expected boolean, got ${typeof A}: ${A}`));
        if (A === 0) return !1;
        if (A === 1) return !0
      }
      if (typeof A === "string") {
        let B = A.toLowerCase();
        if (B === "false" || B === "true") Pa.warn(PI1(`Expected boolean, got ${typeof A}: ${A}`));
        if (B === "false") return !1;
        if (B === "true") return !0
      }
      if (typeof A === "boolean") return A;
      throw new TypeError(`Expected boolean, got ${typeof A}: ${A}`)
    }, "expectBoolean"),
    Oa = A2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "string") {
        let B = parseFloat(A);
        if (!Number.isNaN(B)) {
          if (String(B) !== String(A)) Pa.warn(PI1(`Expected number but observed string: ${A}`));
          return B
        }
      }
      if (typeof A === "number") return A;
      throw new TypeError(`Expected number, got ${typeof A}: ${A}`)
    }, "expectNumber"),
    IN4 = Math.ceil(340282346638528860000000000000000000000),
    TI1 = A2((A) => {
      let B = Oa(A);
      if (B !== void 0 && !Number.isNaN(B) && B !== 1 / 0 && B !== -1 / 0) {
        if (Math.abs(B) > IN4) throw new TypeError(`Expected 32-bit float, got ${A}`)
      }
      return B
    }, "expectFloat32"),
    Ta = A2((A) => {
      if (A === null || A === void 0) return;
      if (Number.isInteger(A) && !Number.isNaN(A)) return A;
      throw new TypeError(`Expected integer, got ${typeof A}: ${A}`)
    }, "expectLong"),
    GN4 = Ta,
    Kk1 = A2((A) => Ek1(A, 32), "expectInt32"),
    Hk1 = A2((A) => Ek1(A, 16), "expectShort"),
    zk1 = A2((A) => Ek1(A, 8), "expectByte"),
    Ek1 = A2((A, B) => {
      let Q = Ta(A);
      if (Q !== void 0 && ZN4(Q, B) !== Q) throw new TypeError(`Expected ${B}-bit integer, got ${A}`);
      return Q
    }, "expectSizedInt"),
    ZN4 = A2((A, B) => {
      switch (B) {
        case 32:
          return Int32Array.of(A)[0];
        case 16:
          return Int16Array.of(A)[0];
        case 8:
          return Int8Array.of(A)[0]
      }
    }, "castInt"),
    DN4 = A2((A, B) => {
      if (A === null || A === void 0) {
        if (B) throw new TypeError(`Expected a non-null value for ${B}`);
        throw new TypeError("Expected a non-null value")
      }
      return A
    }, "expectNonNull"),
    C40 = A2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "object" && !Array.isArray(A)) return A;
      let B = Array.isArray(A) ? "array" : typeof A;
      throw new TypeError(`Expected object, got ${B}: ${A}`)
    }, "expectObject"),
    YN4 = A2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "string") return A;
      if (["boolean", "number", "bigint"].includes(typeof A)) return Pa.warn(PI1(`Expected string, got ${typeof A}: ${A}`)), String(A);
      throw new TypeError(`Expected string, got ${typeof A}: ${A}`)
    }, "expectString"),
    WN4 = A2((A) => {
      if (A === null || A === void 0) return;
      let B = C40(A),
        Q = Object.entries(B).filter(([, I]) => I != null).map(([I]) => I);
      if (Q.length === 0) throw new TypeError("Unions must have exactly one non-null member. None were found.");
      if (Q.length > 1) throw new TypeError(`Unions must have exactly one non-null member. Keys ${Q} were not null.`);
      return B
    }, "expectUnion"),
    Uk1 = A2((A) => {
      if (typeof A == "string") return Oa(mb(A));
      return Oa(A)
    }, "strictParseDouble"),
    JN4 = Uk1,
    K40 = A2((A) => {
      if (typeof A == "string") return TI1(mb(A));
      return TI1(A)
    }, "strictParseFloat32"),
    FN4 = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g,
    mb = A2((A) => {
      let B = A.match(FN4);
      if (B === null || B[0].length !== A.length) throw new TypeError("Expected real number, got implicit NaN");
      return parseFloat(A)
    }, "parseNumber"),
    Nk1 = A2((A) => {
      if (typeof A == "string") return H40(A);
      return Oa(A)
    }, "limitedParseDouble"),
    XN4 = Nk1,
    VN4 = Nk1,
    CN4 = A2((A) => {
      if (typeof A == "string") return H40(A);
      return TI1(A)
    }, "limitedParseFloat32"),
    H40 = A2((A) => {
      switch (A) {
        case "NaN":
          return NaN;
        case "Infinity":
          return 1 / 0;
        case "-Infinity":
          return -1 / 0;
        default:
          throw new Error(`Unable to parse float value: ${A}`)
      }
    }, "parseFloatString"),
    z40 = A2((A) => {
      if (typeof A === "string") return Ta(mb(A));
      return Ta(A)
    }, "strictParseLong"),
    KN4 = z40,
    HN4 = A2((A) => {
      if (typeof A === "string") return Kk1(mb(A));
      return Kk1(A)
    }, "strictParseInt32"),
    gb = A2((A) => {
      if (typeof A === "string") return Hk1(mb(A));
      return Hk1(A)
    }, "strictParseShort"),
    w40 = A2((A) => {
      if (typeof A === "string") return zk1(mb(A));
      return zk1(A)
    }, "strictParseByte"),
    PI1 = A2((A) => {
      return String(new TypeError(A).stack || A).split(`
`).slice(0, 5).filter((B) => !B.includes("stackTraceWarning")).join(`
`)
    }, "stackTraceWarning"),
    Pa = {
      warn: console.warn
    },
    zN4 = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
    $k1 = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];

  function E40(A) {
    let B = A.getUTCFullYear(),
      Q = A.getUTCMonth(),
      I = A.getUTCDay(),
      G = A.getUTCDate(),
      Z = A.getUTCHours(),
      D = A.getUTCMinutes(),
      Y = A.getUTCSeconds(),
      W = G < 10 ? `0${G}` : `${G}`,
      J = Z < 10 ? `0${Z}` : `${Z}`,
      F = D < 10 ? `0${D}` : `${D}`,
      X = Y < 10 ? `0${Y}` : `${Y}`;
    return `${zN4[I]}, ${W} ${$k1[Q]} ${B} ${J}:${F}:${X} GMT`
  }
  A2(E40, "dateToUtcString");
  var wN4 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/),
    EN4 = A2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-3339 date-times must be expressed as strings");
      let B = wN4.exec(A);
      if (!B) throw new TypeError("Invalid RFC-3339 date-time value");
      let [Q, I, G, Z, D, Y, W, J] = B, F = gb(hb(I)), X = lz(G, "month", 1, 12), V = lz(Z, "day", 1, 31);
      return Ra(F, X, V, {
        hours: D,
        minutes: Y,
        seconds: W,
        fractionalMilliseconds: J
      })
    }, "parseRfc3339DateTime"),
    UN4 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/),
    NN4 = A2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-3339 date-times must be expressed as strings");
      let B = UN4.exec(A);
      if (!B) throw new TypeError("Invalid RFC-3339 date-time value");
      let [Q, I, G, Z, D, Y, W, J, F] = B, X = gb(hb(I)), V = lz(G, "month", 1, 12), C = lz(Z, "day", 1, 31), K = Ra(X, V, C, {
        hours: D,
        minutes: Y,
        seconds: W,
        fractionalMilliseconds: J
      });
      if (F.toUpperCase() != "Z") K.setTime(K.getTime() - kN4(F));
      return K
    }, "parseRfc3339DateTimeWithOffset"),
    $N4 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/),
    qN4 = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/),
    MN4 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/),
    LN4 = A2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-7231 date-times must be expressed as strings");
      let B = $N4.exec(A);
      if (B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return Ra(gb(hb(Z)), Vk1(G), lz(I, "day", 1, 31), {
          hours: D,
          minutes: Y,
          seconds: W,
          fractionalMilliseconds: J
        })
      }
      if (B = qN4.exec(A), B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return PN4(Ra(ON4(Z), Vk1(G), lz(I, "day", 1, 31), {
          hours: D,
          minutes: Y,
          seconds: W,
          fractionalMilliseconds: J
        }))
      }
      if (B = MN4.exec(A), B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return Ra(gb(hb(J)), Vk1(I), lz(G.trimLeft(), "day", 1, 31), {
          hours: Z,
          minutes: D,
          seconds: Y,
          fractionalMilliseconds: W
        })
      }
      throw new TypeError("Invalid RFC-7231 date-time value")
    }, "parseRfc7231DateTime"),
    RN4 = A2((A) => {
      if (A === null || A === void 0) return;
      let B;
      if (typeof A === "number") B = A;
      else if (typeof A === "string") B = Uk1(A);
      else if (typeof A === "object" && A.tag === 1) B = A.value;
      else throw new TypeError("Epoch timestamps must be expressed as floating point numbers or their string representation");
      if (Number.isNaN(B) || B === 1 / 0 || B === -1 / 0) throw new TypeError("Epoch timestamps must be valid, non-Infinite, non-NaN numerics");
      return new Date(Math.round(B * 1000))
    }, "parseEpochTimestamp"),
    Ra = A2((A, B, Q, I) => {
      let G = B - 1;
      return _N4(A, G, Q), new Date(Date.UTC(A, G, Q, lz(I.hours, "hour", 0, 23), lz(I.minutes, "minute", 0, 59), lz(I.seconds, "seconds", 0, 60), yN4(I.fractionalMilliseconds)))
    }, "buildDate"),
    ON4 = A2((A) => {
      let B = new Date().getUTCFullYear(),
        Q = Math.floor(B / 100) * 100 + gb(hb(A));
      if (Q < B) return Q + 100;
      return Q
    }, "parseTwoDigitYear"),
    TN4 = 1576800000000,
    PN4 = A2((A) => {
      if (A.getTime() - new Date().getTime() > TN4) return new Date(Date.UTC(A.getUTCFullYear() - 100, A.getUTCMonth(), A.getUTCDate(), A.getUTCHours(), A.getUTCMinutes(), A.getUTCSeconds(), A.getUTCMilliseconds()));
      return A
    }, "adjustRfc850Year"),
    Vk1 = A2((A) => {
      let B = $k1.indexOf(A);
      if (B < 0) throw new TypeError(`Invalid month: ${A}`);
      return B + 1
    }, "parseMonthByShortName"),
    SN4 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
    _N4 = A2((A, B, Q) => {
      let I = SN4[B];
      if (B === 1 && jN4(A)) I = 29;
      if (Q > I) throw new TypeError(`Invalid day for ${$k1[B]} in ${A}: ${Q}`)
    }, "validateDayOfMonth"),
    jN4 = A2((A) => {
      return A % 4 === 0 && (A % 100 !== 0 || A % 400 === 0)
    }, "isLeapYear"),
    lz = A2((A, B, Q, I) => {
      let G = w40(hb(A));
      if (G < Q || G > I) throw new TypeError(`${B} must be between ${Q} and ${I}, inclusive`);
      return G
    }, "parseDateValue"),
    yN4 = A2((A) => {
      if (A === null || A === void 0) return 0;
      return K40("0." + A) * 1000
    }, "parseMilliseconds"),
    kN4 = A2((A) => {
      let B = A[0],
        Q = 1;
      if (B == "+") Q = 1;
      else if (B == "-") Q = -1;
      else throw new TypeError(`Offset direction, ${B}, must be "+" or "-"`);
      let I = Number(A.substring(1, 3)),
        G = Number(A.substring(4, 6));
      return Q * (I * 60 + G) * 60 * 1000
    }, "parseOffsetToMilliseconds"),
    hb = A2((A) => {
      let B = 0;
      while (B < A.length - 1 && A.charAt(B) === "0") B++;
      if (B === 0) return A;
      return A.slice(B)
    }, "stripLeadingZeroes"),
    xN4 = class A extends Error {
      static {
        A2(this, "ServiceException")
      }
      constructor(B) {
        super(B.message);
        Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype), this.name = B.name, this.$fault = B.$fault, this.$metadata = B.$metadata
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return A.prototype.isPrototypeOf(Q) || Boolean(Q.$fault) && Boolean(Q.$metadata) && (Q.$fault === "client" || Q.$fault === "server")
      }
      static[Symbol.hasInstance](B) {
        if (!B) return !1;
        let Q = B;
        if (this === A) return A.isInstance(B);
        if (A.isInstance(B)) {
          if (Q.name && this.name) return this.prototype.isPrototypeOf(B) || Q.name === this.name;
          return this.prototype.isPrototypeOf(B)
        }
        return !1
      }
    },
    U40 = A2((A, B = {}) => {
      Object.entries(B).filter(([, I]) => I !== void 0).forEach(([I, G]) => {
        if (A[I] == null || A[I] === "") A[I] = G
      });
      let Q = A.message || A.Message || "UnknownError";
      return A.message = Q, delete A.Message, A
    }, "decorateServiceException"),
    N40 = A2(({
      output: A,
      parsedBody: B,
      exceptionCtor: Q,
      errorCode: I
    }) => {
      let G = vN4(A),
        Z = G.httpStatusCode ? G.httpStatusCode + "" : void 0,
        D = new Q({
          name: B?.code || B?.Code || I || Z || "UnknownError",
          $fault: "client",
          $metadata: G
        });
      throw U40(D, B)
    }, "throwDefaultError"),
    fN4 = A2((A) => {
      return ({
        output: B,
        parsedBody: Q,
        errorCode: I
      }) => {
        N40({
          output: B,
          parsedBody: Q,
          exceptionCtor: A,
          errorCode: I
        })
      }
    }, "withBaseException"),
    vN4 = A2((A) => ({
      httpStatusCode: A.statusCode,
      requestId: A.headers["x-amzn-requestid"] ?? A.headers["x-amzn-request-id"] ?? A.headers["x-amz-request-id"],
      extendedRequestId: A.headers["x-amz-id-2"],
      cfId: A.headers["x-amz-cf-id"]
    }), "deserializeMetadata"),
    bN4 = A2((A) => {
      switch (A) {
        case "standard":
          return {
            retryMode: "standard", connectionTimeout: 3100
          };
        case "in-region":
          return {
            retryMode: "standard", connectionTimeout: 1100
          };
        case "cross-region":
          return {
            retryMode: "standard", connectionTimeout: 3100
          };
        case "mobile":
          return {
            retryMode: "standard", connectionTimeout: 30000
          };
        default:
          return {}
      }
    }, "loadConfigsForDefaultMode"),
    J40 = !1,
    gN4 = A2((A) => {
      if (A && !J40 && parseInt(A.substring(1, A.indexOf("."))) < 16) J40 = !0
    }, "emitWarningIfUnsupportedVersion"),
    hN4 = A2((A) => {
      let B = [];
      for (let Q in Ck1.AlgorithmId) {
        let I = Ck1.AlgorithmId[Q];
        if (A[I] === void 0) continue;
        B.push({
          algorithmId: () => I,
          checksumConstructor: () => A[I]
        })
      }
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    mN4 = A2((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    dN4 = A2((A) => {
      return {
        setRetryStrategy(B) {
          A.retryStrategy = B
        },
        retryStrategy() {
          return A.retryStrategy
        }
      }
    }, "getRetryConfiguration"),
    uN4 = A2((A) => {
      let B = {};
      return B.retryStrategy = A.retryStrategy(), B
    }, "resolveRetryRuntimeConfig"),
    $40 = A2((A) => {
      return Object.assign(hN4(A), dN4(A))
    }, "getDefaultExtensionConfiguration"),
    pN4 = $40,
    cN4 = A2((A) => {
      return Object.assign(mN4(A), uN4(A))
    }, "resolveDefaultRuntimeConfig"),
    lN4 = A2((A) => Array.isArray(A) ? A : [A], "getArrayIfSingleItem"),
    q40 = A2((A) => {
      for (let Q in A)
        if (A.hasOwnProperty(Q) && A[Q]["#text"] !== void 0) A[Q] = A[Q]["#text"];
        else if (typeof A[Q] === "object" && A[Q] !== null) A[Q] = q40(A[Q]);
      return A
    }, "getValueFromTextNode"),
    iN4 = A2((A) => {
      return A != null
    }, "isSerializableHeaderValue"),
    J_ = A2(function A(B) {
      return Object.assign(new String(B), {
        deserializeJSON() {
          return JSON.parse(String(B))
        },
        toString() {
          return String(B)
        },
        toJSON() {
          return String(B)
        }
      })
    }, "LazyJsonString");
  J_.from = (A) => {
    if (A && typeof A === "object" && (A instanceof J_ || ("deserializeJSON" in A))) return A;
    else if (typeof A === "string" || Object.getPrototypeOf(A) === String.prototype) return J_(String(A));
    return J_(JSON.stringify(A))
  };
  J_.fromObject = J_.from;
  var nN4 = class {
    static {
      A2(this, "NoOpLogger")
    }
    trace() {}
    debug() {}
    info() {}
    warn() {}
    error() {}
  };

  function qk1(A, B, Q) {
    let I, G, Z;
    if (typeof B === "undefined" && typeof Q === "undefined") I = {}, Z = A;
    else if (I = A, typeof B === "function") return G = B, Z = Q, rN4(I, G, Z);
    else Z = B;
    for (let D of Object.keys(Z)) {
      if (!Array.isArray(Z[D])) {
        I[D] = Z[D];
        continue
      }
      M40(I, null, Z, D)
    }
    return I
  }
  A2(qk1, "map");
  var aN4 = A2((A) => {
      let B = {};
      for (let [Q, I] of Object.entries(A || {})) B[Q] = [, I];
      return B
    }, "convertMap"),
    sN4 = A2((A, B) => {
      let Q = {};
      for (let I in B) M40(Q, A, B, I);
      return Q
    }, "take"),
    rN4 = A2((A, B, Q) => {
      return qk1(A, Object.entries(Q).reduce((I, [G, Z]) => {
        if (Array.isArray(Z)) I[G] = Z;
        else if (typeof Z === "function") I[G] = [B, Z()];
        else I[G] = [B, Z];
        return I
      }, {}))
    }, "mapWithFilter"),
    M40 = A2((A, B, Q, I) => {
      if (B !== null) {
        let D = Q[I];
        if (typeof D === "function") D = [, D];
        let [Y = oN4, W = tN4, J = I] = D;
        if (typeof Y === "function" && Y(B[J]) || typeof Y !== "function" && !!Y) A[I] = W(B[J]);
        return
      }
      let [G, Z] = Q[I];
      if (typeof Z === "function") {
        let D, Y = G === void 0 && (D = Z()) != null,
          W = typeof G === "function" && !!G(void 0) || typeof G !== "function" && !!G;
        if (Y) A[I] = D;
        else if (W) A[I] = Z()
      } else {
        let D = G === void 0 && Z != null,
          Y = typeof G === "function" && !!G(Z) || typeof G !== "function" && !!G;
        if (D || Y) A[I] = Z
      }
    }, "applyInstruction"),
    oN4 = A2((A) => A != null, "nonNullish"),
    tN4 = A2((A) => A, "pass");

  function L40(A) {
    if (A.includes(",") || A.includes('"')) A = `"${A.replace(/"/g,"\\\"")}"`;
    return A
  }
  A2(L40, "quoteHeader");
  var eN4 = A2((A) => {
      if (A !== A) return "NaN";
      switch (A) {
        case 1 / 0:
          return "Infinity";
        case -1 / 0:
          return "-Infinity";
        default:
          return A
      }
    }, "serializeFloat"),
    A$4 = A2((A) => A.toISOString().replace(".000Z", "Z"), "serializeDateTime"),
    wk1 = A2((A) => {
      if (A == null) return {};
      if (Array.isArray(A)) return A.filter((B) => B != null).map(wk1);
      if (typeof A === "object") {
        let B = {};
        for (let Q of Object.keys(A)) {
          if (A[Q] == null) continue;
          B[Q] = wk1(A[Q])
        }
        return B
      }
      return A
    }, "_json");

  function R40(A, B, Q) {
    if (Q <= 0 || !Number.isInteger(Q)) throw new Error("Invalid number of delimiters (" + Q + ") for splitEvery.");
    let I = A.split(B);
    if (Q === 1) return I;
    let G = [],
      Z = "";
    for (let D = 0; D < I.length; D++) {
      if (Z === "") Z = I[D];
      else Z += B + I[D];
      if ((D + 1) % Q === 0) G.push(Z), Z = ""
    }
    if (Z !== "") G.push(Z);
    return G
  }
  A2(R40, "splitEvery");
  var B$4 = A2((A) => {
    let B = A.length,
      Q = [],
      I = !1,
      G = void 0,
      Z = 0;
    for (let D = 0; D < B; ++D) {
      let Y = A[D];
      switch (Y) {
        case '"':
          if (G !== "\\") I = !I;
          break;
        case ",":
          if (!I) Q.push(A.slice(Z, D)), Z = D + 1;
          break;
        default:
      }
      G = Y
    }
    return Q.push(A.slice(Z)), Q.map((D) => {
      D = D.trim();
      let Y = D.length;
      if (Y < 2) return D;
      if (D[0] === '"' && D[Y - 1] === '"') D = D.slice(1, Y - 1);
      return D.replace(/\\"/g, '"')
    })
  }, "splitHeader")
})
// @from(Start 3658029, End 3659484)
Lk1 = z((T40) => {
  Object.defineProperty(T40, "__esModule", {
    value: !0
  });
  T40.resolveHttpAuthSchemeConfig = T40.defaultSSOOIDCHttpAuthSchemeProvider = T40.defaultSSOOIDCHttpAuthSchemeParametersProvider = void 0;
  var Q$4 = IB(),
    Mk1 = ZX(),
    I$4 = async (A, B, Q) => {
      return {
        operation: Mk1.getSmithyContext(B).operation,
        region: await Mk1.normalizeProvider(A.region)() || (() => {
          throw new Error("expected `region` to be configured for `aws.auth#sigv4`")
        })()
      }
    };
  T40.defaultSSOOIDCHttpAuthSchemeParametersProvider = I$4;

  function G$4(A) {
    return {
      schemeId: "aws.auth#sigv4",
      signingProperties: {
        name: "sso-oauth",
        region: A.region
      },
      propertiesExtractor: (B, Q) => ({
        signingProperties: {
          config: B,
          context: Q
        }
      })
    }
  }

  function Z$4(A) {
    return {
      schemeId: "smithy.api#noAuth"
    }
  }
  var D$4 = (A) => {
    let B = [];
    switch (A.operation) {
      case "CreateToken": {
        B.push(Z$4(A));
        break
      }
      default:
        B.push(G$4(A))
    }
    return B
  };
  T40.defaultSSOOIDCHttpAuthSchemeProvider = D$4;
  var Y$4 = (A) => {
    let B = Q$4.resolveAwsSdkSigV4Config(A);
    return Object.assign(B, {
      authSchemePreference: Mk1.normalizeProvider(A.authSchemePreference ?? [])
    })
  };
  T40.resolveHttpAuthSchemeConfig = Y$4
})
// @from(Start 3659490, End 3676810)
Ok1 = z((hG8, yI1) => {
  var S40, _40, j40, y40, k40, x40, f40, v40, b40, g40, h40, m40, d40, _I1, Rk1, u40, p40, c40, db, l40, i40, n40, a40, s40, r40, o40, t40, e40, jI1, A60, B60, Q60;
  (function(A) {
    var B = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
    if (typeof define === "function" && define.amd) define("tslib", ["exports"], function(I) {
      A(Q(B, Q(I)))
    });
    else if (typeof yI1 === "object" && typeof hG8 === "object") A(Q(B, Q(hG8)));
    else A(Q(B));

    function Q(I, G) {
      if (I !== B)
        if (typeof Object.create === "function") Object.defineProperty(I, "__esModule", {
          value: !0
        });
        else I.__esModule = !0;
      return function(Z, D) {
        return I[Z] = G ? G(Z, D) : D
      }
    }
  })(function(A) {
    var B = Object.setPrototypeOf || {
      __proto__: []
    }
    instanceof Array && function(Z, D) {
      Z.__proto__ = D
    } || function(Z, D) {
      for (var Y in D)
        if (Object.prototype.hasOwnProperty.call(D, Y)) Z[Y] = D[Y]
    };
    S40 = function(Z, D) {
      if (typeof D !== "function" && D !== null) throw new TypeError("Class extends value " + String(D) + " is not a constructor or null");
      B(Z, D);

      function Y() {
        this.constructor = Z
      }
      Z.prototype = D === null ? Object.create(D) : (Y.prototype = D.prototype, new Y)
    }, _40 = Object.assign || function(Z) {
      for (var D, Y = 1, W = arguments.length; Y < W; Y++) {
        D = arguments[Y];
        for (var J in D)
          if (Object.prototype.hasOwnProperty.call(D, J)) Z[J] = D[J]
      }
      return Z
    }, j40 = function(Z, D) {
      var Y = {};
      for (var W in Z)
        if (Object.prototype.hasOwnProperty.call(Z, W) && D.indexOf(W) < 0) Y[W] = Z[W];
      if (Z != null && typeof Object.getOwnPropertySymbols === "function") {
        for (var J = 0, W = Object.getOwnPropertySymbols(Z); J < W.length; J++)
          if (D.indexOf(W[J]) < 0 && Object.prototype.propertyIsEnumerable.call(Z, W[J])) Y[W[J]] = Z[W[J]]
      }
      return Y
    }, y40 = function(Z, D, Y, W) {
      var J = arguments.length,
        F = J < 3 ? D : W === null ? W = Object.getOwnPropertyDescriptor(D, Y) : W,
        X;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") F = Reflect.decorate(Z, D, Y, W);
      else
        for (var V = Z.length - 1; V >= 0; V--)
          if (X = Z[V]) F = (J < 3 ? X(F) : J > 3 ? X(D, Y, F) : X(D, Y)) || F;
      return J > 3 && F && Object.defineProperty(D, Y, F), F
    }, k40 = function(Z, D) {
      return function(Y, W) {
        D(Y, W, Z)
      }
    }, x40 = function(Z, D, Y, W, J, F) {
      function X(_) {
        if (_ !== void 0 && typeof _ !== "function") throw new TypeError("Function expected");
        return _
      }
      var V = W.kind,
        C = V === "getter" ? "get" : V === "setter" ? "set" : "value",
        K = !D && Z ? W.static ? Z : Z.prototype : null,
        E = D || (K ? Object.getOwnPropertyDescriptor(K, W.name) : {}),
        N, q = !1;
      for (var O = Y.length - 1; O >= 0; O--) {
        var R = {};
        for (var T in W) R[T] = T === "access" ? {} : W[T];
        for (var T in W.access) R.access[T] = W.access[T];
        R.addInitializer = function(_) {
          if (q) throw new TypeError("Cannot add initializers after decoration has completed");
          F.push(X(_ || null))
        };
        var L = Y[O](V === "accessor" ? {
          get: E.get,
          set: E.set
        } : E[C], R);
        if (V === "accessor") {
          if (L === void 0) continue;
          if (L === null || typeof L !== "object") throw new TypeError("Object expected");
          if (N = X(L.get)) E.get = N;
          if (N = X(L.set)) E.set = N;
          if (N = X(L.init)) J.unshift(N)
        } else if (N = X(L))
          if (V === "field") J.unshift(N);
          else E[C] = N
      }
      if (K) Object.defineProperty(K, W.name, E);
      q = !0
    }, f40 = function(Z, D, Y) {
      var W = arguments.length > 2;
      for (var J = 0; J < D.length; J++) Y = W ? D[J].call(Z, Y) : D[J].call(Z);
      return W ? Y : void 0
    }, v40 = function(Z) {
      return typeof Z === "symbol" ? Z : "".concat(Z)
    }, b40 = function(Z, D, Y) {
      if (typeof D === "symbol") D = D.description ? "[".concat(D.description, "]") : "";
      return Object.defineProperty(Z, "name", {
        configurable: !0,
        value: Y ? "".concat(Y, " ", D) : D
      })
    }, g40 = function(Z, D) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(Z, D)
    }, h40 = function(Z, D, Y, W) {
      function J(F) {
        return F instanceof Y ? F : new Y(function(X) {
          X(F)
        })
      }
      return new(Y || (Y = Promise))(function(F, X) {
        function V(E) {
          try {
            K(W.next(E))
          } catch (N) {
            X(N)
          }
        }

        function C(E) {
          try {
            K(W.throw(E))
          } catch (N) {
            X(N)
          }
        }

        function K(E) {
          E.done ? F(E.value) : J(E.value).then(V, C)
        }
        K((W = W.apply(Z, D || [])).next())
      })
    }, m40 = function(Z, D) {
      var Y = {
          label: 0,
          sent: function() {
            if (F[0] & 1) throw F[1];
            return F[1]
          },
          trys: [],
          ops: []
        },
        W, J, F, X = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
      return X.next = V(0), X.throw = V(1), X.return = V(2), typeof Symbol === "function" && (X[Symbol.iterator] = function() {
        return this
      }), X;

      function V(K) {
        return function(E) {
          return C([K, E])
        }
      }

      function C(K) {
        if (W) throw new TypeError("Generator is already executing.");
        while (X && (X = 0, K[0] && (Y = 0)), Y) try {
          if (W = 1, J && (F = K[0] & 2 ? J.return : K[0] ? J.throw || ((F = J.return) && F.call(J), 0) : J.next) && !(F = F.call(J, K[1])).done) return F;
          if (J = 0, F) K = [K[0] & 2, F.value];
          switch (K[0]) {
            case 0:
            case 1:
              F = K;
              break;
            case 4:
              return Y.label++, {
                value: K[1],
                done: !1
              };
            case 5:
              Y.label++, J = K[1], K = [0];
              continue;
            case 7:
              K = Y.ops.pop(), Y.trys.pop();
              continue;
            default:
              if ((F = Y.trys, !(F = F.length > 0 && F[F.length - 1])) && (K[0] === 6 || K[0] === 2)) {
                Y = 0;
                continue
              }
              if (K[0] === 3 && (!F || K[1] > F[0] && K[1] < F[3])) {
                Y.label = K[1];
                break
              }
              if (K[0] === 6 && Y.label < F[1]) {
                Y.label = F[1], F = K;
                break
              }
              if (F && Y.label < F[2]) {
                Y.label = F[2], Y.ops.push(K);
                break
              }
              if (F[2]) Y.ops.pop();
              Y.trys.pop();
              continue
          }
          K = D.call(Z, Y)
        } catch (E) {
          K = [6, E], J = 0
        } finally {
          W = F = 0
        }
        if (K[0] & 5) throw K[1];
        return {
          value: K[0] ? K[1] : void 0,
          done: !0
        }
      }
    }, d40 = function(Z, D) {
      for (var Y in Z)
        if (Y !== "default" && !Object.prototype.hasOwnProperty.call(D, Y)) jI1(D, Z, Y)
    }, jI1 = Object.create ? function(Z, D, Y, W) {
      if (W === void 0) W = Y;
      var J = Object.getOwnPropertyDescriptor(D, Y);
      if (!J || ("get" in J ? !D.__esModule : J.writable || J.configurable)) J = {
        enumerable: !0,
        get: function() {
          return D[Y]
        }
      };
      Object.defineProperty(Z, W, J)
    } : function(Z, D, Y, W) {
      if (W === void 0) W = Y;
      Z[W] = D[Y]
    }, _I1 = function(Z) {
      var D = typeof Symbol === "function" && Symbol.iterator,
        Y = D && Z[D],
        W = 0;
      if (Y) return Y.call(Z);
      if (Z && typeof Z.length === "number") return {
        next: function() {
          if (Z && W >= Z.length) Z = void 0;
          return {
            value: Z && Z[W++],
            done: !Z
          }
        }
      };
      throw new TypeError(D ? "Object is not iterable." : "Symbol.iterator is not defined.")
    }, Rk1 = function(Z, D) {
      var Y = typeof Symbol === "function" && Z[Symbol.iterator];
      if (!Y) return Z;
      var W = Y.call(Z),
        J, F = [],
        X;
      try {
        while ((D === void 0 || D-- > 0) && !(J = W.next()).done) F.push(J.value)
      } catch (V) {
        X = {
          error: V
        }
      } finally {
        try {
          if (J && !J.done && (Y = W.return)) Y.call(W)
        } finally {
          if (X) throw X.error
        }
      }
      return F
    }, u40 = function() {
      for (var Z = [], D = 0; D < arguments.length; D++) Z = Z.concat(Rk1(arguments[D]));
      return Z
    }, p40 = function() {
      for (var Z = 0, D = 0, Y = arguments.length; D < Y; D++) Z += arguments[D].length;
      for (var W = Array(Z), J = 0, D = 0; D < Y; D++)
        for (var F = arguments[D], X = 0, V = F.length; X < V; X++, J++) W[J] = F[X];
      return W
    }, c40 = function(Z, D, Y) {
      if (Y || arguments.length === 2) {
        for (var W = 0, J = D.length, F; W < J; W++)
          if (F || !(W in D)) {
            if (!F) F = Array.prototype.slice.call(D, 0, W);
            F[W] = D[W]
          }
      }
      return Z.concat(F || Array.prototype.slice.call(D))
    }, db = function(Z) {
      return this instanceof db ? (this.v = Z, this) : new db(Z)
    }, l40 = function(Z, D, Y) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var W = Y.apply(Z, D || []),
        J, F = [];
      return J = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), V("next"), V("throw"), V("return", X), J[Symbol.asyncIterator] = function() {
        return this
      }, J;

      function X(O) {
        return function(R) {
          return Promise.resolve(R).then(O, N)
        }
      }

      function V(O, R) {
        if (W[O]) {
          if (J[O] = function(T) {
              return new Promise(function(L, _) {
                F.push([O, T, L, _]) > 1 || C(O, T)
              })
            }, R) J[O] = R(J[O])
        }
      }

      function C(O, R) {
        try {
          K(W[O](R))
        } catch (T) {
          q(F[0][3], T)
        }
      }

      function K(O) {
        O.value instanceof db ? Promise.resolve(O.value.v).then(E, N) : q(F[0][2], O)
      }

      function E(O) {
        C("next", O)
      }

      function N(O) {
        C("throw", O)
      }

      function q(O, R) {
        if (O(R), F.shift(), F.length) C(F[0][0], F[0][1])
      }
    }, i40 = function(Z) {
      var D, Y;
      return D = {}, W("next"), W("throw", function(J) {
        throw J
      }), W("return"), D[Symbol.iterator] = function() {
        return this
      }, D;

      function W(J, F) {
        D[J] = Z[J] ? function(X) {
          return (Y = !Y) ? {
            value: db(Z[J](X)),
            done: !1
          } : F ? F(X) : X
        } : F
      }
    }, n40 = function(Z) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var D = Z[Symbol.asyncIterator],
        Y;
      return D ? D.call(Z) : (Z = typeof _I1 === "function" ? _I1(Z) : Z[Symbol.iterator](), Y = {}, W("next"), W("throw"), W("return"), Y[Symbol.asyncIterator] = function() {
        return this
      }, Y);

      function W(F) {
        Y[F] = Z[F] && function(X) {
          return new Promise(function(V, C) {
            X = Z[F](X), J(V, C, X.done, X.value)
          })
        }
      }

      function J(F, X, V, C) {
        Promise.resolve(C).then(function(K) {
          F({
            value: K,
            done: V
          })
        }, X)
      }
    }, a40 = function(Z, D) {
      if (Object.defineProperty) Object.defineProperty(Z, "raw", {
        value: D
      });
      else Z.raw = D;
      return Z
    };
    var Q = Object.create ? function(Z, D) {
        Object.defineProperty(Z, "default", {
          enumerable: !0,
          value: D
        })
      } : function(Z, D) {
        Z.default = D
      },
      I = function(Z) {
        return I = Object.getOwnPropertyNames || function(D) {
          var Y = [];
          for (var W in D)
            if (Object.prototype.hasOwnProperty.call(D, W)) Y[Y.length] = W;
          return Y
        }, I(Z)
      };
    s40 = function(Z) {
      if (Z && Z.__esModule) return Z;
      var D = {};
      if (Z != null) {
        for (var Y = I(Z), W = 0; W < Y.length; W++)
          if (Y[W] !== "default") jI1(D, Z, Y[W])
      }
      return Q(D, Z), D
    }, r40 = function(Z) {
      return Z && Z.__esModule ? Z : {
        default: Z
      }
    }, o40 = function(Z, D, Y, W) {
      if (Y === "a" && !W) throw new TypeError("Private accessor was defined without a getter");
      if (typeof D === "function" ? Z !== D || !W : !D.has(Z)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
      return Y === "m" ? W : Y === "a" ? W.call(Z) : W ? W.value : D.get(Z)
    }, t40 = function(Z, D, Y, W, J) {
      if (W === "m") throw new TypeError("Private method is not writable");
      if (W === "a" && !J) throw new TypeError("Private accessor was defined without a setter");
      if (typeof D === "function" ? Z !== D || !J : !D.has(Z)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
      return W === "a" ? J.call(Z, Y) : J ? J.value = Y : D.set(Z, Y), Y
    }, e40 = function(Z, D) {
      if (D === null || typeof D !== "object" && typeof D !== "function") throw new TypeError("Cannot use 'in' operator on non-object");
      return typeof Z === "function" ? D === Z : Z.has(D)
    }, A60 = function(Z, D, Y) {
      if (D !== null && D !== void 0) {
        if (typeof D !== "object" && typeof D !== "function") throw new TypeError("Object expected.");
        var W, J;
        if (Y) {
          if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
          W = D[Symbol.asyncDispose]
        }
        if (W === void 0) {
          if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
          if (W = D[Symbol.dispose], Y) J = W
        }
        if (typeof W !== "function") throw new TypeError("Object not disposable.");
        if (J) W = function() {
          try {
            J.call(this)
          } catch (F) {
            return Promise.reject(F)
          }
        };
        Z.stack.push({
          value: D,
          dispose: W,
          async: Y
        })
      } else if (Y) Z.stack.push({
        async: !0
      });
      return D
    };
    var G = typeof SuppressedError === "function" ? SuppressedError : function(Z, D, Y) {
      var W = new Error(Y);
      return W.name = "SuppressedError", W.error = Z, W.suppressed = D, W
    };
    B60 = function(Z) {
      function D(F) {
        Z.error = Z.hasError ? new G(F, Z.error, "An error was suppressed during disposal.") : F, Z.hasError = !0
      }
      var Y, W = 0;

      function J() {
        while (Y = Z.stack.pop()) try {
          if (!Y.async && W === 1) return W = 0, Z.stack.push(Y), Promise.resolve().then(J);
          if (Y.dispose) {
            var F = Y.dispose.call(Y.value);
            if (Y.async) return W |= 2, Promise.resolve(F).then(J, function(X) {
              return D(X), J()
            })
          } else W |= 1
        } catch (X) {
          D(X)
        }
        if (W === 1) return Z.hasError ? Promise.reject(Z.error) : Promise.resolve();
        if (Z.hasError) throw Z.error
      }
      return J()
    }, Q60 = function(Z, D) {
      if (typeof Z === "string" && /^\.\.?\//.test(Z)) return Z.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(Y, W, J, F, X) {
        return W ? D ? ".jsx" : ".js" : J && (!F || !X) ? Y : J + F + "." + X.toLowerCase() + "js"
      });
      return Z
    }, A("__extends", S40), A("__assign", _40), A("__rest", j40), A("__decorate", y40), A("__param", k40), A("__esDecorate", x40), A("__runInitializers", f40), A("__propKey", v40), A("__setFunctionName", b40), A("__metadata", g40), A("__awaiter", h40), A("__generator", m40), A("__exportStar", d40), A("__createBinding", jI1), A("__values", _I1), A("__read", Rk1), A("__spread", u40), A("__spreadArrays", p40), A("__spreadArray", c40), A("__await", db), A("__asyncGenerator", l40), A("__asyncDelegator", i40), A("__asyncValues", n40), A("__makeTemplateObject", a40), A("__importStar", s40), A("__importDefault", r40), A("__classPrivateFieldGet", o40), A("__classPrivateFieldSet", t40), A("__classPrivateFieldIn", e40), A("__addDisposableResource", A60), A("__disposeResources", B60), A("__rewriteRelativeImportExtension", Q60)
  })
})
// @from(Start 3676816, End 3681097)
Tk1 = z((mG8, F$4) => {
  F$4.exports = {
    name: "@aws-sdk/nested-clients",
    version: "3.797.0",
    description: "Nested clients for AWS SDK packages.",
    main: "./dist-cjs/index.js",
    module: "./dist-es/index.js",
    types: "./dist-types/index.d.ts",
    scripts: {
      build: "yarn lint && concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
      "build:cjs": "node ../../scripts/compilation/inline nested-clients",
      "build:es": "tsc -p tsconfig.es.json",
      "build:include:deps": "lerna run --scope $npm_package_name --include-dependencies build",
      "build:types": "tsc -p tsconfig.types.json",
      "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
      clean: "rimraf ./dist-* && rimraf *.tsbuildinfo",
      lint: "node ../../scripts/validation/submodules-linter.js --pkg nested-clients",
      test: "yarn g:vitest run",
      "test:watch": "yarn g:vitest watch"
    },
    engines: {
      node: ">=18.0.0"
    },
    author: {
      name: "AWS SDK for JavaScript Team",
      url: "https://aws.amazon.com/javascript/"
    },
    license: "Apache-2.0",
    dependencies: {
      "@aws-crypto/sha256-browser": "5.2.0",
      "@aws-crypto/sha256-js": "5.2.0",
      "@aws-sdk/core": "3.796.0",
      "@aws-sdk/middleware-host-header": "3.775.0",
      "@aws-sdk/middleware-logger": "3.775.0",
      "@aws-sdk/middleware-recursion-detection": "3.775.0",
      "@aws-sdk/middleware-user-agent": "3.796.0",
      "@aws-sdk/region-config-resolver": "3.775.0",
      "@aws-sdk/types": "3.775.0",
      "@aws-sdk/util-endpoints": "3.787.0",
      "@aws-sdk/util-user-agent-browser": "3.775.0",
      "@aws-sdk/util-user-agent-node": "3.796.0",
      "@smithy/config-resolver": "^4.1.0",
      "@smithy/core": "^3.2.0",
      "@smithy/fetch-http-handler": "^5.0.2",
      "@smithy/hash-node": "^4.0.2",
      "@smithy/invalid-dependency": "^4.0.2",
      "@smithy/middleware-content-length": "^4.0.2",
      "@smithy/middleware-endpoint": "^4.1.0",
      "@smithy/middleware-retry": "^4.1.0",
      "@smithy/middleware-serde": "^4.0.3",
      "@smithy/middleware-stack": "^4.0.2",
      "@smithy/node-config-provider": "^4.0.2",
      "@smithy/node-http-handler": "^4.0.4",
      "@smithy/protocol-http": "^5.1.0",
      "@smithy/smithy-client": "^4.2.0",
      "@smithy/types": "^4.2.0",
      "@smithy/url-parser": "^4.0.2",
      "@smithy/util-base64": "^4.0.0",
      "@smithy/util-body-length-browser": "^4.0.0",
      "@smithy/util-body-length-node": "^4.0.0",
      "@smithy/util-defaults-mode-browser": "^4.0.8",
      "@smithy/util-defaults-mode-node": "^4.0.8",
      "@smithy/util-endpoints": "^3.0.2",
      "@smithy/util-middleware": "^4.0.2",
      "@smithy/util-retry": "^4.0.2",
      "@smithy/util-utf8": "^4.0.0",
      tslib: "^2.6.2"
    },
    devDependencies: {
      concurrently: "7.0.0",
      "downlevel-dts": "0.10.1",
      rimraf: "3.0.2",
      typescript: "~5.2.2"
    },
    typesVersions: {
      "<4.0": {
        "dist-types/*": ["dist-types/ts3.4/*"]
      }
    },
    files: ["./sso-oidc.d.ts", "./sso-oidc.js", "./sts.d.ts", "./sts.js", "dist-*/**"],
    browser: {
      "./dist-es/submodules/sso-oidc/runtimeConfig": "./dist-es/submodules/sso-oidc/runtimeConfig.browser",
      "./dist-es/submodules/sts/runtimeConfig": "./dist-es/submodules/sts/runtimeConfig.browser"
    },
    "react-native": {},
    homepage: "https://github.com/aws/aws-sdk-js-v3/tree/main/packages/nested-clients",
    repository: {
      type: "git",
      url: "https://github.com/aws/aws-sdk-js-v3.git",
      directory: "packages/nested-clients"
    },
    exports: {
      "./sso-oidc": {
        types: "./dist-types/submodules/sso-oidc/index.d.ts",
        module: "./dist-es/submodules/sso-oidc/index.js",
        node: "./dist-cjs/submodules/sso-oidc/index.js",
        import: "./dist-es/submodules/sso-oidc/index.js",
        require: "./dist-cjs/submodules/sso-oidc/index.js"
      },
      "./sts": {
        types: "./dist-types/submodules/sts/index.d.ts",
        module: "./dist-es/submodules/sts/index.js",
        node: "./dist-cjs/submodules/sts/index.js",
        import: "./dist-es/submodules/sts/index.js",
        require: "./dist-cjs/submodules/sts/index.js"
      }
    }
  }
})
// @from(Start 3681103, End 3681593)
Z60 = z((I60) => {
  Object.defineProperty(I60, "__esModule", {
    value: !0
  });
  I60.fromBase64 = void 0;
  var X$4 = MZ(),
    V$4 = /^[A-Za-z0-9+/]*={0,2}$/,
    C$4 = (A) => {
      if (A.length * 3 % 4 !== 0) throw new TypeError("Incorrect padding on base64 string.");
      if (!V$4.exec(A)) throw new TypeError("Invalid base64 string.");
      let B = X$4.fromString(A, "base64");
      return new Uint8Array(B.buffer, B.byteOffset, B.byteLength)
    };
  I60.fromBase64 = C$4
})
// @from(Start 3681599, End 3682172)
W60 = z((D60) => {
  Object.defineProperty(D60, "__esModule", {
    value: !0
  });
  D60.toBase64 = void 0;
  var K$4 = MZ(),
    H$4 = RQ(),
    z$4 = (A) => {
      let B;
      if (typeof A === "string") B = H$4.fromUtf8(A);
      else B = A;
      if (typeof B !== "object" || typeof B.byteOffset !== "number" || typeof B.byteLength !== "number") throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
      return K$4.fromArrayBuffer(B.buffer, B.byteOffset, B.byteLength).toString("base64")
    };
  D60.toBase64 = z$4
})
// @from(Start 3682178, End 3682874)
_k1 = z((pG8, kI1) => {
  var {
    defineProperty: J60,
    getOwnPropertyDescriptor: w$4,
    getOwnPropertyNames: E$4
  } = Object, U$4 = Object.prototype.hasOwnProperty, Pk1 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of E$4(B))
        if (!U$4.call(A, G) && G !== Q) J60(A, G, {
          get: () => B[G],
          enumerable: !(I = w$4(B, G)) || I.enumerable
        })
    }
    return A
  }, F60 = (A, B, Q) => (Pk1(A, B, "default"), Q && Pk1(Q, B, "default")), N$4 = (A) => Pk1(J60({}, "__esModule", {
    value: !0
  }), A), Sk1 = {};
  kI1.exports = N$4(Sk1);
  F60(Sk1, Z60(), kI1.exports);
  F60(Sk1, W60(), kI1.exports)
})
// @from(Start 3682880, End 3687520)
T60 = z((R60) => {
  Object.defineProperty(R60, "__esModule", {
    value: !0
  });
  R60.ruleSet = void 0;
  var $60 = "required",
    VX = "fn",
    CX = "argv",
    cb = "ref",
    X60 = !0,
    V60 = "isSet",
    Sa = "booleanEquals",
    ub = "error",
    pb = "endpoint",
    KN = "tree",
    jk1 = "PartitionResult",
    yk1 = "getAttr",
    C60 = {
      [$60]: !1,
      type: "String"
    },
    K60 = {
      [$60]: !0,
      default: !1,
      type: "Boolean"
    },
    H60 = {
      [cb]: "Endpoint"
    },
    q60 = {
      [VX]: Sa,
      [CX]: [{
        [cb]: "UseFIPS"
      }, !0]
    },
    M60 = {
      [VX]: Sa,
      [CX]: [{
        [cb]: "UseDualStack"
      }, !0]
    },
    XX = {},
    z60 = {
      [VX]: yk1,
      [CX]: [{
        [cb]: jk1
      }, "supportsFIPS"]
    },
    L60 = {
      [cb]: jk1
    },
    w60 = {
      [VX]: Sa,
      [CX]: [!0, {
        [VX]: yk1,
        [CX]: [L60, "supportsDualStack"]
      }]
    },
    E60 = [q60],
    U60 = [M60],
    N60 = [{
      [cb]: "Region"
    }],
    $$4 = {
      version: "1.0",
      parameters: {
        Region: C60,
        UseDualStack: K60,
        UseFIPS: K60,
        Endpoint: C60
      },
      rules: [{
        conditions: [{
          [VX]: V60,
          [CX]: [H60]
        }],
        rules: [{
          conditions: E60,
          error: "Invalid Configuration: FIPS and custom endpoint are not supported",
          type: ub
        }, {
          conditions: U60,
          error: "Invalid Configuration: Dualstack and custom endpoint are not supported",
          type: ub
        }, {
          endpoint: {
            url: H60,
            properties: XX,
            headers: XX
          },
          type: pb
        }],
        type: KN
      }, {
        conditions: [{
          [VX]: V60,
          [CX]: N60
        }],
        rules: [{
          conditions: [{
            [VX]: "aws.partition",
            [CX]: N60,
            assign: jk1
          }],
          rules: [{
            conditions: [q60, M60],
            rules: [{
              conditions: [{
                [VX]: Sa,
                [CX]: [X60, z60]
              }, w60],
              rules: [{
                endpoint: {
                  url: "https://oidc-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
                  properties: XX,
                  headers: XX
                },
                type: pb
              }],
              type: KN
            }, {
              error: "FIPS and DualStack are enabled, but this partition does not support one or both",
              type: ub
            }],
            type: KN
          }, {
            conditions: E60,
            rules: [{
              conditions: [{
                [VX]: Sa,
                [CX]: [z60, X60]
              }],
              rules: [{
                conditions: [{
                  [VX]: "stringEquals",
                  [CX]: [{
                    [VX]: yk1,
                    [CX]: [L60, "name"]
                  }, "aws-us-gov"]
                }],
                endpoint: {
                  url: "https://oidc.{Region}.amazonaws.com",
                  properties: XX,
                  headers: XX
                },
                type: pb
              }, {
                endpoint: {
                  url: "https://oidc-fips.{Region}.{PartitionResult#dnsSuffix}",
                  properties: XX,
                  headers: XX
                },
                type: pb
              }],
              type: KN
            }, {
              error: "FIPS is enabled but this partition does not support FIPS",
              type: ub
            }],
            type: KN
          }, {
            conditions: U60,
            rules: [{
              conditions: [w60],
              rules: [{
                endpoint: {
                  url: "https://oidc.{Region}.{PartitionResult#dualStackDnsSuffix}",
                  properties: XX,
                  headers: XX
                },
                type: pb
              }],
              type: KN
            }, {
              error: "DualStack is enabled but this partition does not support DualStack",
              type: ub
            }],
            type: KN
          }, {
            endpoint: {
              url: "https://oidc.{Region}.{PartitionResult#dnsSuffix}",
              properties: XX,
              headers: XX
            },
            type: pb
          }],
          type: KN
        }],
        type: KN
      }, {
        error: "Invalid Configuration: Missing Region",
        type: ub
      }]
    };
  R60.ruleSet = $$4
})
// @from(Start 3687526, End 3688084)
_60 = z((P60) => {
  Object.defineProperty(P60, "__esModule", {
    value: !0
  });
  P60.defaultEndpointResolver = void 0;
  var q$4 = RL(),
    kk1 = LL(),
    M$4 = T60(),
    L$4 = new kk1.EndpointCache({
      size: 50,
      params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
    }),
    R$4 = (A, B = {}) => {
      return L$4.get(A, () => kk1.resolveEndpoint(M$4.ruleSet, {
        endpointParams: A,
        logger: B.logger
      }))
    };
  P60.defaultEndpointResolver = R$4;
  kk1.customEndpointFunctions.aws = q$4.awsEndpointFunctions
})
// @from(Start 3688090, End 3689509)
f60 = z((k60) => {
  Object.defineProperty(k60, "__esModule", {
    value: !0
  });
  k60.getRuntimeConfig = void 0;
  var O$4 = IB(),
    T$4 = NI(),
    P$4 = p3(),
    S$4 = FN(),
    j60 = _k1(),
    y60 = RQ(),
    _$4 = Lk1(),
    j$4 = _60(),
    y$4 = (A) => {
      return {
        apiVersion: "2019-06-10",
        base64Decoder: A?.base64Decoder ?? j60.fromBase64,
        base64Encoder: A?.base64Encoder ?? j60.toBase64,
        disableHostPrefix: A?.disableHostPrefix ?? !1,
        endpointProvider: A?.endpointProvider ?? j$4.defaultEndpointResolver,
        extensions: A?.extensions ?? [],
        httpAuthSchemeProvider: A?.httpAuthSchemeProvider ?? _$4.defaultSSOOIDCHttpAuthSchemeProvider,
        httpAuthSchemes: A?.httpAuthSchemes ?? [{
          schemeId: "aws.auth#sigv4",
          identityProvider: (B) => B.getIdentityProvider("aws.auth#sigv4"),
          signer: new O$4.AwsSdkSigV4Signer
        }, {
          schemeId: "smithy.api#noAuth",
          identityProvider: (B) => B.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
          signer: new T$4.NoAuthSigner
        }],
        logger: A?.logger ?? new P$4.NoOpLogger,
        serviceId: A?.serviceId ?? "SSO OIDC",
        urlParser: A?.urlParser ?? S$4.parseUrl,
        utf8Decoder: A?.utf8Decoder ?? y60.fromUtf8,
        utf8Encoder: A?.utf8Encoder ?? y60.toUtf8
      }
    };
  k60.getRuntimeConfig = y$4
})
// @from(Start 3689515, End 3691612)
d60 = z((h60) => {
  Object.defineProperty(h60, "__esModule", {
    value: !0
  });
  h60.getRuntimeConfig = void 0;
  var k$4 = Ok1(),
    x$4 = k$4.__importDefault(Tk1()),
    f$4 = IB(),
    v60 = I_(),
    xI1 = _D(),
    v$4 = G_(),
    b60 = KJ(),
    lb = qC(),
    g60 = DN(),
    b$4 = Z_(),
    g$4 = vL(),
    h$4 = f60(),
    m$4 = p3(),
    d$4 = Y_(),
    u$4 = p3(),
    p$4 = (A) => {
      u$4.emitWarningIfUnsupportedVersion(process.version);
      let B = d$4.resolveDefaultsModeConfig(A),
        Q = () => B().then(m$4.loadConfigsForDefaultMode),
        I = h$4.getRuntimeConfig(A);
      f$4.emitWarningIfUnsupportedVersion(process.version);
      let G = {
        profile: A?.profile
      };
      return {
        ...I,
        ...A,
        runtime: "node",
        defaultsMode: B,
        bodyLengthChecker: A?.bodyLengthChecker ?? b$4.calculateBodyLength,
        defaultUserAgentProvider: A?.defaultUserAgentProvider ?? v60.createDefaultUserAgentProvider({
          serviceId: I.serviceId,
          clientVersion: x$4.default.version
        }),
        maxAttempts: A?.maxAttempts ?? lb.loadConfig(b60.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, A),
        region: A?.region ?? lb.loadConfig(xI1.NODE_REGION_CONFIG_OPTIONS, {
          ...xI1.NODE_REGION_CONFIG_FILE_OPTIONS,
          ...G
        }),
        requestHandler: g60.NodeHttpHandler.create(A?.requestHandler ?? Q),
        retryMode: A?.retryMode ?? lb.loadConfig({
          ...b60.NODE_RETRY_MODE_CONFIG_OPTIONS,
          default: async () => (await Q()).retryMode || g$4.DEFAULT_RETRY_MODE
        }, A),
        sha256: A?.sha256 ?? v$4.Hash.bind(null, "sha256"),
        streamCollector: A?.streamCollector ?? g60.streamCollector,
        useDualstackEndpoint: A?.useDualstackEndpoint ?? lb.loadConfig(xI1.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, G),
        useFipsEndpoint: A?.useFipsEndpoint ?? lb.loadConfig(xI1.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, G),
        userAgentAppId: A?.userAgentAppId ?? lb.loadConfig(v60.NODE_APP_ID_CONFIG_OPTIONS, G)
      }
    };
  h60.getRuntimeConfig = p$4
})
// @from(Start 3691618, End 3696125)
vI1 = z((aG8, i60) => {
  var {
    defineProperty: fI1,
    getOwnPropertyDescriptor: c$4,
    getOwnPropertyNames: l$4
  } = Object, i$4 = Object.prototype.hasOwnProperty, dL = (A, B) => fI1(A, "name", {
    value: B,
    configurable: !0
  }), n$4 = (A, B) => {
    for (var Q in B) fI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, a$4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of l$4(B))
        if (!i$4.call(A, G) && G !== Q) fI1(A, G, {
          get: () => B[G],
          enumerable: !(I = c$4(B, G)) || I.enumerable
        })
    }
    return A
  }, s$4 = (A) => a$4(fI1({}, "__esModule", {
    value: !0
  }), A), u60 = {};
  n$4(u60, {
    Field: () => t$4,
    Fields: () => e$4,
    HttpRequest: () => Aq4,
    HttpResponse: () => Bq4,
    IHttpRequest: () => p60.HttpRequest,
    getHttpHandlerExtensionConfiguration: () => r$4,
    isValidHostname: () => l60,
    resolveHttpHandlerRuntimeConfig: () => o$4
  });
  i60.exports = s$4(u60);
  var r$4 = dL((A) => {
      return {
        setHttpHandler(B) {
          A.httpHandler = B
        },
        httpHandler() {
          return A.httpHandler
        },
        updateHttpClientConfig(B, Q) {
          A.httpHandler?.updateHttpClientConfig(B, Q)
        },
        httpHandlerConfigs() {
          return A.httpHandler.httpHandlerConfigs()
        }
      }
    }, "getHttpHandlerExtensionConfiguration"),
    o$4 = dL((A) => {
      return {
        httpHandler: A.httpHandler()
      }
    }, "resolveHttpHandlerRuntimeConfig"),
    p60 = Fk1(),
    t$4 = class {
      static {
        dL(this, "Field")
      }
      constructor({
        name: A,
        kind: B = p60.FieldPosition.HEADER,
        values: Q = []
      }) {
        this.name = A, this.kind = B, this.values = Q
      }
      add(A) {
        this.values.push(A)
      }
      set(A) {
        this.values = A
      }
      remove(A) {
        this.values = this.values.filter((B) => B !== A)
      }
      toString() {
        return this.values.map((A) => A.includes(",") || A.includes(" ") ? `"${A}"` : A).join(", ")
      }
      get() {
        return this.values
      }
    },
    e$4 = class {
      constructor({
        fields: A = [],
        encoding: B = "utf-8"
      }) {
        this.entries = {}, A.forEach(this.setField.bind(this)), this.encoding = B
      }
      static {
        dL(this, "Fields")
      }
      setField(A) {
        this.entries[A.name.toLowerCase()] = A
      }
      getField(A) {
        return this.entries[A.toLowerCase()]
      }
      removeField(A) {
        delete this.entries[A.toLowerCase()]
      }
      getByType(A) {
        return Object.values(this.entries).filter((B) => B.kind === A)
      }
    },
    Aq4 = class A {
      static {
        dL(this, "HttpRequest")
      }
      constructor(B) {
        this.method = B.method || "GET", this.hostname = B.hostname || "localhost", this.port = B.port, this.query = B.query || {}, this.headers = B.headers || {}, this.body = B.body, this.protocol = B.protocol ? B.protocol.slice(-1) !== ":" ? `${B.protocol}:` : B.protocol : "https:", this.path = B.path ? B.path.charAt(0) !== "/" ? `/${B.path}` : B.path : "/", this.username = B.username, this.password = B.password, this.fragment = B.fragment
      }
      static clone(B) {
        let Q = new A({
          ...B,
          headers: {
            ...B.headers
          }
        });
        if (Q.query) Q.query = c60(Q.query);
        return Q
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return "method" in Q && "protocol" in Q && "hostname" in Q && "path" in Q && typeof Q.query === "object" && typeof Q.headers === "object"
      }
      clone() {
        return A.clone(this)
      }
    };

  function c60(A) {
    return Object.keys(A).reduce((B, Q) => {
      let I = A[Q];
      return {
        ...B,
        [Q]: Array.isArray(I) ? [...I] : I
      }
    }, {})
  }
  dL(c60, "cloneQuery");
  var Bq4 = class {
    static {
      dL(this, "HttpResponse")
    }
    constructor(A) {
      this.statusCode = A.statusCode, this.reason = A.reason, this.headers = A.headers || {}, this.body = A.body
    }
    static isInstance(A) {
      if (!A) return !1;
      let B = A;
      return typeof B.statusCode === "number" && typeof B.headers === "object"
    }
  };

  function l60(A) {
    return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(A)
  }
  dL(l60, "isValidHostname")
})
// @from(Start 3696131, End 3715607)
vk1 = z((tG8, U50) => {
  var {
    defineProperty: bI1,
    getOwnPropertyDescriptor: Qq4,
    getOwnPropertyNames: Iq4
  } = Object, Gq4 = Object.prototype.hasOwnProperty, X6 = (A, B) => bI1(A, "name", {
    value: B,
    configurable: !0
  }), Zq4 = (A, B) => {
    for (var Q in B) bI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, Dq4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of Iq4(B))
        if (!Gq4.call(A, G) && G !== Q) bI1(A, G, {
          get: () => B[G],
          enumerable: !(I = Qq4(B, G)) || I.enumerable
        })
    }
    return A
  }, Yq4 = (A) => Dq4(bI1({}, "__esModule", {
    value: !0
  }), A), A50 = {};
  Zq4(A50, {
    $Command: () => I50.Command,
    AccessDeniedException: () => G50,
    AuthorizationPendingException: () => Z50,
    CreateTokenCommand: () => w50,
    CreateTokenRequestFilterSensitiveLog: () => D50,
    CreateTokenResponseFilterSensitiveLog: () => Y50,
    ExpiredTokenException: () => W50,
    InternalServerException: () => J50,
    InvalidClientException: () => F50,
    InvalidGrantException: () => X50,
    InvalidRequestException: () => V50,
    InvalidScopeException: () => C50,
    SSOOIDC: () => E50,
    SSOOIDCClient: () => Q50,
    SSOOIDCServiceException: () => HJ,
    SlowDownException: () => K50,
    UnauthorizedClientException: () => H50,
    UnsupportedGrantTypeException: () => z50,
    __Client: () => B50.Client
  });
  U50.exports = Yq4(A50);
  var n60 = cS(),
    Wq4 = lS(),
    Jq4 = iS(),
    a60 = jL(),
    Fq4 = _D(),
    xk1 = NI(),
    Xq4 = tS(),
    Vq4 = hz(),
    s60 = KJ(),
    B50 = p3(),
    r60 = Lk1(),
    Cq4 = X6((A) => {
      return Object.assign(A, {
        useDualstackEndpoint: A.useDualstackEndpoint ?? !1,
        useFipsEndpoint: A.useFipsEndpoint ?? !1,
        defaultSigningName: "sso-oauth"
      })
    }, "resolveClientEndpointParameters"),
    Kq4 = {
      UseFIPS: {
        type: "builtInParams",
        name: "useFipsEndpoint"
      },
      Endpoint: {
        type: "builtInParams",
        name: "endpoint"
      },
      Region: {
        type: "builtInParams",
        name: "region"
      },
      UseDualStack: {
        type: "builtInParams",
        name: "useDualstackEndpoint"
      }
    },
    Hq4 = d60(),
    o60 = W_(),
    t60 = vI1(),
    e60 = p3(),
    zq4 = X6((A) => {
      let {
        httpAuthSchemes: B,
        httpAuthSchemeProvider: Q,
        credentials: I
      } = A;
      return {
        setHttpAuthScheme(G) {
          let Z = B.findIndex((D) => D.schemeId === G.schemeId);
          if (Z === -1) B.push(G);
          else B.splice(Z, 1, G)
        },
        httpAuthSchemes() {
          return B
        },
        setHttpAuthSchemeProvider(G) {
          Q = G
        },
        httpAuthSchemeProvider() {
          return Q
        },
        setCredentials(G) {
          I = G
        },
        credentials() {
          return I
        }
      }
    }, "getHttpAuthExtensionConfiguration"),
    wq4 = X6((A) => {
      return {
        httpAuthSchemes: A.httpAuthSchemes(),
        httpAuthSchemeProvider: A.httpAuthSchemeProvider(),
        credentials: A.credentials()
      }
    }, "resolveHttpAuthRuntimeConfig"),
    Eq4 = X6((A, B) => {
      let Q = Object.assign(o60.getAwsRegionExtensionConfiguration(A), e60.getDefaultExtensionConfiguration(A), t60.getHttpHandlerExtensionConfiguration(A), zq4(A));
      return B.forEach((I) => I.configure(Q)), Object.assign(A, o60.resolveAwsRegionExtensionConfiguration(Q), e60.resolveDefaultRuntimeConfig(Q), t60.resolveHttpHandlerRuntimeConfig(Q), wq4(Q))
    }, "resolveRuntimeExtensions"),
    Q50 = class extends B50.Client {
      static {
        X6(this, "SSOOIDCClient")
      }
      config;
      constructor(...[A]) {
        let B = Hq4.getRuntimeConfig(A || {});
        super(B);
        this.initConfig = B;
        let Q = Cq4(B),
          I = a60.resolveUserAgentConfig(Q),
          G = s60.resolveRetryConfig(I),
          Z = Fq4.resolveRegionConfig(G),
          D = n60.resolveHostHeaderConfig(Z),
          Y = Vq4.resolveEndpointConfig(D),
          W = r60.resolveHttpAuthSchemeConfig(Y),
          J = Eq4(W, A?.extensions || []);
        this.config = J, this.middlewareStack.use(a60.getUserAgentPlugin(this.config)), this.middlewareStack.use(s60.getRetryPlugin(this.config)), this.middlewareStack.use(Xq4.getContentLengthPlugin(this.config)), this.middlewareStack.use(n60.getHostHeaderPlugin(this.config)), this.middlewareStack.use(Wq4.getLoggerPlugin(this.config)), this.middlewareStack.use(Jq4.getRecursionDetectionPlugin(this.config)), this.middlewareStack.use(xk1.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
          httpAuthSchemeParametersProvider: r60.defaultSSOOIDCHttpAuthSchemeParametersProvider,
          identityProviderConfigProvider: X6(async (F) => new xk1.DefaultIdentityProviderConfig({
            "aws.auth#sigv4": F.credentials
          }), "identityProviderConfigProvider")
        })), this.middlewareStack.use(xk1.getHttpSigningPlugin(this.config))
      }
      destroy() {
        super.destroy()
      }
    },
    Uq4 = p3(),
    Nq4 = hz(),
    $q4 = yz(),
    I50 = p3(),
    ib = p3(),
    qq4 = p3(),
    HJ = class A extends qq4.ServiceException {
      static {
        X6(this, "SSOOIDCServiceException")
      }
      constructor(B) {
        super(B);
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    G50 = class A extends HJ {
      static {
        X6(this, "AccessDeniedException")
      }
      name = "AccessDeniedException";
      $fault = "client";
      error;
      error_description;
      constructor(B) {
        super({
          name: "AccessDeniedException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype), this.error = B.error, this.error_description = B.error_description
      }
    },
    Z50 = class A extends HJ {
      static {
        X6(this, "AuthorizationPendingException")
      }
      name = "AuthorizationPendingException";
      $fault = "client";
      error;
      error_description;
      constructor(B) {
        super({
          name: "AuthorizationPendingException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype), this.error = B.error, this.error_description = B.error_description
      }
    },
    D50 = X6((A) => ({
      ...A,
      ...A.clientSecret && {
        clientSecret: ib.SENSITIVE_STRING
      },
      ...A.refreshToken && {
        refreshToken: ib.SENSITIVE_STRING
      },
      ...A.codeVerifier && {
        codeVerifier: ib.SENSITIVE_STRING
      }
    }), "CreateTokenRequestFilterSensitiveLog"),
    Y50 = X6((A) => ({
      ...A,
      ...A.accessToken && {
        accessToken: ib.SENSITIVE_STRING
      },
      ...A.refreshToken && {
        refreshToken: ib.SENSITIVE_STRING
      },
      ...A.idToken && {
        idToken: ib.SENSITIVE_STRING
      }
    }), "CreateTokenResponseFilterSensitiveLog"),
    W50 = class A extends HJ {
      static {
        X6(this, "ExpiredTokenException")
      }
      name = "ExpiredTokenException";
      $fault = "client";
      error;
      error_description;
      constructor(B) {
        super({
          name: "ExpiredTokenException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype), this.error = B.error, this.error_description = B.error_description
      }
    },
    J50 = class A extends HJ {
      static {
        X6(this, "InternalServerException")
      }
      name = "InternalServerException";
      $fault = "server";
      error;
      error_description;
      constructor(B) {
        super({
          name: "InternalServerException",
          $fault: "server",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype), this.error = B.error, this.error_description = B.error_description
      }
    },
    F50 = class A extends HJ {
      static {
        X6(this, "InvalidClientException")
      }
      name = "InvalidClientException";
      $fault = "client";
      error;
      error_description;
      constructor(B) {
        super({
          name: "InvalidClientException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype), this.error = B.error, this.error_description = B.error_description
      }
    },
    X50 = class A extends HJ {
      static {
        X6(this, "InvalidGrantException")
      }
      name = "InvalidGrantException";
      $fault = "client";
      error;
      error_description;
      constructor(B) {
        super({
          name: "InvalidGrantException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype), this.error = B.error, this.error_description = B.error_description
      }
    },
    V50 = class A extends HJ {
      static {
        X6(this, "InvalidRequestException")
      }
      name = "InvalidRequestException";
      $fault = "client";
      error;
      error_description;
      constructor(B) {
        super({
          name: "InvalidRequestException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype), this.error = B.error, this.error_description = B.error_description
      }
    },
    C50 = class A extends HJ {
      static {
        X6(this, "InvalidScopeException")
      }
      name = "InvalidScopeException";
      $fault = "client";
      error;
      error_description;
      constructor(B) {
        super({
          name: "InvalidScopeException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype), this.error = B.error, this.error_description = B.error_description
      }
    },
    K50 = class A extends HJ {
      static {
        X6(this, "SlowDownException")
      }
      name = "SlowDownException";
      $fault = "client";
      error;
      error_description;
      constructor(B) {
        super({
          name: "SlowDownException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype), this.error = B.error, this.error_description = B.error_description
      }
    },
    H50 = class A extends HJ {
      static {
        X6(this, "UnauthorizedClientException")
      }
      name = "UnauthorizedClientException";
      $fault = "client";
      error;
      error_description;
      constructor(B) {
        super({
          name: "UnauthorizedClientException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype), this.error = B.error, this.error_description = B.error_description
      }
    },
    z50 = class A extends HJ {
      static {
        X6(this, "UnsupportedGrantTypeException")
      }
      name = "UnsupportedGrantTypeException";
      $fault = "client";
      error;
      error_description;
      constructor(B) {
        super({
          name: "UnsupportedGrantTypeException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype), this.error = B.error, this.error_description = B.error_description
      }
    },
    fk1 = IB(),
    Mq4 = NI(),
    j2 = p3(),
    Lq4 = X6(async (A, B) => {
      let Q = Mq4.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/token");
      let G;
      return G = JSON.stringify(j2.take(A, {
        clientId: [],
        clientSecret: [],
        code: [],
        codeVerifier: [],
        deviceCode: [],
        grantType: [],
        redirectUri: [],
        refreshToken: [],
        scope: X6((Z) => j2._json(Z), "scope")
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_CreateTokenCommand"),
    Rq4 = X6(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return Oq4(A, B);
      let Q = j2.map({
          $metadata: KX(A)
        }),
        I = j2.expectNonNull(j2.expectObject(await fk1.parseJsonBody(A.body, B)), "body"),
        G = j2.take(I, {
          accessToken: j2.expectString,
          expiresIn: j2.expectInt32,
          idToken: j2.expectString,
          refreshToken: j2.expectString,
          tokenType: j2.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_CreateTokenCommand"),
    Oq4 = X6(async (A, B) => {
      let Q = {
          ...A,
          body: await fk1.parseJsonErrorBody(A.body, B)
        },
        I = fk1.loadRestJsonErrorCode(A, Q.body);
      switch (I) {
        case "AccessDeniedException":
        case "com.amazonaws.ssooidc#AccessDeniedException":
          throw await Pq4(Q, B);
        case "AuthorizationPendingException":
        case "com.amazonaws.ssooidc#AuthorizationPendingException":
          throw await Sq4(Q, B);
        case "ExpiredTokenException":
        case "com.amazonaws.ssooidc#ExpiredTokenException":
          throw await _q4(Q, B);
        case "InternalServerException":
        case "com.amazonaws.ssooidc#InternalServerException":
          throw await jq4(Q, B);
        case "InvalidClientException":
        case "com.amazonaws.ssooidc#InvalidClientException":
          throw await yq4(Q, B);
        case "InvalidGrantException":
        case "com.amazonaws.ssooidc#InvalidGrantException":
          throw await kq4(Q, B);
        case "InvalidRequestException":
        case "com.amazonaws.ssooidc#InvalidRequestException":
          throw await xq4(Q, B);
        case "InvalidScopeException":
        case "com.amazonaws.ssooidc#InvalidScopeException":
          throw await fq4(Q, B);
        case "SlowDownException":
        case "com.amazonaws.ssooidc#SlowDownException":
          throw await vq4(Q, B);
        case "UnauthorizedClientException":
        case "com.amazonaws.ssooidc#UnauthorizedClientException":
          throw await bq4(Q, B);
        case "UnsupportedGrantTypeException":
        case "com.amazonaws.ssooidc#UnsupportedGrantTypeException":
          throw await gq4(Q, B);
        default:
          let G = Q.body;
          return Tq4({
            output: A,
            parsedBody: G,
            errorCode: I
          })
      }
    }, "de_CommandError"),
    Tq4 = j2.withBaseException(HJ),
    Pq4 = X6(async (A, B) => {
      let Q = j2.map({}),
        I = A.body,
        G = j2.take(I, {
          error: j2.expectString,
          error_description: j2.expectString
        });
      Object.assign(Q, G);
      let Z = new G50({
        $metadata: KX(A),
        ...Q
      });
      return j2.decorateServiceException(Z, A.body)
    }, "de_AccessDeniedExceptionRes"),
    Sq4 = X6(async (A, B) => {
      let Q = j2.map({}),
        I = A.body,
        G = j2.take(I, {
          error: j2.expectString,
          error_description: j2.expectString
        });
      Object.assign(Q, G);
      let Z = new Z50({
        $metadata: KX(A),
        ...Q
      });
      return j2.decorateServiceException(Z, A.body)
    }, "de_AuthorizationPendingExceptionRes"),
    _q4 = X6(async (A, B) => {
      let Q = j2.map({}),
        I = A.body,
        G = j2.take(I, {
          error: j2.expectString,
          error_description: j2.expectString
        });
      Object.assign(Q, G);
      let Z = new W50({
        $metadata: KX(A),
        ...Q
      });
      return j2.decorateServiceException(Z, A.body)
    }, "de_ExpiredTokenExceptionRes"),
    jq4 = X6(async (A, B) => {
      let Q = j2.map({}),
        I = A.body,
        G = j2.take(I, {
          error: j2.expectString,
          error_description: j2.expectString
        });
      Object.assign(Q, G);
      let Z = new J50({
        $metadata: KX(A),
        ...Q
      });
      return j2.decorateServiceException(Z, A.body)
    }, "de_InternalServerExceptionRes"),
    yq4 = X6(async (A, B) => {
      let Q = j2.map({}),
        I = A.body,
        G = j2.take(I, {
          error: j2.expectString,
          error_description: j2.expectString
        });
      Object.assign(Q, G);
      let Z = new F50({
        $metadata: KX(A),
        ...Q
      });
      return j2.decorateServiceException(Z, A.body)
    }, "de_InvalidClientExceptionRes"),
    kq4 = X6(async (A, B) => {
      let Q = j2.map({}),
        I = A.body,
        G = j2.take(I, {
          error: j2.expectString,
          error_description: j2.expectString
        });
      Object.assign(Q, G);
      let Z = new X50({
        $metadata: KX(A),
        ...Q
      });
      return j2.decorateServiceException(Z, A.body)
    }, "de_InvalidGrantExceptionRes"),
    xq4 = X6(async (A, B) => {
      let Q = j2.map({}),
        I = A.body,
        G = j2.take(I, {
          error: j2.expectString,
          error_description: j2.expectString
        });
      Object.assign(Q, G);
      let Z = new V50({
        $metadata: KX(A),
        ...Q
      });
      return j2.decorateServiceException(Z, A.body)
    }, "de_InvalidRequestExceptionRes"),
    fq4 = X6(async (A, B) => {
      let Q = j2.map({}),
        I = A.body,
        G = j2.take(I, {
          error: j2.expectString,
          error_description: j2.expectString
        });
      Object.assign(Q, G);
      let Z = new C50({
        $metadata: KX(A),
        ...Q
      });
      return j2.decorateServiceException(Z, A.body)
    }, "de_InvalidScopeExceptionRes"),
    vq4 = X6(async (A, B) => {
      let Q = j2.map({}),
        I = A.body,
        G = j2.take(I, {
          error: j2.expectString,
          error_description: j2.expectString
        });
      Object.assign(Q, G);
      let Z = new K50({
        $metadata: KX(A),
        ...Q
      });
      return j2.decorateServiceException(Z, A.body)
    }, "de_SlowDownExceptionRes"),
    bq4 = X6(async (A, B) => {
      let Q = j2.map({}),
        I = A.body,
        G = j2.take(I, {
          error: j2.expectString,
          error_description: j2.expectString
        });
      Object.assign(Q, G);
      let Z = new H50({
        $metadata: KX(A),
        ...Q
      });
      return j2.decorateServiceException(Z, A.body)
    }, "de_UnauthorizedClientExceptionRes"),
    gq4 = X6(async (A, B) => {
      let Q = j2.map({}),
        I = A.body,
        G = j2.take(I, {
          error: j2.expectString,
          error_description: j2.expectString
        });
      Object.assign(Q, G);
      let Z = new z50({
        $metadata: KX(A),
        ...Q
      });
      return j2.decorateServiceException(Z, A.body)
    }, "de_UnsupportedGrantTypeExceptionRes"),
    KX = X6((A) => ({
      httpStatusCode: A.statusCode,
      requestId: A.headers["x-amzn-requestid"] ?? A.headers["x-amzn-request-id"] ?? A.headers["x-amz-request-id"],
      extendedRequestId: A.headers["x-amz-id-2"],
      cfId: A.headers["x-amz-cf-id"]
    }), "deserializeMetadata"),
    w50 = class extends I50.Command.classBuilder().ep(Kq4).m(function(A, B, Q, I) {
      return [$q4.getSerdePlugin(Q, this.serialize, this.deserialize), Nq4.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AWSSSOOIDCService", "CreateToken", {}).n("SSOOIDCClient", "CreateTokenCommand").f(D50, Y50).ser(Lq4).de(Rq4).build() {
      static {
        X6(this, "CreateTokenCommand")
      }
    },
    hq4 = {
      CreateTokenCommand: w50
    },
    E50 = class extends Q50 {
      static {
        X6(this, "SSOOIDC")
      }
    };
  Uq4.createAggregatedClient(hq4, E50)
})
// @from(Start 3715613, End 3721038)
T50 = z((QZ8, O50) => {
  var {
    create: mq4,
    defineProperty: ja,
    getOwnPropertyDescriptor: dq4,
    getOwnPropertyNames: uq4,
    getPrototypeOf: pq4
  } = Object, cq4 = Object.prototype.hasOwnProperty, uL = (A, B) => ja(A, "name", {
    value: B,
    configurable: !0
  }), lq4 = (A, B) => {
    for (var Q in B) ja(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, q50 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of uq4(B))
        if (!cq4.call(A, G) && G !== Q) ja(A, G, {
          get: () => B[G],
          enumerable: !(I = dq4(B, G)) || I.enumerable
        })
    }
    return A
  }, M50 = (A, B, Q) => (Q = A != null ? mq4(pq4(A)) : {}, q50(B || !A || !A.__esModule ? ja(Q, "default", {
    value: A,
    enumerable: !0
  }) : Q, A)), iq4 = (A) => q50(ja({}, "__esModule", {
    value: !0
  }), A), L50 = {};
  lq4(L50, {
    fromSso: () => R50,
    fromStatic: () => eq4,
    nodeProvider: () => AM4
  });
  O50.exports = iq4(L50);
  var nq4 = 300000,
    bk1 = "To refresh this SSO session run 'aws sso login' with the corresponding profile.",
    aq4 = uL(async (A, B = {}) => {
      let {
        SSOOIDCClient: Q
      } = await Promise.resolve().then(() => M50(vk1()));
      return new Q(Object.assign({}, B.clientConfig ?? {}, {
        region: A ?? B.clientConfig?.region,
        logger: B.clientConfig?.logger ?? B.parentClientConfig?.logger
      }))
    }, "getSsoOidcClient"),
    sq4 = uL(async (A, B, Q = {}) => {
      let {
        CreateTokenCommand: I
      } = await Promise.resolve().then(() => M50(vk1()));
      return (await aq4(B, Q)).send(new I({
        clientId: A.clientId,
        clientSecret: A.clientSecret,
        refreshToken: A.refreshToken,
        grantType: "refresh_token"
      }))
    }, "getNewSsoOidcToken"),
    OC = $I(),
    N50 = uL((A) => {
      if (A.expiration && A.expiration.getTime() < Date.now()) throw new OC.TokenProviderError(`Token is expired. ${bk1}`, !1)
    }, "validateTokenExpiry"),
    F_ = uL((A, B, Q = !1) => {
      if (typeof B === "undefined") throw new OC.TokenProviderError(`Value not present for '${A}' in SSO Token${Q?". Cannot refresh":""}. ${bk1}`, !1)
    }, "validateTokenKey"),
    _a = xL(),
    rq4 = Z1("fs"),
    {
      writeFile: oq4
    } = rq4.promises,
    tq4 = uL((A, B) => {
      let Q = _a.getSSOTokenFilepath(A),
        I = JSON.stringify(B, null, 2);
      return oq4(Q, I)
    }, "writeSSOTokenToFile"),
    $50 = new Date(0),
    R50 = uL((A = {}) => async ({
      callerClientConfig: B
    } = {}) => {
      let Q = {
        ...A,
        parentClientConfig: {
          ...B,
          ...A.parentClientConfig
        }
      };
      Q.logger?.debug("@aws-sdk/token-providers - fromSso");
      let I = await _a.parseKnownFiles(Q),
        G = _a.getProfileName({
          profile: Q.profile ?? B?.profile
        }),
        Z = I[G];
      if (!Z) throw new OC.TokenProviderError(`Profile '${G}' could not be found in shared credentials file.`, !1);
      else if (!Z.sso_session) throw new OC.TokenProviderError(`Profile '${G}' is missing required property 'sso_session'.`);
      let D = Z.sso_session,
        W = (await _a.loadSsoSessionData(Q))[D];
      if (!W) throw new OC.TokenProviderError(`Sso session '${D}' could not be found in shared credentials file.`, !1);
      for (let E of ["sso_start_url", "sso_region"])
        if (!W[E]) throw new OC.TokenProviderError(`Sso session '${D}' is missing required property '${E}'.`, !1);
      let {
        sso_start_url: J,
        sso_region: F
      } = W, X;
      try {
        X = await _a.getSSOTokenFromFile(D)
      } catch (E) {
        throw new OC.TokenProviderError(`The SSO session token associated with profile=${G} was not found or is invalid. ${bk1}`, !1)
      }
      F_("accessToken", X.accessToken), F_("expiresAt", X.expiresAt);
      let {
        accessToken: V,
        expiresAt: C
      } = X, K = {
        token: V,
        expiration: new Date(C)
      };
      if (K.expiration.getTime() - Date.now() > nq4) return K;
      if (Date.now() - $50.getTime() < 30000) return N50(K), K;
      F_("clientId", X.clientId, !0), F_("clientSecret", X.clientSecret, !0), F_("refreshToken", X.refreshToken, !0);
      try {
        $50.setTime(Date.now());
        let E = await sq4(X, F, Q);
        F_("accessToken", E.accessToken), F_("expiresIn", E.expiresIn);
        let N = new Date(Date.now() + E.expiresIn * 1000);
        try {
          await tq4(D, {
            ...X,
            accessToken: E.accessToken,
            expiresAt: N.toISOString(),
            refreshToken: E.refreshToken
          })
        } catch (q) {}
        return {
          token: E.accessToken,
          expiration: N
        }
      } catch (E) {
        return N50(K), K
      }
    }, "fromSso"),
    eq4 = uL(({
      token: A,
      logger: B
    }) => async () => {
      if (B?.debug("@aws-sdk/token-providers - fromStatic"), !A || !A.token) throw new OC.TokenProviderError("Please pass a valid token to fromStatic", !1);
      return A
    }, "fromStatic"),
    AM4 = uL((A = {}) => OC.memoize(OC.chain(R50(A), async () => {
      throw new OC.TokenProviderError("Could not load token from any providers", !1)
    }), (B) => B.expiration !== void 0 && B.expiration.getTime() - Date.now() < 300000, (B) => B.expiration !== void 0), "nodeProvider")
})
// @from(Start 3721044, End 3728244)
dI1 = z((IZ8, v50) => {
  var {
    defineProperty: hI1,
    getOwnPropertyDescriptor: BM4,
    getOwnPropertyNames: _50
  } = Object, QM4 = Object.prototype.hasOwnProperty, mI1 = (A, B) => hI1(A, "name", {
    value: B,
    configurable: !0
  }), IM4 = (A, B) => function Q() {
    return A && (B = A[_50(A)[0]](A = 0)), B
  }, j50 = (A, B) => {
    for (var Q in B) hI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, GM4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of _50(B))
        if (!QM4.call(A, G) && G !== Q) hI1(A, G, {
          get: () => B[G],
          enumerable: !(I = BM4(B, G)) || I.enumerable
        })
    }
    return A
  }, ZM4 = (A) => GM4(hI1({}, "__esModule", {
    value: !0
  }), A), y50 = {};
  j50(y50, {
    GetRoleCredentialsCommand: () => gk1.GetRoleCredentialsCommand,
    SSOClient: () => gk1.SSOClient
  });
  var gk1, DM4 = IM4({
      "src/loadSso.ts"() {
        gk1 = e90()
      }
    }),
    k50 = {};
  j50(k50, {
    fromSSO: () => WM4,
    isSsoProfile: () => x50,
    validateSsoProfile: () => f50
  });
  v50.exports = ZM4(k50);
  var x50 = mI1((A) => A && (typeof A.sso_start_url === "string" || typeof A.sso_account_id === "string" || typeof A.sso_session === "string" || typeof A.sso_region === "string" || typeof A.sso_role_name === "string"), "isSsoProfile"),
    P50 = NC(),
    YM4 = T50(),
    TC = $I(),
    gI1 = xL(),
    ya = !1,
    S50 = mI1(async ({
      ssoStartUrl: A,
      ssoSession: B,
      ssoAccountId: Q,
      ssoRegion: I,
      ssoRoleName: G,
      ssoClient: Z,
      clientConfig: D,
      parentClientConfig: Y,
      profile: W,
      logger: J
    }) => {
      let F, X = "To refresh this SSO session run aws sso login with the corresponding profile.";
      if (B) try {
        let i = await YM4.fromSso({
          profile: W
        })();
        F = {
          accessToken: i.token,
          expiresAt: new Date(i.expiration).toISOString()
        }
      } catch (i) {
        throw new TC.CredentialsProviderError(i.message, {
          tryNextLink: ya,
          logger: J
        })
      } else try {
        F = await gI1.getSSOTokenFromFile(A)
      } catch (i) {
        throw new TC.CredentialsProviderError("The SSO session associated with this profile is invalid. To refresh this SSO session run aws sso login with the corresponding profile.", {
          tryNextLink: ya,
          logger: J
        })
      }
      if (new Date(F.expiresAt).getTime() - Date.now() <= 0) throw new TC.CredentialsProviderError("The SSO session associated with this profile has expired. To refresh this SSO session run aws sso login with the corresponding profile.", {
        tryNextLink: ya,
        logger: J
      });
      let {
        accessToken: V
      } = F, {
        SSOClient: C,
        GetRoleCredentialsCommand: K
      } = await Promise.resolve().then(() => (DM4(), y50)), E = Z || new C(Object.assign({}, D ?? {}, {
        logger: D?.logger ?? Y?.logger,
        region: D?.region ?? I
      })), N;
      try {
        N = await E.send(new K({
          accountId: Q,
          roleName: G,
          accessToken: V
        }))
      } catch (i) {
        throw new TC.CredentialsProviderError(i, {
          tryNextLink: ya,
          logger: J
        })
      }
      let {
        roleCredentials: {
          accessKeyId: q,
          secretAccessKey: O,
          sessionToken: R,
          expiration: T,
          credentialScope: L,
          accountId: _
        } = {}
      } = N;
      if (!q || !O || !R || !T) throw new TC.CredentialsProviderError("SSO returns an invalid temporary credential.", {
        tryNextLink: ya,
        logger: J
      });
      let k = {
        accessKeyId: q,
        secretAccessKey: O,
        sessionToken: R,
        expiration: new Date(T),
        ...L && {
          credentialScope: L
        },
        ..._ && {
          accountId: _
        }
      };
      if (B) P50.setCredentialFeature(k, "CREDENTIALS_SSO", "s");
      else P50.setCredentialFeature(k, "CREDENTIALS_SSO_LEGACY", "u");
      return k
    }, "resolveSSOCredentials"),
    f50 = mI1((A, B) => {
      let {
        sso_start_url: Q,
        sso_account_id: I,
        sso_region: G,
        sso_role_name: Z
      } = A;
      if (!Q || !I || !G || !Z) throw new TC.CredentialsProviderError(`Profile is configured with invalid SSO credentials. Required parameters "sso_account_id", "sso_region", "sso_role_name", "sso_start_url". Got ${Object.keys(A).join(", ")}
Reference: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html`, {
        tryNextLink: !1,
        logger: B
      });
      return A
    }, "validateSsoProfile"),
    WM4 = mI1((A = {}) => async ({
      callerClientConfig: B
    } = {}) => {
      A.logger?.debug("@aws-sdk/credential-provider-sso - fromSSO");
      let {
        ssoStartUrl: Q,
        ssoAccountId: I,
        ssoRegion: G,
        ssoRoleName: Z,
        ssoSession: D
      } = A, {
        ssoClient: Y
      } = A, W = gI1.getProfileName({
        profile: A.profile ?? B?.profile
      });
      if (!Q && !I && !G && !Z && !D) {
        let F = (await gI1.parseKnownFiles(A))[W];
        if (!F) throw new TC.CredentialsProviderError(`Profile ${W} was not found.`, {
          logger: A.logger
        });
        if (!x50(F)) throw new TC.CredentialsProviderError(`Profile ${W} is not configured with SSO credentials.`, {
          logger: A.logger
        });
        if (F?.sso_session) {
          let q = (await gI1.loadSsoSessionData(A))[F.sso_session],
            O = ` configurations in profile ${W} and sso-session ${F.sso_session}`;
          if (G && G !== q.sso_region) throw new TC.CredentialsProviderError("Conflicting SSO region" + O, {
            tryNextLink: !1,
            logger: A.logger
          });
          if (Q && Q !== q.sso_start_url) throw new TC.CredentialsProviderError("Conflicting SSO start_url" + O, {
            tryNextLink: !1,
            logger: A.logger
          });
          F.sso_region = q.sso_region, F.sso_start_url = q.sso_start_url
        }
        let {
          sso_start_url: X,
          sso_account_id: V,
          sso_region: C,
          sso_role_name: K,
          sso_session: E
        } = f50(F, A.logger);
        return S50({
          ssoStartUrl: X,
          ssoSession: E,
          ssoAccountId: V,
          ssoRegion: C,
          ssoRoleName: K,
          ssoClient: Y,
          clientConfig: A.clientConfig,
          parentClientConfig: A.parentClientConfig,
          profile: W
        })
      } else if (!Q || !I || !G || !Z) throw new TC.CredentialsProviderError('Incomplete configuration. The fromSSO() argument hash must include "ssoStartUrl", "ssoAccountId", "ssoRegion", "ssoRoleName"', {
        tryNextLink: !1,
        logger: A.logger
      });
      else return S50({
        ssoStartUrl: Q,
        ssoSession: D,
        ssoAccountId: I,
        ssoRegion: G,
        ssoRoleName: Z,
        ssoClient: Y,
        clientConfig: A.clientConfig,
        parentClientConfig: A.parentClientConfig,
        profile: W
      })
    }, "fromSSO")
})
// @from(Start 3728250, End 3729890)
mk1 = z((b50) => {
  Object.defineProperty(b50, "__esModule", {
    value: !0
  });
  b50.resolveHttpAuthSchemeConfig = b50.resolveStsAuthConfig = b50.defaultSTSHttpAuthSchemeProvider = b50.defaultSTSHttpAuthSchemeParametersProvider = void 0;
  var JM4 = IB(),
    hk1 = ZX(),
    FM4 = ka(),
    XM4 = async (A, B, Q) => {
      return {
        operation: hk1.getSmithyContext(B).operation,
        region: await hk1.normalizeProvider(A.region)() || (() => {
          throw new Error("expected `region` to be configured for `aws.auth#sigv4`")
        })()
      }
    };
  b50.defaultSTSHttpAuthSchemeParametersProvider = XM4;

  function VM4(A) {
    return {
      schemeId: "aws.auth#sigv4",
      signingProperties: {
        name: "sts",
        region: A.region
      },
      propertiesExtractor: (B, Q) => ({
        signingProperties: {
          config: B,
          context: Q
        }
      })
    }
  }

  function CM4(A) {
    return {
      schemeId: "smithy.api#noAuth"
    }
  }
  var KM4 = (A) => {
    let B = [];
    switch (A.operation) {
      case "AssumeRoleWithWebIdentity": {
        B.push(CM4(A));
        break
      }
      default:
        B.push(VM4(A))
    }
    return B
  };
  b50.defaultSTSHttpAuthSchemeProvider = KM4;
  var HM4 = (A) => Object.assign(A, {
    stsClientCtor: FM4.STSClient
  });
  b50.resolveStsAuthConfig = HM4;
  var zM4 = (A) => {
    let B = b50.resolveStsAuthConfig(A),
      Q = JM4.resolveAwsSdkSigV4Config(B);
    return Object.assign(Q, {
      authSchemePreference: hk1.normalizeProvider(A.authSchemePreference ?? [])
    })
  };
  b50.resolveHttpAuthSchemeConfig = zM4
})
// @from(Start 3729896, End 3730783)
xa = z((m50) => {
  Object.defineProperty(m50, "__esModule", {
    value: !0
  });
  m50.commonParams = m50.resolveClientEndpointParameters = void 0;
  var UM4 = (A) => {
    return Object.assign(A, {
      useDualstackEndpoint: A.useDualstackEndpoint ?? !1,
      useFipsEndpoint: A.useFipsEndpoint ?? !1,
      useGlobalEndpoint: A.useGlobalEndpoint ?? !1,
      defaultSigningName: "sts"
    })
  };
  m50.resolveClientEndpointParameters = UM4;
  m50.commonParams = {
    UseGlobalEndpoint: {
      type: "builtInParams",
      name: "useGlobalEndpoint"
    },
    UseFIPS: {
      type: "builtInParams",
      name: "useFipsEndpoint"
    },
    Endpoint: {
      type: "builtInParams",
      name: "endpoint"
    },
    Region: {
      type: "builtInParams",
      name: "region"
    },
    UseDualStack: {
      type: "builtInParams",
      name: "useDualstackEndpoint"
    }
  }
})
// @from(Start 3730789, End 3738959)
X80 = z((J80) => {
  Object.defineProperty(J80, "__esModule", {
    value: !0
  });
  J80.ruleSet = void 0;
  var e50 = "required",
    n4 = "type",
    M5 = "fn",
    L5 = "argv",
    cL = "ref",
    u50 = !1,
    dk1 = !0,
    pL = "booleanEquals",
    TG = "stringEquals",
    A80 = "sigv4",
    B80 = "sts",
    Q80 = "us-east-1",
    oB = "endpoint",
    p50 = "https://sts.{Region}.{PartitionResult#dnsSuffix}",
    iz = "tree",
    nb = "error",
    pk1 = "getAttr",
    c50 = {
      [e50]: !1,
      [n4]: "String"
    },
    uk1 = {
      [e50]: !0,
      default: !1,
      [n4]: "Boolean"
    },
    I80 = {
      [cL]: "Endpoint"
    },
    l50 = {
      [M5]: "isSet",
      [L5]: [{
        [cL]: "Region"
      }]
    },
    PG = {
      [cL]: "Region"
    },
    i50 = {
      [M5]: "aws.partition",
      [L5]: [PG],
      assign: "PartitionResult"
    },
    G80 = {
      [cL]: "UseFIPS"
    },
    Z80 = {
      [cL]: "UseDualStack"
    },
    LZ = {
      url: "https://sts.amazonaws.com",
      properties: {
        authSchemes: [{
          name: A80,
          signingName: B80,
          signingRegion: Q80
        }]
      },
      headers: {}
    },
    zJ = {},
    n50 = {
      conditions: [{
        [M5]: TG,
        [L5]: [PG, "aws-global"]
      }],
      [oB]: LZ,
      [n4]: oB
    },
    D80 = {
      [M5]: pL,
      [L5]: [G80, !0]
    },
    Y80 = {
      [M5]: pL,
      [L5]: [Z80, !0]
    },
    a50 = {
      [M5]: pk1,
      [L5]: [{
        [cL]: "PartitionResult"
      }, "supportsFIPS"]
    },
    W80 = {
      [cL]: "PartitionResult"
    },
    s50 = {
      [M5]: pL,
      [L5]: [!0, {
        [M5]: pk1,
        [L5]: [W80, "supportsDualStack"]
      }]
    },
    r50 = [{
      [M5]: "isSet",
      [L5]: [I80]
    }],
    o50 = [D80],
    t50 = [Y80],
    $M4 = {
      version: "1.0",
      parameters: {
        Region: c50,
        UseDualStack: uk1,
        UseFIPS: uk1,
        Endpoint: c50,
        UseGlobalEndpoint: uk1
      },
      rules: [{
        conditions: [{
          [M5]: pL,
          [L5]: [{
            [cL]: "UseGlobalEndpoint"
          }, dk1]
        }, {
          [M5]: "not",
          [L5]: r50
        }, l50, i50, {
          [M5]: pL,
          [L5]: [G80, u50]
        }, {
          [M5]: pL,
          [L5]: [Z80, u50]
        }],
        rules: [{
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "ap-northeast-1"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "ap-south-1"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "ap-southeast-1"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "ap-southeast-2"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, n50, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "ca-central-1"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "eu-central-1"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "eu-north-1"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "eu-west-1"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "eu-west-2"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "eu-west-3"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "sa-east-1"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, Q80]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "us-east-2"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "us-west-1"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          conditions: [{
            [M5]: TG,
            [L5]: [PG, "us-west-2"]
          }],
          endpoint: LZ,
          [n4]: oB
        }, {
          endpoint: {
            url: p50,
            properties: {
              authSchemes: [{
                name: A80,
                signingName: B80,
                signingRegion: "{Region}"
              }]
            },
            headers: zJ
          },
          [n4]: oB
        }],
        [n4]: iz
      }, {
        conditions: r50,
        rules: [{
          conditions: o50,
          error: "Invalid Configuration: FIPS and custom endpoint are not supported",
          [n4]: nb
        }, {
          conditions: t50,
          error: "Invalid Configuration: Dualstack and custom endpoint are not supported",
          [n4]: nb
        }, {
          endpoint: {
            url: I80,
            properties: zJ,
            headers: zJ
          },
          [n4]: oB
        }],
        [n4]: iz
      }, {
        conditions: [l50],
        rules: [{
          conditions: [i50],
          rules: [{
            conditions: [D80, Y80],
            rules: [{
              conditions: [{
                [M5]: pL,
                [L5]: [dk1, a50]
              }, s50],
              rules: [{
                endpoint: {
                  url: "https://sts-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
                  properties: zJ,
                  headers: zJ
                },
                [n4]: oB
              }],
              [n4]: iz
            }, {
              error: "FIPS and DualStack are enabled, but this partition does not support one or both",
              [n4]: nb
            }],
            [n4]: iz
          }, {
            conditions: o50,
            rules: [{
              conditions: [{
                [M5]: pL,
                [L5]: [a50, dk1]
              }],
              rules: [{
                conditions: [{
                  [M5]: TG,
                  [L5]: [{
                    [M5]: pk1,
                    [L5]: [W80, "name"]
                  }, "aws-us-gov"]
                }],
                endpoint: {
                  url: "https://sts.{Region}.amazonaws.com",
                  properties: zJ,
                  headers: zJ
                },
                [n4]: oB
              }, {
                endpoint: {
                  url: "https://sts-fips.{Region}.{PartitionResult#dnsSuffix}",
                  properties: zJ,
                  headers: zJ
                },
                [n4]: oB
              }],
              [n4]: iz
            }, {
              error: "FIPS is enabled but this partition does not support FIPS",
              [n4]: nb
            }],
            [n4]: iz
          }, {
            conditions: t50,
            rules: [{
              conditions: [s50],
              rules: [{
                endpoint: {
                  url: "https://sts.{Region}.{PartitionResult#dualStackDnsSuffix}",
                  properties: zJ,
                  headers: zJ
                },
                [n4]: oB
              }],
              [n4]: iz
            }, {
              error: "DualStack is enabled but this partition does not support DualStack",
              [n4]: nb
            }],
            [n4]: iz
          }, n50, {
            endpoint: {
              url: p50,
              properties: zJ,
              headers: zJ
            },
            [n4]: oB
          }],
          [n4]: iz
        }],
        [n4]: iz
      }, {
        error: "Invalid Configuration: Missing Region",
        [n4]: nb
      }]
    };
  J80.ruleSet = $M4
})
// @from(Start 3738965, End 3739544)
K80 = z((V80) => {
  Object.defineProperty(V80, "__esModule", {
    value: !0
  });
  V80.defaultEndpointResolver = void 0;
  var qM4 = RL(),
    ck1 = LL(),
    MM4 = X80(),
    LM4 = new ck1.EndpointCache({
      size: 50,
      params: ["Endpoint", "Region", "UseDualStack", "UseFIPS", "UseGlobalEndpoint"]
    }),
    RM4 = (A, B = {}) => {
      return LM4.get(A, () => ck1.resolveEndpoint(MM4.ruleSet, {
        endpointParams: A,
        logger: B.logger
      }))
    };
  V80.defaultEndpointResolver = RM4;
  ck1.customEndpointFunctions.aws = qM4.awsEndpointFunctions
})
// @from(Start 3739550, End 3740960)
U80 = z((w80) => {
  Object.defineProperty(w80, "__esModule", {
    value: !0
  });
  w80.getRuntimeConfig = void 0;
  var OM4 = IB(),
    TM4 = NI(),
    PM4 = p3(),
    SM4 = FN(),
    H80 = _k1(),
    z80 = RQ(),
    _M4 = mk1(),
    jM4 = K80(),
    yM4 = (A) => {
      return {
        apiVersion: "2011-06-15",
        base64Decoder: A?.base64Decoder ?? H80.fromBase64,
        base64Encoder: A?.base64Encoder ?? H80.toBase64,
        disableHostPrefix: A?.disableHostPrefix ?? !1,
        endpointProvider: A?.endpointProvider ?? jM4.defaultEndpointResolver,
        extensions: A?.extensions ?? [],
        httpAuthSchemeProvider: A?.httpAuthSchemeProvider ?? _M4.defaultSTSHttpAuthSchemeProvider,
        httpAuthSchemes: A?.httpAuthSchemes ?? [{
          schemeId: "aws.auth#sigv4",
          identityProvider: (B) => B.getIdentityProvider("aws.auth#sigv4"),
          signer: new OM4.AwsSdkSigV4Signer
        }, {
          schemeId: "smithy.api#noAuth",
          identityProvider: (B) => B.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
          signer: new TM4.NoAuthSigner
        }],
        logger: A?.logger ?? new PM4.NoOpLogger,
        serviceId: A?.serviceId ?? "STS",
        urlParser: A?.urlParser ?? SM4.parseUrl,
        utf8Decoder: A?.utf8Decoder ?? z80.fromUtf8,
        utf8Encoder: A?.utf8Encoder ?? z80.toUtf8
      }
    };
  w80.getRuntimeConfig = yM4
})
// @from(Start 3740966, End 3743566)
O80 = z((L80) => {
  Object.defineProperty(L80, "__esModule", {
    value: !0
  });
  L80.getRuntimeConfig = void 0;
  var kM4 = Ok1(),
    xM4 = kM4.__importDefault(Tk1()),
    N80 = IB(),
    $80 = I_(),
    uI1 = _D(),
    fM4 = NI(),
    vM4 = G_(),
    q80 = KJ(),
    ab = qC(),
    M80 = DN(),
    bM4 = Z_(),
    gM4 = vL(),
    hM4 = U80(),
    mM4 = p3(),
    dM4 = Y_(),
    uM4 = p3(),
    pM4 = (A) => {
      uM4.emitWarningIfUnsupportedVersion(process.version);
      let B = dM4.resolveDefaultsModeConfig(A),
        Q = () => B().then(mM4.loadConfigsForDefaultMode),
        I = hM4.getRuntimeConfig(A);
      N80.emitWarningIfUnsupportedVersion(process.version);
      let G = {
        profile: A?.profile
      };
      return {
        ...I,
        ...A,
        runtime: "node",
        defaultsMode: B,
        bodyLengthChecker: A?.bodyLengthChecker ?? bM4.calculateBodyLength,
        defaultUserAgentProvider: A?.defaultUserAgentProvider ?? $80.createDefaultUserAgentProvider({
          serviceId: I.serviceId,
          clientVersion: xM4.default.version
        }),
        httpAuthSchemes: A?.httpAuthSchemes ?? [{
          schemeId: "aws.auth#sigv4",
          identityProvider: (Z) => Z.getIdentityProvider("aws.auth#sigv4") || (async (D) => await A.credentialDefaultProvider(D?.__config || {})()),
          signer: new N80.AwsSdkSigV4Signer
        }, {
          schemeId: "smithy.api#noAuth",
          identityProvider: (Z) => Z.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
          signer: new fM4.NoAuthSigner
        }],
        maxAttempts: A?.maxAttempts ?? ab.loadConfig(q80.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, A),
        region: A?.region ?? ab.loadConfig(uI1.NODE_REGION_CONFIG_OPTIONS, {
          ...uI1.NODE_REGION_CONFIG_FILE_OPTIONS,
          ...G
        }),
        requestHandler: M80.NodeHttpHandler.create(A?.requestHandler ?? Q),
        retryMode: A?.retryMode ?? ab.loadConfig({
          ...q80.NODE_RETRY_MODE_CONFIG_OPTIONS,
          default: async () => (await Q()).retryMode || gM4.DEFAULT_RETRY_MODE
        }, A),
        sha256: A?.sha256 ?? vM4.Hash.bind(null, "sha256"),
        streamCollector: A?.streamCollector ?? M80.streamCollector,
        useDualstackEndpoint: A?.useDualstackEndpoint ?? ab.loadConfig(uI1.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, G),
        useFipsEndpoint: A?.useFipsEndpoint ?? ab.loadConfig(uI1.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, G),
        userAgentAppId: A?.userAgentAppId ?? ab.loadConfig($80.NODE_APP_ID_CONFIG_OPTIONS, G)
      }
    };
  L80.getRuntimeConfig = pM4
})
// @from(Start 3743572, End 3744591)
S80 = z((T80) => {
  Object.defineProperty(T80, "__esModule", {
    value: !0
  });
  T80.resolveHttpAuthRuntimeConfig = T80.getHttpAuthExtensionConfiguration = void 0;
  var cM4 = (A) => {
    let {
      httpAuthSchemes: B,
      httpAuthSchemeProvider: Q,
      credentials: I
    } = A;
    return {
      setHttpAuthScheme(G) {
        let Z = B.findIndex((D) => D.schemeId === G.schemeId);
        if (Z === -1) B.push(G);
        else B.splice(Z, 1, G)
      },
      httpAuthSchemes() {
        return B
      },
      setHttpAuthSchemeProvider(G) {
        Q = G
      },
      httpAuthSchemeProvider() {
        return Q
      },
      setCredentials(G) {
        I = G
      },
      credentials() {
        return I
      }
    }
  };
  T80.getHttpAuthExtensionConfiguration = cM4;
  var lM4 = (A) => {
    return {
      httpAuthSchemes: A.httpAuthSchemes(),
      httpAuthSchemeProvider: A.httpAuthSchemeProvider(),
      credentials: A.credentials()
    }
  };
  T80.resolveHttpAuthRuntimeConfig = lM4
})
// @from(Start 3744597, End 3745282)
v80 = z((x80) => {
  Object.defineProperty(x80, "__esModule", {
    value: !0
  });
  x80.resolveRuntimeExtensions = void 0;
  var _80 = W_(),
    j80 = vI1(),
    y80 = p3(),
    k80 = S80(),
    nM4 = (A, B) => {
      let Q = Object.assign(_80.getAwsRegionExtensionConfiguration(A), y80.getDefaultExtensionConfiguration(A), j80.getHttpHandlerExtensionConfiguration(A), k80.getHttpAuthExtensionConfiguration(A));
      return B.forEach((I) => I.configure(Q)), Object.assign(A, _80.resolveAwsRegionExtensionConfiguration(Q), y80.resolveDefaultRuntimeConfig(Q), j80.resolveHttpHandlerRuntimeConfig(Q), k80.resolveHttpAuthRuntimeConfig(Q))
    };
  x80.resolveRuntimeExtensions = nM4
})
// @from(Start 3745288, End 3747179)
ka = z((ik1) => {
  Object.defineProperty(ik1, "__esModule", {
    value: !0
  });
  ik1.STSClient = ik1.__Client = void 0;
  var b80 = cS(),
    aM4 = lS(),
    sM4 = iS(),
    g80 = jL(),
    rM4 = _D(),
    lk1 = NI(),
    oM4 = tS(),
    tM4 = hz(),
    h80 = KJ(),
    d80 = p3();
  Object.defineProperty(ik1, "__Client", {
    enumerable: !0,
    get: function() {
      return d80.Client
    }
  });
  var m80 = mk1(),
    eM4 = xa(),
    AL4 = O80(),
    BL4 = v80();
  class u80 extends d80.Client {
    config;
    constructor(...[A]) {
      let B = AL4.getRuntimeConfig(A || {});
      super(B);
      this.initConfig = B;
      let Q = eM4.resolveClientEndpointParameters(B),
        I = g80.resolveUserAgentConfig(Q),
        G = h80.resolveRetryConfig(I),
        Z = rM4.resolveRegionConfig(G),
        D = b80.resolveHostHeaderConfig(Z),
        Y = tM4.resolveEndpointConfig(D),
        W = m80.resolveHttpAuthSchemeConfig(Y),
        J = BL4.resolveRuntimeExtensions(W, A?.extensions || []);
      this.config = J, this.middlewareStack.use(g80.getUserAgentPlugin(this.config)), this.middlewareStack.use(h80.getRetryPlugin(this.config)), this.middlewareStack.use(oM4.getContentLengthPlugin(this.config)), this.middlewareStack.use(b80.getHostHeaderPlugin(this.config)), this.middlewareStack.use(aM4.getLoggerPlugin(this.config)), this.middlewareStack.use(sM4.getRecursionDetectionPlugin(this.config)), this.middlewareStack.use(lk1.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
        httpAuthSchemeParametersProvider: m80.defaultSTSHttpAuthSchemeParametersProvider,
        identityProviderConfigProvider: async (F) => new lk1.DefaultIdentityProviderConfig({
          "aws.auth#sigv4": F.credentials
        })
      })), this.middlewareStack.use(lk1.getHttpSigningPlugin(this.config))
    }
    destroy() {
      super.destroy()
    }
  }
  ik1.STSClient = u80
})
// @from(Start 3747185, End 3770297)
cI1 = z((KZ8, qx1) => {
  var {
    defineProperty: pI1,
    getOwnPropertyDescriptor: QL4,
    getOwnPropertyNames: IL4
  } = Object, GL4 = Object.prototype.hasOwnProperty, a2 = (A, B) => pI1(A, "name", {
    value: B,
    configurable: !0
  }), ZL4 = (A, B) => {
    for (var Q in B) pI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, Hx1 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of IL4(B))
        if (!GL4.call(A, G) && G !== Q) pI1(A, G, {
          get: () => B[G],
          enumerable: !(I = QL4(B, G)) || I.enumerable
        })
    }
    return A
  }, DL4 = (A, B, Q) => (Hx1(A, B, "default"), Q && Hx1(Q, B, "default")), YL4 = (A) => Hx1(pI1({}, "__esModule", {
    value: !0
  }), A), wx1 = {};
  ZL4(wx1, {
    AssumeRoleCommand: () => Nx1,
    AssumeRoleResponseFilterSensitiveLog: () => i80,
    AssumeRoleWithWebIdentityCommand: () => $x1,
    AssumeRoleWithWebIdentityRequestFilterSensitiveLog: () => e80,
    AssumeRoleWithWebIdentityResponseFilterSensitiveLog: () => AB0,
    ClientInputEndpointParameters: () => eL4.ClientInputEndpointParameters,
    CredentialsFilterSensitiveLog: () => Ex1,
    ExpiredTokenException: () => n80,
    IDPCommunicationErrorException: () => BB0,
    IDPRejectedClaimException: () => o80,
    InvalidIdentityTokenException: () => t80,
    MalformedPolicyDocumentException: () => a80,
    PackedPolicyTooLargeException: () => s80,
    RegionDisabledException: () => r80,
    STS: () => VB0,
    STSServiceException: () => zN,
    decorateDefaultCredentialProvider: () => QR4,
    getDefaultRoleAssumer: () => EB0,
    getDefaultRoleAssumerWithWebIdentity: () => UB0
  });
  qx1.exports = YL4(wx1);
  DL4(wx1, ka(), qx1.exports);
  var WL4 = p3(),
    JL4 = hz(),
    FL4 = yz(),
    XL4 = p3(),
    VL4 = xa(),
    l80 = p3(),
    CL4 = p3(),
    zN = class A extends CL4.ServiceException {
      static {
        a2(this, "STSServiceException")
      }
      constructor(B) {
        super(B);
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    Ex1 = a2((A) => ({
      ...A,
      ...A.SecretAccessKey && {
        SecretAccessKey: l80.SENSITIVE_STRING
      }
    }), "CredentialsFilterSensitiveLog"),
    i80 = a2((A) => ({
      ...A,
      ...A.Credentials && {
        Credentials: Ex1(A.Credentials)
      }
    }), "AssumeRoleResponseFilterSensitiveLog"),
    n80 = class A extends zN {
      static {
        a2(this, "ExpiredTokenException")
      }
      name = "ExpiredTokenException";
      $fault = "client";
      constructor(B) {
        super({
          name: "ExpiredTokenException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    a80 = class A extends zN {
      static {
        a2(this, "MalformedPolicyDocumentException")
      }
      name = "MalformedPolicyDocumentException";
      $fault = "client";
      constructor(B) {
        super({
          name: "MalformedPolicyDocumentException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    s80 = class A extends zN {
      static {
        a2(this, "PackedPolicyTooLargeException")
      }
      name = "PackedPolicyTooLargeException";
      $fault = "client";
      constructor(B) {
        super({
          name: "PackedPolicyTooLargeException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    r80 = class A extends zN {
      static {
        a2(this, "RegionDisabledException")
      }
      name = "RegionDisabledException";
      $fault = "client";
      constructor(B) {
        super({
          name: "RegionDisabledException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    o80 = class A extends zN {
      static {
        a2(this, "IDPRejectedClaimException")
      }
      name = "IDPRejectedClaimException";
      $fault = "client";
      constructor(B) {
        super({
          name: "IDPRejectedClaimException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    t80 = class A extends zN {
      static {
        a2(this, "InvalidIdentityTokenException")
      }
      name = "InvalidIdentityTokenException";
      $fault = "client";
      constructor(B) {
        super({
          name: "InvalidIdentityTokenException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    e80 = a2((A) => ({
      ...A,
      ...A.WebIdentityToken && {
        WebIdentityToken: l80.SENSITIVE_STRING
      }
    }), "AssumeRoleWithWebIdentityRequestFilterSensitiveLog"),
    AB0 = a2((A) => ({
      ...A,
      ...A.Credentials && {
        Credentials: Ex1(A.Credentials)
      }
    }), "AssumeRoleWithWebIdentityResponseFilterSensitiveLog"),
    BB0 = class A extends zN {
      static {
        a2(this, "IDPCommunicationErrorException")
      }
      name = "IDPCommunicationErrorException";
      $fault = "client";
      constructor(B) {
        super({
          name: "IDPCommunicationErrorException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    Ux1 = IB(),
    KL4 = vI1(),
    m5 = p3(),
    HL4 = a2(async (A, B) => {
      let Q = YB0,
        I;
      return I = XB0({
        ...OL4(A, B),
        [JB0]: cL4,
        [FB0]: WB0
      }), DB0(B, Q, "/", void 0, I)
    }, "se_AssumeRoleCommand"),
    zL4 = a2(async (A, B) => {
      let Q = YB0,
        I;
      return I = XB0({
        ...TL4(A, B),
        [JB0]: lL4,
        [FB0]: WB0
      }), DB0(B, Q, "/", void 0, I)
    }, "se_AssumeRoleWithWebIdentityCommand"),
    wL4 = a2(async (A, B) => {
      if (A.statusCode >= 300) return QB0(A, B);
      let Q = await Ux1.parseXmlBody(A.body, B),
        I = {};
      return I = xL4(Q.AssumeRoleResult, B), {
        $metadata: wN(A),
        ...I
      }
    }, "de_AssumeRoleCommand"),
    EL4 = a2(async (A, B) => {
      if (A.statusCode >= 300) return QB0(A, B);
      let Q = await Ux1.parseXmlBody(A.body, B),
        I = {};
      return I = fL4(Q.AssumeRoleWithWebIdentityResult, B), {
        $metadata: wN(A),
        ...I
      }
    }, "de_AssumeRoleWithWebIdentityCommand"),
    QB0 = a2(async (A, B) => {
      let Q = {
          ...A,
          body: await Ux1.parseXmlErrorBody(A.body, B)
        },
        I = iL4(A, Q.body);
      switch (I) {
        case "ExpiredTokenException":
        case "com.amazonaws.sts#ExpiredTokenException":
          throw await UL4(Q, B);
        case "MalformedPolicyDocument":
        case "com.amazonaws.sts#MalformedPolicyDocumentException":
          throw await ML4(Q, B);
        case "PackedPolicyTooLarge":
        case "com.amazonaws.sts#PackedPolicyTooLargeException":
          throw await LL4(Q, B);
        case "RegionDisabledException":
        case "com.amazonaws.sts#RegionDisabledException":
          throw await RL4(Q, B);
        case "IDPCommunicationError":
        case "com.amazonaws.sts#IDPCommunicationErrorException":
          throw await NL4(Q, B);
        case "IDPRejectedClaim":
        case "com.amazonaws.sts#IDPRejectedClaimException":
          throw await $L4(Q, B);
        case "InvalidIdentityToken":
        case "com.amazonaws.sts#InvalidIdentityTokenException":
          throw await qL4(Q, B);
        default:
          let G = Q.body;
          return pL4({
            output: A,
            parsedBody: G.Error,
            errorCode: I
          })
      }
    }, "de_CommandError"),
    UL4 = a2(async (A, B) => {
      let Q = A.body,
        I = vL4(Q.Error, B),
        G = new n80({
          $metadata: wN(A),
          ...I
        });
      return m5.decorateServiceException(G, Q)
    }, "de_ExpiredTokenExceptionRes"),
    NL4 = a2(async (A, B) => {
      let Q = A.body,
        I = bL4(Q.Error, B),
        G = new BB0({
          $metadata: wN(A),
          ...I
        });
      return m5.decorateServiceException(G, Q)
    }, "de_IDPCommunicationErrorExceptionRes"),
    $L4 = a2(async (A, B) => {
      let Q = A.body,
        I = gL4(Q.Error, B),
        G = new o80({
          $metadata: wN(A),
          ...I
        });
      return m5.decorateServiceException(G, Q)
    }, "de_IDPRejectedClaimExceptionRes"),
    qL4 = a2(async (A, B) => {
      let Q = A.body,
        I = hL4(Q.Error, B),
        G = new t80({
          $metadata: wN(A),
          ...I
        });
      return m5.decorateServiceException(G, Q)
    }, "de_InvalidIdentityTokenExceptionRes"),
    ML4 = a2(async (A, B) => {
      let Q = A.body,
        I = mL4(Q.Error, B),
        G = new a80({
          $metadata: wN(A),
          ...I
        });
      return m5.decorateServiceException(G, Q)
    }, "de_MalformedPolicyDocumentExceptionRes"),
    LL4 = a2(async (A, B) => {
      let Q = A.body,
        I = dL4(Q.Error, B),
        G = new s80({
          $metadata: wN(A),
          ...I
        });
      return m5.decorateServiceException(G, Q)
    }, "de_PackedPolicyTooLargeExceptionRes"),
    RL4 = a2(async (A, B) => {
      let Q = A.body,
        I = uL4(Q.Error, B),
        G = new r80({
          $metadata: wN(A),
          ...I
        });
      return m5.decorateServiceException(G, Q)
    }, "de_RegionDisabledExceptionRes"),
    OL4 = a2((A, B) => {
      let Q = {};
      if (A[Bg] != null) Q[Bg] = A[Bg];
      if (A[Qg] != null) Q[Qg] = A[Qg];
      if (A[eb] != null) {
        let I = IB0(A[eb], B);
        if (A[eb]?.length === 0) Q.PolicyArns = [];
        Object.entries(I).forEach(([G, Z]) => {
          let D = `PolicyArns.${G}`;
          Q[D] = Z
        })
      }
      if (A[tb] != null) Q[tb] = A[tb];
      if (A[ob] != null) Q[ob] = A[ob];
      if (A[Jx1] != null) {
        let I = kL4(A[Jx1], B);
        if (A[Jx1]?.length === 0) Q.Tags = [];
        Object.entries(I).forEach(([G, Z]) => {
          let D = `Tags.${G}`;
          Q[D] = Z
        })
      }
      if (A[Xx1] != null) {
        let I = yL4(A[Xx1], B);
        if (A[Xx1]?.length === 0) Q.TransitiveTagKeys = [];
        Object.entries(I).forEach(([G, Z]) => {
          let D = `TransitiveTagKeys.${G}`;
          Q[D] = Z
        })
      }
      if (A[ek1] != null) Q[ek1] = A[ek1];
      if (A[Yx1] != null) Q[Yx1] = A[Yx1];
      if (A[Fx1] != null) Q[Fx1] = A[Fx1];
      if (A[HN] != null) Q[HN] = A[HN];
      if (A[Qx1] != null) {
        let I = _L4(A[Qx1], B);
        if (A[Qx1]?.length === 0) Q.ProvidedContexts = [];
        Object.entries(I).forEach(([G, Z]) => {
          let D = `ProvidedContexts.${G}`;
          Q[D] = Z
        })
      }
      return Q
    }, "se_AssumeRoleRequest"),
    TL4 = a2((A, B) => {
      let Q = {};
      if (A[Bg] != null) Q[Bg] = A[Bg];
      if (A[Qg] != null) Q[Qg] = A[Qg];
      if (A[Cx1] != null) Q[Cx1] = A[Cx1];
      if (A[Ix1] != null) Q[Ix1] = A[Ix1];
      if (A[eb] != null) {
        let I = IB0(A[eb], B);
        if (A[eb]?.length === 0) Q.PolicyArns = [];
        Object.entries(I).forEach(([G, Z]) => {
          let D = `PolicyArns.${G}`;
          Q[D] = Z
        })
      }
      if (A[tb] != null) Q[tb] = A[tb];
      if (A[ob] != null) Q[ob] = A[ob];
      return Q
    }, "se_AssumeRoleWithWebIdentityRequest"),
    IB0 = a2((A, B) => {
      let Q = {},
        I = 1;
      for (let G of A) {
        if (G === null) continue;
        let Z = PL4(G, B);
        Object.entries(Z).forEach(([D, Y]) => {
          Q[`member.${I}.${D}`] = Y
        }), I++
      }
      return Q
    }, "se_policyDescriptorListType"),
    PL4 = a2((A, B) => {
      let Q = {};
      if (A[Kx1] != null) Q[Kx1] = A[Kx1];
      return Q
    }, "se_PolicyDescriptorType"),
    SL4 = a2((A, B) => {
      let Q = {};
      if (A[Bx1] != null) Q[Bx1] = A[Bx1];
      if (A[ok1] != null) Q[ok1] = A[ok1];
      return Q
    }, "se_ProvidedContext"),
    _L4 = a2((A, B) => {
      let Q = {},
        I = 1;
      for (let G of A) {
        if (G === null) continue;
        let Z = SL4(G, B);
        Object.entries(Z).forEach(([D, Y]) => {
          Q[`member.${I}.${D}`] = Y
        }), I++
      }
      return Q
    }, "se_ProvidedContextsListType"),
    jL4 = a2((A, B) => {
      let Q = {};
      if (A[Ax1] != null) Q[Ax1] = A[Ax1];
      if (A[Vx1] != null) Q[Vx1] = A[Vx1];
      return Q
    }, "se_Tag"),
    yL4 = a2((A, B) => {
      let Q = {},
        I = 1;
      for (let G of A) {
        if (G === null) continue;
        Q[`member.${I}`] = G, I++
      }
      return Q
    }, "se_tagKeyListType"),
    kL4 = a2((A, B) => {
      let Q = {},
        I = 1;
      for (let G of A) {
        if (G === null) continue;
        let Z = jL4(G, B);
        Object.entries(Z).forEach(([D, Y]) => {
          Q[`member.${I}.${D}`] = Y
        }), I++
      }
      return Q
    }, "se_tagListType"),
    GB0 = a2((A, B) => {
      let Q = {};
      if (A[ak1] != null) Q[ak1] = m5.expectString(A[ak1]);
      if (A[sk1] != null) Q[sk1] = m5.expectString(A[sk1]);
      return Q
    }, "de_AssumedRoleUser"),
    xL4 = a2((A, B) => {
      let Q = {};
      if (A[rb] != null) Q[rb] = ZB0(A[rb], B);
      if (A[sb] != null) Q[sb] = GB0(A[sb], B);
      if (A[Ag] != null) Q[Ag] = m5.strictParseInt32(A[Ag]);
      if (A[HN] != null) Q[HN] = m5.expectString(A[HN]);
      return Q
    }, "de_AssumeRoleResponse"),
    fL4 = a2((A, B) => {
      let Q = {};
      if (A[rb] != null) Q[rb] = ZB0(A[rb], B);
      if (A[Dx1] != null) Q[Dx1] = m5.expectString(A[Dx1]);
      if (A[sb] != null) Q[sb] = GB0(A[sb], B);
      if (A[Ag] != null) Q[Ag] = m5.strictParseInt32(A[Ag]);
      if (A[Gx1] != null) Q[Gx1] = m5.expectString(A[Gx1]);
      if (A[rk1] != null) Q[rk1] = m5.expectString(A[rk1]);
      if (A[HN] != null) Q[HN] = m5.expectString(A[HN]);
      return Q
    }, "de_AssumeRoleWithWebIdentityResponse"),
    ZB0 = a2((A, B) => {
      let Q = {};
      if (A[nk1] != null) Q[nk1] = m5.expectString(A[nk1]);
      if (A[Zx1] != null) Q[Zx1] = m5.expectString(A[Zx1]);
      if (A[Wx1] != null) Q[Wx1] = m5.expectString(A[Wx1]);
      if (A[tk1] != null) Q[tk1] = m5.expectNonNull(m5.parseRfc3339DateTimeWithOffset(A[tk1]));
      return Q
    }, "de_Credentials"),
    vL4 = a2((A, B) => {
      let Q = {};
      if (A[TQ] != null) Q[TQ] = m5.expectString(A[TQ]);
      return Q
    }, "de_ExpiredTokenException"),
    bL4 = a2((A, B) => {
      let Q = {};
      if (A[TQ] != null) Q[TQ] = m5.expectString(A[TQ]);
      return Q
    }, "de_IDPCommunicationErrorException"),
    gL4 = a2((A, B) => {
      let Q = {};
      if (A[TQ] != null) Q[TQ] = m5.expectString(A[TQ]);
      return Q
    }, "de_IDPRejectedClaimException"),
    hL4 = a2((A, B) => {
      let Q = {};
      if (A[TQ] != null) Q[TQ] = m5.expectString(A[TQ]);
      return Q
    }, "de_InvalidIdentityTokenException"),
    mL4 = a2((A, B) => {
      let Q = {};
      if (A[TQ] != null) Q[TQ] = m5.expectString(A[TQ]);
      return Q
    }, "de_MalformedPolicyDocumentException"),
    dL4 = a2((A, B) => {
      let Q = {};
      if (A[TQ] != null) Q[TQ] = m5.expectString(A[TQ]);
      return Q
    }, "de_PackedPolicyTooLargeException"),
    uL4 = a2((A, B) => {
      let Q = {};
      if (A[TQ] != null) Q[TQ] = m5.expectString(A[TQ]);
      return Q
    }, "de_RegionDisabledException"),
    wN = a2((A) => ({
      httpStatusCode: A.statusCode,
      requestId: A.headers["x-amzn-requestid"] ?? A.headers["x-amzn-request-id"] ?? A.headers["x-amz-request-id"],
      extendedRequestId: A.headers["x-amz-id-2"],
      cfId: A.headers["x-amz-cf-id"]
    }), "deserializeMetadata"),
    pL4 = m5.withBaseException(zN),
    DB0 = a2(async (A, B, Q, I, G) => {
      let {
        hostname: Z,
        protocol: D = "https",
        port: Y,
        path: W
      } = await A.endpoint(), J = {
        protocol: D,
        hostname: Z,
        port: Y,
        method: "POST",
        path: W.endsWith("/") ? W.slice(0, -1) + Q : W + Q,
        headers: B
      };
      if (I !== void 0) J.hostname = I;
      if (G !== void 0) J.body = G;
      return new KL4.HttpRequest(J)
    }, "buildHttpRpcRequest"),
    YB0 = {
      "content-type": "application/x-www-form-urlencoded"
    },
    WB0 = "2011-06-15",
    JB0 = "Action",
    nk1 = "AccessKeyId",
    cL4 = "AssumeRole",
    ak1 = "AssumedRoleId",
    sb = "AssumedRoleUser",
    lL4 = "AssumeRoleWithWebIdentity",
    sk1 = "Arn",
    rk1 = "Audience",
    rb = "Credentials",
    ok1 = "ContextAssertion",
    ob = "DurationSeconds",
    tk1 = "Expiration",
    ek1 = "ExternalId",
    Ax1 = "Key",
    tb = "Policy",
    eb = "PolicyArns",
    Bx1 = "ProviderArn",
    Qx1 = "ProvidedContexts",
    Ix1 = "ProviderId",
    Ag = "PackedPolicySize",
    Gx1 = "Provider",
    Bg = "RoleArn",
    Qg = "RoleSessionName",
    Zx1 = "SecretAccessKey",
    Dx1 = "SubjectFromWebIdentityToken",
    HN = "SourceIdentity",
    Yx1 = "SerialNumber",
    Wx1 = "SessionToken",
    Jx1 = "Tags",
    Fx1 = "TokenCode",
    Xx1 = "TransitiveTagKeys",
    FB0 = "Version",
    Vx1 = "Value",
    Cx1 = "WebIdentityToken",
    Kx1 = "arn",
    TQ = "message",
    XB0 = a2((A) => Object.entries(A).map(([B, Q]) => m5.extendedEncodeURIComponent(B) + "=" + m5.extendedEncodeURIComponent(Q)).join("&"), "buildFormUrlencodedString"),
    iL4 = a2((A, B) => {
      if (B.Error?.Code !== void 0) return B.Error.Code;
      if (A.statusCode == 404) return "NotFound"
    }, "loadQueryErrorCode"),
    Nx1 = class extends XL4.Command.classBuilder().ep(VL4.commonParams).m(function(A, B, Q, I) {
      return [FL4.getSerdePlugin(Q, this.serialize, this.deserialize), JL4.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AWSSecurityTokenServiceV20110615", "AssumeRole", {}).n("STSClient", "AssumeRoleCommand").f(void 0, i80).ser(HL4).de(wL4).build() {
      static {
        a2(this, "AssumeRoleCommand")
      }
    },
    nL4 = hz(),
    aL4 = yz(),
    sL4 = p3(),
    rL4 = xa(),
    $x1 = class extends sL4.Command.classBuilder().ep(rL4.commonParams).m(function(A, B, Q, I) {
      return [aL4.getSerdePlugin(Q, this.serialize, this.deserialize), nL4.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AWSSecurityTokenServiceV20110615", "AssumeRoleWithWebIdentity", {}).n("STSClient", "AssumeRoleWithWebIdentityCommand").f(e80, AB0).ser(zL4).de(EL4).build() {
      static {
        a2(this, "AssumeRoleWithWebIdentityCommand")
      }
    },
    oL4 = ka(),
    tL4 = {
      AssumeRoleCommand: Nx1,
      AssumeRoleWithWebIdentityCommand: $x1
    },
    VB0 = class extends oL4.STSClient {
      static {
        a2(this, "STS")
      }
    };
  WL4.createAggregatedClient(tL4, VB0);
  var eL4 = xa(),
    zx1 = NC(),
    c80 = "us-east-1",
    CB0 = a2((A) => {
      if (typeof A?.Arn === "string") {
        let B = A.Arn.split(":");
        if (B.length > 4 && B[4] !== "") return B[4]
      }
      return
    }, "getAccountIdFromAssumedRoleUser"),
    KB0 = a2(async (A, B, Q) => {
      let I = typeof A === "function" ? await A() : A,
        G = typeof B === "function" ? await B() : B;
      return Q?.debug?.("@aws-sdk/client-sts::resolveRegion", "accepting first of:", `${I} (provider)`, `${G} (parent client)`, `${c80} (STS default)`), I ?? G ?? c80
    }, "resolveRegion"),
    AR4 = a2((A, B) => {
      let Q, I;
      return async (G, Z) => {
        if (I = G, !Q) {
          let {
            logger: F = A?.parentClientConfig?.logger,
            region: X,
            requestHandler: V = A?.parentClientConfig?.requestHandler,
            credentialProviderLogger: C
          } = A, K = await KB0(X, A?.parentClientConfig?.region, C), E = !HB0(V);
          Q = new B({
            profile: A?.parentClientConfig?.profile,
            credentialDefaultProvider: a2(() => async () => I, "credentialDefaultProvider"),
            region: K,
            requestHandler: E ? V : void 0,
            logger: F
          })
        }
        let {
          Credentials: D,
          AssumedRoleUser: Y
        } = await Q.send(new Nx1(Z));
        if (!D || !D.AccessKeyId || !D.SecretAccessKey) throw new Error(`Invalid response from STS.assumeRole call with role ${Z.RoleArn}`);
        let W = CB0(Y),
          J = {
            accessKeyId: D.AccessKeyId,
            secretAccessKey: D.SecretAccessKey,
            sessionToken: D.SessionToken,
            expiration: D.Expiration,
            ...D.CredentialScope && {
              credentialScope: D.CredentialScope
            },
            ...W && {
              accountId: W
            }
          };
        return zx1.setCredentialFeature(J, "CREDENTIALS_STS_ASSUME_ROLE", "i"), J
      }
    }, "getDefaultRoleAssumer"),
    BR4 = a2((A, B) => {
      let Q;
      return async (I) => {
        if (!Q) {
          let {
            logger: W = A?.parentClientConfig?.logger,
            region: J,
            requestHandler: F = A?.parentClientConfig?.requestHandler,
            credentialProviderLogger: X
          } = A, V = await KB0(J, A?.parentClientConfig?.region, X), C = !HB0(F);
          Q = new B({
            profile: A?.parentClientConfig?.profile,
            region: V,
            requestHandler: C ? F : void 0,
            logger: W
          })
        }
        let {
          Credentials: G,
          AssumedRoleUser: Z
        } = await Q.send(new $x1(I));
        if (!G || !G.AccessKeyId || !G.SecretAccessKey) throw new Error(`Invalid response from STS.assumeRoleWithWebIdentity call with role ${I.RoleArn}`);
        let D = CB0(Z),
          Y = {
            accessKeyId: G.AccessKeyId,
            secretAccessKey: G.SecretAccessKey,
            sessionToken: G.SessionToken,
            expiration: G.Expiration,
            ...G.CredentialScope && {
              credentialScope: G.CredentialScope
            },
            ...D && {
              accountId: D
            }
          };
        if (D) zx1.setCredentialFeature(Y, "RESOLVED_ACCOUNT_ID", "T");
        return zx1.setCredentialFeature(Y, "CREDENTIALS_STS_ASSUME_ROLE_WEB_ID", "k"), Y
      }
    }, "getDefaultRoleAssumerWithWebIdentity"),
    HB0 = a2((A) => {
      return A?.metadata?.handlerProtocol === "h2"
    }, "isH2"),
    zB0 = ka(),
    wB0 = a2((A, B) => {
      if (!B) return A;
      else return class Q extends A {
        static {
          a2(this, "CustomizableSTSClient")
        }
        constructor(I) {
          super(I);
          for (let G of B) this.middlewareStack.use(G)
        }
      }
    }, "getCustomizableStsClientCtor"),
    EB0 = a2((A = {}, B) => AR4(A, wB0(zB0.STSClient, B)), "getDefaultRoleAssumer"),
    UB0 = a2((A = {}, B) => BR4(A, wB0(zB0.STSClient, B)), "getDefaultRoleAssumerWithWebIdentity"),
    QR4 = a2((A) => (B) => A({
      roleAssumer: EB0(B),
      roleAssumerWithWebIdentity: UB0(B),
      ...B
    }), "decorateDefaultCredentialProvider")
})
// @from(Start 3770303, End 3773525)
iI1 = z((EZ8, qB0) => {
  var {
    defineProperty: lI1,
    getOwnPropertyDescriptor: IR4,
    getOwnPropertyNames: GR4
  } = Object, ZR4 = Object.prototype.hasOwnProperty, Lx1 = (A, B) => lI1(A, "name", {
    value: B,
    configurable: !0
  }), DR4 = (A, B) => {
    for (var Q in B) lI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, YR4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of GR4(B))
        if (!ZR4.call(A, G) && G !== Q) lI1(A, G, {
          get: () => B[G],
          enumerable: !(I = IR4(B, G)) || I.enumerable
        })
    }
    return A
  }, WR4 = (A) => YR4(lI1({}, "__esModule", {
    value: !0
  }), A), $B0 = {};
  DR4($B0, {
    fromProcess: () => KR4
  });
  qB0.exports = WR4($B0);
  var NB0 = xL(),
    Mx1 = $I(),
    JR4 = Z1("child_process"),
    FR4 = Z1("util"),
    XR4 = NC(),
    VR4 = Lx1((A, B, Q) => {
      if (B.Version !== 1) throw Error(`Profile ${A} credential_process did not return Version 1.`);
      if (B.AccessKeyId === void 0 || B.SecretAccessKey === void 0) throw Error(`Profile ${A} credential_process returned invalid credentials.`);
      if (B.Expiration) {
        let Z = new Date;
        if (new Date(B.Expiration) < Z) throw Error(`Profile ${A} credential_process returned expired credentials.`)
      }
      let I = B.AccountId;
      if (!I && Q?.[A]?.aws_account_id) I = Q[A].aws_account_id;
      let G = {
        accessKeyId: B.AccessKeyId,
        secretAccessKey: B.SecretAccessKey,
        ...B.SessionToken && {
          sessionToken: B.SessionToken
        },
        ...B.Expiration && {
          expiration: new Date(B.Expiration)
        },
        ...B.CredentialScope && {
          credentialScope: B.CredentialScope
        },
        ...I && {
          accountId: I
        }
      };
      return XR4.setCredentialFeature(G, "CREDENTIALS_PROCESS", "w"), G
    }, "getValidatedProcessCredentials"),
    CR4 = Lx1(async (A, B, Q) => {
      let I = B[A];
      if (B[A]) {
        let G = I.credential_process;
        if (G !== void 0) {
          let Z = FR4.promisify(JR4.exec);
          try {
            let {
              stdout: D
            } = await Z(G), Y;
            try {
              Y = JSON.parse(D.trim())
            } catch {
              throw Error(`Profile ${A} credential_process returned invalid JSON.`)
            }
            return VR4(A, Y, B)
          } catch (D) {
            throw new Mx1.CredentialsProviderError(D.message, {
              logger: Q
            })
          }
        } else throw new Mx1.CredentialsProviderError(`Profile ${A} did not contain credential_process.`, {
          logger: Q
        })
      } else throw new Mx1.CredentialsProviderError(`Profile ${A} could not be found in shared credentials file.`, {
        logger: Q
      })
    }, "resolveProcessCredentials"),
    KR4 = Lx1((A = {}) => async ({
      callerClientConfig: B
    } = {}) => {
      A.logger?.debug("@aws-sdk/credential-provider-process - fromProcess");
      let Q = await NB0.parseKnownFiles(A);
      return CR4(NB0.getProfileName({
        profile: A.profile ?? B?.profile
      }), Q, A.logger)
    }, "fromProcess")
})
// @from(Start 3773531, End 3775556)
Rx1 = z((nz) => {
  var HR4 = nz && nz.__createBinding || (Object.create ? function(A, B, Q, I) {
      if (I === void 0) I = Q;
      var G = Object.getOwnPropertyDescriptor(B, Q);
      if (!G || ("get" in G ? !B.__esModule : G.writable || G.configurable)) G = {
        enumerable: !0,
        get: function() {
          return B[Q]
        }
      };
      Object.defineProperty(A, I, G)
    } : function(A, B, Q, I) {
      if (I === void 0) I = Q;
      A[I] = B[Q]
    }),
    zR4 = nz && nz.__setModuleDefault || (Object.create ? function(A, B) {
      Object.defineProperty(A, "default", {
        enumerable: !0,
        value: B
      })
    } : function(A, B) {
      A.default = B
    }),
    wR4 = nz && nz.__importStar || function(A) {
      if (A && A.__esModule) return A;
      var B = {};
      if (A != null) {
        for (var Q in A)
          if (Q !== "default" && Object.prototype.hasOwnProperty.call(A, Q)) HR4(B, A, Q)
      }
      return zR4(B, A), B
    };
  Object.defineProperty(nz, "__esModule", {
    value: !0
  });
  nz.fromWebToken = void 0;
  var ER4 = (A) => async (B) => {
    A.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");
    let {
      roleArn: Q,
      roleSessionName: I,
      webIdentityToken: G,
      providerId: Z,
      policyArns: D,
      policy: Y,
      durationSeconds: W
    } = A, {
      roleAssumerWithWebIdentity: J
    } = A;
    if (!J) {
      let {
        getDefaultRoleAssumerWithWebIdentity: F
      } = await Promise.resolve().then(() => wR4(cI1()));
      J = F({
        ...A.clientConfig,
        credentialProviderLogger: A.logger,
        parentClientConfig: {
          ...B?.callerClientConfig,
          ...A.parentClientConfig
        }
      }, A.clientPlugins)
    }
    return J({
      RoleArn: Q,
      RoleSessionName: I ?? `aws-sdk-js-session-${Date.now()}`,
      WebIdentityToken: G,
      ProviderId: Z,
      PolicyArns: D,
      Policy: Y,
      DurationSeconds: W
    })
  };
  nz.fromWebToken = ER4
})
// @from(Start 3775562, End 3776623)
OB0 = z((LB0) => {
  Object.defineProperty(LB0, "__esModule", {
    value: !0
  });
  LB0.fromTokenFile = void 0;
  var UR4 = NC(),
    NR4 = $I(),
    $R4 = Z1("fs"),
    qR4 = Rx1(),
    MB0 = "AWS_WEB_IDENTITY_TOKEN_FILE",
    MR4 = "AWS_ROLE_ARN",
    LR4 = "AWS_ROLE_SESSION_NAME",
    RR4 = (A = {}) => async () => {
      A.logger?.debug("@aws-sdk/credential-provider-web-identity - fromTokenFile");
      let B = A?.webIdentityTokenFile ?? process.env[MB0],
        Q = A?.roleArn ?? process.env[MR4],
        I = A?.roleSessionName ?? process.env[LR4];
      if (!B || !Q) throw new NR4.CredentialsProviderError("Web identity configuration not specified", {
        logger: A.logger
      });
      let G = await qR4.fromWebToken({
        ...A,
        webIdentityToken: $R4.readFileSync(B, {
          encoding: "ascii"
        }),
        roleArn: Q,
        roleSessionName: I
      })();
      if (B === process.env[MB0]) UR4.setCredentialFeature(G, "CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN", "h");
      return G
    };
  LB0.fromTokenFile = RR4
})
// @from(Start 3776629, End 3777324)
fa = z(($Z8, nI1) => {
  var {
    defineProperty: TB0,
    getOwnPropertyDescriptor: OR4,
    getOwnPropertyNames: TR4
  } = Object, PR4 = Object.prototype.hasOwnProperty, Ox1 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of TR4(B))
        if (!PR4.call(A, G) && G !== Q) TB0(A, G, {
          get: () => B[G],
          enumerable: !(I = OR4(B, G)) || I.enumerable
        })
    }
    return A
  }, PB0 = (A, B, Q) => (Ox1(A, B, "default"), Q && Ox1(Q, B, "default")), SR4 = (A) => Ox1(TB0({}, "__esModule", {
    value: !0
  }), A), Tx1 = {};
  nI1.exports = SR4(Tx1);
  PB0(Tx1, OB0(), nI1.exports);
  PB0(Tx1, Rx1(), nI1.exports)
})
// @from(Start 3777330, End 3787000)
_x1 = z((qZ8, fB0) => {
  var {
    create: _R4,
    defineProperty: ba,
    getOwnPropertyDescriptor: jR4,
    getOwnPropertyNames: yR4,
    getPrototypeOf: kR4
  } = Object, xR4 = Object.prototype.hasOwnProperty, W7 = (A, B) => ba(A, "name", {
    value: B,
    configurable: !0
  }), fR4 = (A, B) => {
    for (var Q in B) ba(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, yB0 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of yR4(B))
        if (!xR4.call(A, G) && G !== Q) ba(A, G, {
          get: () => B[G],
          enumerable: !(I = jR4(B, G)) || I.enumerable
        })
    }
    return A
  }, lL = (A, B, Q) => (Q = A != null ? _R4(kR4(A)) : {}, yB0(B || !A || !A.__esModule ? ba(Q, "default", {
    value: A,
    enumerable: !0
  }) : Q, A)), vR4 = (A) => yB0(ba({}, "__esModule", {
    value: !0
  }), A), kB0 = {};
  fR4(kB0, {
    fromIni: () => aR4
  });
  fB0.exports = vR4(kB0);
  var Sx1 = xL(),
    iL = NC(),
    va = $I(),
    bR4 = W7((A, B, Q) => {
      let I = {
        EcsContainer: W7(async (G) => {
          let {
            fromHttp: Z
          } = await Promise.resolve().then(() => lL(AI1())), {
            fromContainerMetadata: D
          } = await Promise.resolve().then(() => lL(B_()));
          return Q?.debug("@aws-sdk/credential-provider-ini - credential_source is EcsContainer"), async () => va.chain(Z(G ?? {}), D(G))().then(Px1)
        }, "EcsContainer"),
        Ec2InstanceMetadata: W7(async (G) => {
          Q?.debug("@aws-sdk/credential-provider-ini - credential_source is Ec2InstanceMetadata");
          let {
            fromInstanceMetadata: Z
          } = await Promise.resolve().then(() => lL(B_()));
          return async () => Z(G)().then(Px1)
        }, "Ec2InstanceMetadata"),
        Environment: W7(async (G) => {
          Q?.debug("@aws-sdk/credential-provider-ini - credential_source is Environment");
          let {
            fromEnv: Z
          } = await Promise.resolve().then(() => lL(d71()));
          return async () => Z(G)().then(Px1)
        }, "Environment")
      };
      if (A in I) return I[A];
      else throw new va.CredentialsProviderError(`Unsupported credential source in profile ${B}. Got ${A}, expected EcsContainer or Ec2InstanceMetadata or Environment.`, {
        logger: Q
      })
    }, "resolveCredentialSource"),
    Px1 = W7((A) => iL.setCredentialFeature(A, "CREDENTIALS_PROFILE_NAMED_PROVIDER", "p"), "setNamedProvider"),
    gR4 = W7((A, {
      profile: B = "default",
      logger: Q
    } = {}) => {
      return Boolean(A) && typeof A === "object" && typeof A.role_arn === "string" && ["undefined", "string"].indexOf(typeof A.role_session_name) > -1 && ["undefined", "string"].indexOf(typeof A.external_id) > -1 && ["undefined", "string"].indexOf(typeof A.mfa_serial) > -1 && (hR4(A, {
        profile: B,
        logger: Q
      }) || mR4(A, {
        profile: B,
        logger: Q
      }))
    }, "isAssumeRoleProfile"),
    hR4 = W7((A, {
      profile: B,
      logger: Q
    }) => {
      let I = typeof A.source_profile === "string" && typeof A.credential_source === "undefined";
      if (I) Q?.debug?.(`    ${B} isAssumeRoleWithSourceProfile source_profile=${A.source_profile}`);
      return I
    }, "isAssumeRoleWithSourceProfile"),
    mR4 = W7((A, {
      profile: B,
      logger: Q
    }) => {
      let I = typeof A.credential_source === "string" && typeof A.source_profile === "undefined";
      if (I) Q?.debug?.(`    ${B} isCredentialSourceProfile credential_source=${A.credential_source}`);
      return I
    }, "isCredentialSourceProfile"),
    dR4 = W7(async (A, B, Q, I = {}) => {
      Q.logger?.debug("@aws-sdk/credential-provider-ini - resolveAssumeRoleCredentials (STS)");
      let G = B[A],
        {
          source_profile: Z,
          region: D
        } = G;
      if (!Q.roleAssumer) {
        let {
          getDefaultRoleAssumer: W
        } = await Promise.resolve().then(() => lL(cI1()));
        Q.roleAssumer = W({
          ...Q.clientConfig,
          credentialProviderLogger: Q.logger,
          parentClientConfig: {
            ...Q?.parentClientConfig,
            region: D ?? Q?.parentClientConfig?.region
          }
        }, Q.clientPlugins)
      }
      if (Z && Z in I) throw new va.CredentialsProviderError(`Detected a cycle attempting to resolve credentials for profile ${Sx1.getProfileName(Q)}. Profiles visited: ` + Object.keys(I).join(", "), {
        logger: Q.logger
      });
      Q.logger?.debug(`@aws-sdk/credential-provider-ini - finding credential resolver using ${Z?`source_profile=[${Z}]`:`profile=[${A}]`}`);
      let Y = Z ? xB0(Z, B, Q, {
        ...I,
        [Z]: !0
      }, SB0(B[Z] ?? {})) : (await bR4(G.credential_source, A, Q.logger)(Q))();
      if (SB0(G)) return Y.then((W) => iL.setCredentialFeature(W, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o"));
      else {
        let W = {
            RoleArn: G.role_arn,
            RoleSessionName: G.role_session_name || `aws-sdk-js-${Date.now()}`,
            ExternalId: G.external_id,
            DurationSeconds: parseInt(G.duration_seconds || "3600", 10)
          },
          {
            mfa_serial: J
          } = G;
        if (J) {
          if (!Q.mfaCodeProvider) throw new va.CredentialsProviderError(`Profile ${A} requires multi-factor authentication, but no MFA code callback was provided.`, {
            logger: Q.logger,
            tryNextLink: !1
          });
          W.SerialNumber = J, W.TokenCode = await Q.mfaCodeProvider(J)
        }
        let F = await Y;
        return Q.roleAssumer(F, W).then((X) => iL.setCredentialFeature(X, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o"))
      }
    }, "resolveAssumeRoleCredentials"),
    SB0 = W7((A) => {
      return !A.role_arn && !!A.credential_source
    }, "isCredentialSourceWithoutRoleArn"),
    uR4 = W7((A) => Boolean(A) && typeof A === "object" && typeof A.credential_process === "string", "isProcessProfile"),
    pR4 = W7(async (A, B) => Promise.resolve().then(() => lL(iI1())).then(({
      fromProcess: Q
    }) => Q({
      ...A,
      profile: B
    })().then((I) => iL.setCredentialFeature(I, "CREDENTIALS_PROFILE_PROCESS", "v"))), "resolveProcessCredentials"),
    cR4 = W7(async (A, B, Q = {}) => {
      let {
        fromSSO: I
      } = await Promise.resolve().then(() => lL(dI1()));
      return I({
        profile: A,
        logger: Q.logger,
        parentClientConfig: Q.parentClientConfig,
        clientConfig: Q.clientConfig
      })().then((G) => {
        if (B.sso_session) return iL.setCredentialFeature(G, "CREDENTIALS_PROFILE_SSO", "r");
        else return iL.setCredentialFeature(G, "CREDENTIALS_PROFILE_SSO_LEGACY", "t")
      })
    }, "resolveSsoCredentials"),
    lR4 = W7((A) => A && (typeof A.sso_start_url === "string" || typeof A.sso_account_id === "string" || typeof A.sso_session === "string" || typeof A.sso_region === "string" || typeof A.sso_role_name === "string"), "isSsoProfile"),
    _B0 = W7((A) => Boolean(A) && typeof A === "object" && typeof A.aws_access_key_id === "string" && typeof A.aws_secret_access_key === "string" && ["undefined", "string"].indexOf(typeof A.aws_session_token) > -1 && ["undefined", "string"].indexOf(typeof A.aws_account_id) > -1, "isStaticCredsProfile"),
    jB0 = W7(async (A, B) => {
      B?.logger?.debug("@aws-sdk/credential-provider-ini - resolveStaticCredentials");
      let Q = {
        accessKeyId: A.aws_access_key_id,
        secretAccessKey: A.aws_secret_access_key,
        sessionToken: A.aws_session_token,
        ...A.aws_credential_scope && {
          credentialScope: A.aws_credential_scope
        },
        ...A.aws_account_id && {
          accountId: A.aws_account_id
        }
      };
      return iL.setCredentialFeature(Q, "CREDENTIALS_PROFILE", "n")
    }, "resolveStaticCredentials"),
    iR4 = W7((A) => Boolean(A) && typeof A === "object" && typeof A.web_identity_token_file === "string" && typeof A.role_arn === "string" && ["undefined", "string"].indexOf(typeof A.role_session_name) > -1, "isWebIdentityProfile"),
    nR4 = W7(async (A, B) => Promise.resolve().then(() => lL(fa())).then(({
      fromTokenFile: Q
    }) => Q({
      webIdentityTokenFile: A.web_identity_token_file,
      roleArn: A.role_arn,
      roleSessionName: A.role_session_name,
      roleAssumerWithWebIdentity: B.roleAssumerWithWebIdentity,
      logger: B.logger,
      parentClientConfig: B.parentClientConfig
    })().then((I) => iL.setCredentialFeature(I, "CREDENTIALS_PROFILE_STS_WEB_ID_TOKEN", "q"))), "resolveWebIdentityCredentials"),
    xB0 = W7(async (A, B, Q, I = {}, G = !1) => {
      let Z = B[A];
      if (Object.keys(I).length > 0 && _B0(Z)) return jB0(Z, Q);
      if (G || gR4(Z, {
          profile: A,
          logger: Q.logger
        })) return dR4(A, B, Q, I);
      if (_B0(Z)) return jB0(Z, Q);
      if (iR4(Z)) return nR4(Z, Q);
      if (uR4(Z)) return pR4(Q, A);
      if (lR4(Z)) return await cR4(A, Z, Q);
      throw new va.CredentialsProviderError(`Could not resolve credentials using profile: [${A}] in configuration/credentials file(s).`, {
        logger: Q.logger
      })
    }, "resolveProfileData"),
    aR4 = W7((A = {}) => async ({
      callerClientConfig: B
    } = {}) => {
      let Q = {
        ...A,
        parentClientConfig: {
          ...B,
          ...A.parentClientConfig
        }
      };
      Q.logger?.debug("@aws-sdk/credential-provider-ini - fromIni");
      let I = await Sx1.parseKnownFiles(Q);
      return xB0(Sx1.getProfileName({
        profile: A.profile ?? B?.profile
      }), I, Q)
    }, "fromIni")
})
// @from(Start 3787006, End 3791933)
ha = z((MZ8, uB0) => {
  var {
    create: sR4,
    defineProperty: ga,
    getOwnPropertyDescriptor: rR4,
    getOwnPropertyNames: oR4,
    getPrototypeOf: tR4
  } = Object, eR4 = Object.prototype.hasOwnProperty, aI1 = (A, B) => ga(A, "name", {
    value: B,
    configurable: !0
  }), AO4 = (A, B) => {
    for (var Q in B) ga(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, gB0 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of oR4(B))
        if (!eR4.call(A, G) && G !== Q) ga(A, G, {
          get: () => B[G],
          enumerable: !(I = rR4(B, G)) || I.enumerable
        })
    }
    return A
  }, Ig = (A, B, Q) => (Q = A != null ? sR4(tR4(A)) : {}, gB0(B || !A || !A.__esModule ? ga(Q, "default", {
    value: A,
    enumerable: !0
  }) : Q, A)), BO4 = (A) => gB0(ga({}, "__esModule", {
    value: !0
  }), A), hB0 = {};
  AO4(hB0, {
    credentialsTreatedAsExpired: () => dB0,
    credentialsWillNeedRefresh: () => mB0,
    defaultProvider: () => GO4
  });
  uB0.exports = BO4(hB0);
  var jx1 = d71(),
    QO4 = xL(),
    X_ = $I(),
    vB0 = "AWS_EC2_METADATA_DISABLED",
    IO4 = aI1(async (A) => {
      let {
        ENV_CMDS_FULL_URI: B,
        ENV_CMDS_RELATIVE_URI: Q,
        fromContainerMetadata: I,
        fromInstanceMetadata: G
      } = await Promise.resolve().then(() => Ig(B_()));
      if (process.env[Q] || process.env[B]) {
        A.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromHttp/fromContainerMetadata");
        let {
          fromHttp: Z
        } = await Promise.resolve().then(() => Ig(AI1()));
        return X_.chain(Z(A), I(A))
      }
      if (process.env[vB0] && process.env[vB0] !== "false") return async () => {
        throw new X_.CredentialsProviderError("EC2 Instance Metadata Service access disabled", {
          logger: A.logger
        })
      };
      return A.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromInstanceMetadata"), G(A)
    }, "remoteProvider"),
    bB0 = !1,
    GO4 = aI1((A = {}) => X_.memoize(X_.chain(async () => {
      if (A.profile ?? process.env[QO4.ENV_PROFILE]) {
        if (process.env[jx1.ENV_KEY] && process.env[jx1.ENV_SECRET]) {
          if (!bB0)(A.logger?.warn && A.logger?.constructor?.name !== "NoOpLogger" ? A.logger.warn : console.warn)(`@aws-sdk/credential-provider-node - defaultProvider::fromEnv WARNING:
    Multiple credential sources detected: 
    Both AWS_PROFILE and the pair AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY static credentials are set.
    This SDK will proceed with the AWS_PROFILE value.
    
    However, a future version may change this behavior to prefer the ENV static credentials.
    Please ensure that your environment only sets either the AWS_PROFILE or the
    AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY pair.
`), bB0 = !0
        }
        throw new X_.CredentialsProviderError("AWS_PROFILE is set, skipping fromEnv provider.", {
          logger: A.logger,
          tryNextLink: !0
        })
      }
      return A.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromEnv"), jx1.fromEnv(A)()
    }, async () => {
      A.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromSSO");
      let {
        ssoStartUrl: B,
        ssoAccountId: Q,
        ssoRegion: I,
        ssoRoleName: G,
        ssoSession: Z
      } = A;
      if (!B && !Q && !I && !G && !Z) throw new X_.CredentialsProviderError("Skipping SSO provider in default chain (inputs do not include SSO fields).", {
        logger: A.logger
      });
      let {
        fromSSO: D
      } = await Promise.resolve().then(() => Ig(dI1()));
      return D(A)()
    }, async () => {
      A.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromIni");
      let {
        fromIni: B
      } = await Promise.resolve().then(() => Ig(_x1()));
      return B(A)()
    }, async () => {
      A.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromProcess");
      let {
        fromProcess: B
      } = await Promise.resolve().then(() => Ig(iI1()));
      return B(A)()
    }, async () => {
      A.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromTokenFile");
      let {
        fromTokenFile: B
      } = await Promise.resolve().then(() => Ig(fa()));
      return B(A)()
    }, async () => {
      return A.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::remoteProvider"), (await IO4(A))()
    }, async () => {
      throw new X_.CredentialsProviderError("Could not load credentials from any providers", {
        tryNextLink: !1,
        logger: A.logger
      })
    }), dB0, mB0), "defaultProvider"),
    mB0 = aI1((A) => A?.expiration !== void 0, "credentialsWillNeedRefresh"),
    dB0 = aI1((A) => A?.expiration !== void 0 && A.expiration.getTime() - Date.now() < 300000, "credentialsTreatedAsExpired")
})
// @from(Start 3791939, End 3794722)
yx1 = z((LZ8, oB0) => {
  var {
    defineProperty: sI1,
    getOwnPropertyDescriptor: ZO4,
    getOwnPropertyNames: DO4
  } = Object, YO4 = Object.prototype.hasOwnProperty, rI1 = (A, B) => sI1(A, "name", {
    value: B,
    configurable: !0
  }), WO4 = (A, B) => {
    for (var Q in B) sI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, JO4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of DO4(B))
        if (!YO4.call(A, G) && G !== Q) sI1(A, G, {
          get: () => B[G],
          enumerable: !(I = ZO4(B, G)) || I.enumerable
        })
    }
    return A
  }, FO4 = (A) => JO4(sI1({}, "__esModule", {
    value: !0
  }), A), pB0 = {};
  WO4(pB0, {
    AlgorithmId: () => nB0,
    EndpointURLScheme: () => iB0,
    FieldPosition: () => aB0,
    HttpApiKeyAuthLocation: () => lB0,
    HttpAuthLocation: () => cB0,
    IniSectionType: () => sB0,
    RequestHandlerProtocol: () => rB0,
    SMITHY_CONTEXT_KEY: () => HO4,
    getDefaultClientConfiguration: () => CO4,
    resolveDefaultRuntimeConfig: () => KO4
  });
  oB0.exports = FO4(pB0);
  var cB0 = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(cB0 || {}),
    lB0 = ((A) => {
      return A.HEADER = "header", A.QUERY = "query", A
    })(lB0 || {}),
    iB0 = ((A) => {
      return A.HTTP = "http", A.HTTPS = "https", A
    })(iB0 || {}),
    nB0 = ((A) => {
      return A.MD5 = "md5", A.CRC32 = "crc32", A.CRC32C = "crc32c", A.SHA1 = "sha1", A.SHA256 = "sha256", A
    })(nB0 || {}),
    XO4 = rI1((A) => {
      let B = [];
      if (A.sha256 !== void 0) B.push({
        algorithmId: () => "sha256",
        checksumConstructor: () => A.sha256
      });
      if (A.md5 != null) B.push({
        algorithmId: () => "md5",
        checksumConstructor: () => A.md5
      });
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    VO4 = rI1((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    CO4 = rI1((A) => {
      return XO4(A)
    }, "getDefaultClientConfiguration"),
    KO4 = rI1((A) => {
      return VO4(A)
    }, "resolveDefaultRuntimeConfig"),
    aB0 = ((A) => {
      return A[A.HEADER = 0] = "HEADER", A[A.TRAILER = 1] = "TRAILER", A
    })(aB0 || {}),
    HO4 = "__smithy_context",
    sB0 = ((A) => {
      return A.PROFILE = "profile", A.SSO_SESSION = "sso-session", A.SERVICES = "services", A
    })(sB0 || {}),
    rB0 = ((A) => {
      return A.HTTP_0_9 = "http/0.9", A.HTTP_1_0 = "http/1.0", A.TDS_8_0 = "tds/8.0", A
    })(rB0 || {})
})
// @from(Start 3794728, End 3823265)
ca = z((RZ8, H30) => {
  var {
    defineProperty: eI1,
    getOwnPropertyDescriptor: zO4,
    getOwnPropertyNames: wO4
  } = Object, EO4 = Object.prototype.hasOwnProperty, B2 = (A, B) => eI1(A, "name", {
    value: B,
    configurable: !0
  }), UO4 = (A, B) => {
    for (var Q in B) eI1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, NO4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of wO4(B))
        if (!EO4.call(A, G) && G !== Q) eI1(A, G, {
          get: () => B[G],
          enumerable: !(I = zO4(B, G)) || I.enumerable
        })
    }
    return A
  }, $O4 = (A) => NO4(eI1({}, "__esModule", {
    value: !0
  }), A), eB0 = {};
  UO4(eB0, {
    Client: () => qO4,
    Command: () => B30,
    LazyJsonString: () => V_,
    NoOpLogger: () => ET4,
    SENSITIVE_STRING: () => LO4,
    ServiceException: () => ZT4,
    _json: () => hx1,
    collectBody: () => kx1.collectBody,
    convertMap: () => UT4,
    createAggregatedClient: () => RO4,
    dateToUtcString: () => Y30,
    decorateServiceException: () => W30,
    emitWarningIfUnsupportedVersion: () => JT4,
    expectBoolean: () => TO4,
    expectByte: () => gx1,
    expectFloat32: () => oI1,
    expectInt: () => SO4,
    expectInt32: () => vx1,
    expectLong: () => ua,
    expectNonNull: () => jO4,
    expectNumber: () => da,
    expectObject: () => Q30,
    expectShort: () => bx1,
    expectString: () => yO4,
    expectUnion: () => kO4,
    extendedEncodeURIComponent: () => kx1.extendedEncodeURIComponent,
    getArrayIfSingleItem: () => zT4,
    getDefaultClientConfiguration: () => KT4,
    getDefaultExtensionConfiguration: () => F30,
    getValueFromTextNode: () => X30,
    handleFloat: () => vO4,
    isSerializableHeaderValue: () => wT4,
    limitedParseDouble: () => ux1,
    limitedParseFloat: () => bO4,
    limitedParseFloat32: () => gO4,
    loadConfigsForDefaultMode: () => WT4,
    logger: () => pa,
    map: () => cx1,
    parseBoolean: () => OO4,
    parseEpochTimestamp: () => rO4,
    parseRfc3339DateTime: () => pO4,
    parseRfc3339DateTimeWithOffset: () => lO4,
    parseRfc7231DateTime: () => sO4,
    quoteHeader: () => C30,
    resolveDefaultRuntimeConfig: () => HT4,
    resolvedPath: () => kx1.resolvedPath,
    serializeDateTime: () => RT4,
    serializeFloat: () => LT4,
    splitEvery: () => K30,
    splitHeader: () => OT4,
    strictParseByte: () => D30,
    strictParseDouble: () => dx1,
    strictParseFloat: () => xO4,
    strictParseFloat32: () => I30,
    strictParseInt: () => hO4,
    strictParseInt32: () => mO4,
    strictParseLong: () => Z30,
    strictParseShort: () => Gg,
    take: () => NT4,
    throwDefaultError: () => J30,
    withBaseException: () => DT4
  });
  H30.exports = $O4(eB0);
  var A30 = WN(),
    qO4 = class {
      constructor(A) {
        this.config = A, this.middlewareStack = A30.constructStack()
      }
      static {
        B2(this, "Client")
      }
      send(A, B, Q) {
        let I = typeof B !== "function" ? B : void 0,
          G = typeof B === "function" ? B : Q,
          Z = I === void 0 && this.config.cacheMiddleware === !0,
          D;
        if (Z) {
          if (!this.handlers) this.handlers = new WeakMap;
          let Y = this.handlers;
          if (Y.has(A.constructor)) D = Y.get(A.constructor);
          else D = A.resolveMiddleware(this.middlewareStack, this.config, I), Y.set(A.constructor, D)
        } else delete this.handlers, D = A.resolveMiddleware(this.middlewareStack, this.config, I);
        if (G) D(A).then((Y) => G(null, Y.output), (Y) => G(Y)).catch(() => {});
        else return D(A).then((Y) => Y.output)
      }
      destroy() {
        this.config?.requestHandler?.destroy?.(), delete this.handlers
      }
    },
    kx1 = vz(),
    fx1 = yx1(),
    B30 = class {
      constructor() {
        this.middlewareStack = A30.constructStack()
      }
      static {
        B2(this, "Command")
      }
      static classBuilder() {
        return new MO4
      }
      resolveMiddlewareWithContext(A, B, Q, {
        middlewareFn: I,
        clientName: G,
        commandName: Z,
        inputFilterSensitiveLog: D,
        outputFilterSensitiveLog: Y,
        smithyContext: W,
        additionalContext: J,
        CommandCtor: F
      }) {
        for (let E of I.bind(this)(F, A, B, Q)) this.middlewareStack.use(E);
        let X = A.concat(this.middlewareStack),
          {
            logger: V
          } = B,
          C = {
            logger: V,
            clientName: G,
            commandName: Z,
            inputFilterSensitiveLog: D,
            outputFilterSensitiveLog: Y,
            [fx1.SMITHY_CONTEXT_KEY]: {
              commandInstance: this,
              ...W
            },
            ...J
          },
          {
            requestHandler: K
          } = B;
        return X.resolve((E) => K.handle(E.request, Q || {}), C)
      }
    },
    MO4 = class {
      constructor() {
        this._init = () => {}, this._ep = {}, this._middlewareFn = () => [], this._commandName = "", this._clientName = "", this._additionalContext = {}, this._smithyContext = {}, this._inputFilterSensitiveLog = (A) => A, this._outputFilterSensitiveLog = (A) => A, this._serializer = null, this._deserializer = null
      }
      static {
        B2(this, "ClassBuilder")
      }
      init(A) {
        this._init = A
      }
      ep(A) {
        return this._ep = A, this
      }
      m(A) {
        return this._middlewareFn = A, this
      }
      s(A, B, Q = {}) {
        return this._smithyContext = {
          service: A,
          operation: B,
          ...Q
        }, this
      }
      c(A = {}) {
        return this._additionalContext = A, this
      }
      n(A, B) {
        return this._clientName = A, this._commandName = B, this
      }
      f(A = (Q) => Q, B = (Q) => Q) {
        return this._inputFilterSensitiveLog = A, this._outputFilterSensitiveLog = B, this
      }
      ser(A) {
        return this._serializer = A, this
      }
      de(A) {
        return this._deserializer = A, this
      }
      build() {
        let A = this,
          B;
        return B = class extends B30 {
          constructor(...[Q]) {
            super();
            this.serialize = A._serializer, this.deserialize = A._deserializer, this.input = Q ?? {}, A._init(this)
          }
          static {
            B2(this, "CommandRef")
          }
          static getEndpointParameterInstructions() {
            return A._ep
          }
          resolveMiddleware(Q, I, G) {
            return this.resolveMiddlewareWithContext(Q, I, G, {
              CommandCtor: B,
              middlewareFn: A._middlewareFn,
              clientName: A._clientName,
              commandName: A._commandName,
              inputFilterSensitiveLog: A._inputFilterSensitiveLog,
              outputFilterSensitiveLog: A._outputFilterSensitiveLog,
              smithyContext: A._smithyContext,
              additionalContext: A._additionalContext
            })
          }
        }
      }
    },
    LO4 = "***SensitiveInformation***",
    RO4 = B2((A, B) => {
      for (let Q of Object.keys(A)) {
        let I = A[Q],
          G = B2(async function(D, Y, W) {
            let J = new I(D);
            if (typeof Y === "function") this.send(J, Y);
            else if (typeof W === "function") {
              if (typeof Y !== "object") throw new Error(`Expected http options but got ${typeof Y}`);
              this.send(J, Y || {}, W)
            } else return this.send(J, Y)
          }, "methodImpl"),
          Z = (Q[0].toLowerCase() + Q.slice(1)).replace(/Command$/, "");
        B.prototype[Z] = G
      }
    }, "createAggregatedClient"),
    OO4 = B2((A) => {
      switch (A) {
        case "true":
          return !0;
        case "false":
          return !1;
        default:
          throw new Error(`Unable to parse boolean value "${A}"`)
      }
    }, "parseBoolean"),
    TO4 = B2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "number") {
        if (A === 0 || A === 1) pa.warn(tI1(`Expected boolean, got ${typeof A}: ${A}`));
        if (A === 0) return !1;
        if (A === 1) return !0
      }
      if (typeof A === "string") {
        let B = A.toLowerCase();
        if (B === "false" || B === "true") pa.warn(tI1(`Expected boolean, got ${typeof A}: ${A}`));
        if (B === "false") return !1;
        if (B === "true") return !0
      }
      if (typeof A === "boolean") return A;
      throw new TypeError(`Expected boolean, got ${typeof A}: ${A}`)
    }, "expectBoolean"),
    da = B2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "string") {
        let B = parseFloat(A);
        if (!Number.isNaN(B)) {
          if (String(B) !== String(A)) pa.warn(tI1(`Expected number but observed string: ${A}`));
          return B
        }
      }
      if (typeof A === "number") return A;
      throw new TypeError(`Expected number, got ${typeof A}: ${A}`)
    }, "expectNumber"),
    PO4 = Math.ceil(340282346638528860000000000000000000000),
    oI1 = B2((A) => {
      let B = da(A);
      if (B !== void 0 && !Number.isNaN(B) && B !== 1 / 0 && B !== -1 / 0) {
        if (Math.abs(B) > PO4) throw new TypeError(`Expected 32-bit float, got ${A}`)
      }
      return B
    }, "expectFloat32"),
    ua = B2((A) => {
      if (A === null || A === void 0) return;
      if (Number.isInteger(A) && !Number.isNaN(A)) return A;
      throw new TypeError(`Expected integer, got ${typeof A}: ${A}`)
    }, "expectLong"),
    SO4 = ua,
    vx1 = B2((A) => mx1(A, 32), "expectInt32"),
    bx1 = B2((A) => mx1(A, 16), "expectShort"),
    gx1 = B2((A) => mx1(A, 8), "expectByte"),
    mx1 = B2((A, B) => {
      let Q = ua(A);
      if (Q !== void 0 && _O4(Q, B) !== Q) throw new TypeError(`Expected ${B}-bit integer, got ${A}`);
      return Q
    }, "expectSizedInt"),
    _O4 = B2((A, B) => {
      switch (B) {
        case 32:
          return Int32Array.of(A)[0];
        case 16:
          return Int16Array.of(A)[0];
        case 8:
          return Int8Array.of(A)[0]
      }
    }, "castInt"),
    jO4 = B2((A, B) => {
      if (A === null || A === void 0) {
        if (B) throw new TypeError(`Expected a non-null value for ${B}`);
        throw new TypeError("Expected a non-null value")
      }
      return A
    }, "expectNonNull"),
    Q30 = B2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "object" && !Array.isArray(A)) return A;
      let B = Array.isArray(A) ? "array" : typeof A;
      throw new TypeError(`Expected object, got ${B}: ${A}`)
    }, "expectObject"),
    yO4 = B2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A === "string") return A;
      if (["boolean", "number", "bigint"].includes(typeof A)) return pa.warn(tI1(`Expected string, got ${typeof A}: ${A}`)), String(A);
      throw new TypeError(`Expected string, got ${typeof A}: ${A}`)
    }, "expectString"),
    kO4 = B2((A) => {
      if (A === null || A === void 0) return;
      let B = Q30(A),
        Q = Object.entries(B).filter(([, I]) => I != null).map(([I]) => I);
      if (Q.length === 0) throw new TypeError("Unions must have exactly one non-null member. None were found.");
      if (Q.length > 1) throw new TypeError(`Unions must have exactly one non-null member. Keys ${Q} were not null.`);
      return B
    }, "expectUnion"),
    dx1 = B2((A) => {
      if (typeof A == "string") return da(Dg(A));
      return da(A)
    }, "strictParseDouble"),
    xO4 = dx1,
    I30 = B2((A) => {
      if (typeof A == "string") return oI1(Dg(A));
      return oI1(A)
    }, "strictParseFloat32"),
    fO4 = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g,
    Dg = B2((A) => {
      let B = A.match(fO4);
      if (B === null || B[0].length !== A.length) throw new TypeError("Expected real number, got implicit NaN");
      return parseFloat(A)
    }, "parseNumber"),
    ux1 = B2((A) => {
      if (typeof A == "string") return G30(A);
      return da(A)
    }, "limitedParseDouble"),
    vO4 = ux1,
    bO4 = ux1,
    gO4 = B2((A) => {
      if (typeof A == "string") return G30(A);
      return oI1(A)
    }, "limitedParseFloat32"),
    G30 = B2((A) => {
      switch (A) {
        case "NaN":
          return NaN;
        case "Infinity":
          return 1 / 0;
        case "-Infinity":
          return -1 / 0;
        default:
          throw new Error(`Unable to parse float value: ${A}`)
      }
    }, "parseFloatString"),
    Z30 = B2((A) => {
      if (typeof A === "string") return ua(Dg(A));
      return ua(A)
    }, "strictParseLong"),
    hO4 = Z30,
    mO4 = B2((A) => {
      if (typeof A === "string") return vx1(Dg(A));
      return vx1(A)
    }, "strictParseInt32"),
    Gg = B2((A) => {
      if (typeof A === "string") return bx1(Dg(A));
      return bx1(A)
    }, "strictParseShort"),
    D30 = B2((A) => {
      if (typeof A === "string") return gx1(Dg(A));
      return gx1(A)
    }, "strictParseByte"),
    tI1 = B2((A) => {
      return String(new TypeError(A).stack || A).split(`
`).slice(0, 5).filter((B) => !B.includes("stackTraceWarning")).join(`
`)
    }, "stackTraceWarning"),
    pa = {
      warn: console.warn
    },
    dO4 = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
    px1 = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];

  function Y30(A) {
    let B = A.getUTCFullYear(),
      Q = A.getUTCMonth(),
      I = A.getUTCDay(),
      G = A.getUTCDate(),
      Z = A.getUTCHours(),
      D = A.getUTCMinutes(),
      Y = A.getUTCSeconds(),
      W = G < 10 ? `0${G}` : `${G}`,
      J = Z < 10 ? `0${Z}` : `${Z}`,
      F = D < 10 ? `0${D}` : `${D}`,
      X = Y < 10 ? `0${Y}` : `${Y}`;
    return `${dO4[I]}, ${W} ${px1[Q]} ${B} ${J}:${F}:${X} GMT`
  }
  B2(Y30, "dateToUtcString");
  var uO4 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/),
    pO4 = B2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-3339 date-times must be expressed as strings");
      let B = uO4.exec(A);
      if (!B) throw new TypeError("Invalid RFC-3339 date-time value");
      let [Q, I, G, Z, D, Y, W, J] = B, F = Gg(Zg(I)), X = az(G, "month", 1, 12), V = az(Z, "day", 1, 31);
      return ma(F, X, V, {
        hours: D,
        minutes: Y,
        seconds: W,
        fractionalMilliseconds: J
      })
    }, "parseRfc3339DateTime"),
    cO4 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/),
    lO4 = B2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-3339 date-times must be expressed as strings");
      let B = cO4.exec(A);
      if (!B) throw new TypeError("Invalid RFC-3339 date-time value");
      let [Q, I, G, Z, D, Y, W, J, F] = B, X = Gg(Zg(I)), V = az(G, "month", 1, 12), C = az(Z, "day", 1, 31), K = ma(X, V, C, {
        hours: D,
        minutes: Y,
        seconds: W,
        fractionalMilliseconds: J
      });
      if (F.toUpperCase() != "Z") K.setTime(K.getTime() - GT4(F));
      return K
    }, "parseRfc3339DateTimeWithOffset"),
    iO4 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/),
    nO4 = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/),
    aO4 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/),
    sO4 = B2((A) => {
      if (A === null || A === void 0) return;
      if (typeof A !== "string") throw new TypeError("RFC-7231 date-times must be expressed as strings");
      let B = iO4.exec(A);
      if (B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return ma(Gg(Zg(Z)), xx1(G), az(I, "day", 1, 31), {
          hours: D,
          minutes: Y,
          seconds: W,
          fractionalMilliseconds: J
        })
      }
      if (B = nO4.exec(A), B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return eO4(ma(oO4(Z), xx1(G), az(I, "day", 1, 31), {
          hours: D,
          minutes: Y,
          seconds: W,
          fractionalMilliseconds: J
        }))
      }
      if (B = aO4.exec(A), B) {
        let [Q, I, G, Z, D, Y, W, J] = B;
        return ma(Gg(Zg(J)), xx1(I), az(G.trimLeft(), "day", 1, 31), {
          hours: Z,
          minutes: D,
          seconds: Y,
          fractionalMilliseconds: W
        })
      }
      throw new TypeError("Invalid RFC-7231 date-time value")
    }, "parseRfc7231DateTime"),
    rO4 = B2((A) => {
      if (A === null || A === void 0) return;
      let B;
      if (typeof A === "number") B = A;
      else if (typeof A === "string") B = dx1(A);
      else if (typeof A === "object" && A.tag === 1) B = A.value;
      else throw new TypeError("Epoch timestamps must be expressed as floating point numbers or their string representation");
      if (Number.isNaN(B) || B === 1 / 0 || B === -1 / 0) throw new TypeError("Epoch timestamps must be valid, non-Infinite, non-NaN numerics");
      return new Date(Math.round(B * 1000))
    }, "parseEpochTimestamp"),
    ma = B2((A, B, Q, I) => {
      let G = B - 1;
      return BT4(A, G, Q), new Date(Date.UTC(A, G, Q, az(I.hours, "hour", 0, 23), az(I.minutes, "minute", 0, 59), az(I.seconds, "seconds", 0, 60), IT4(I.fractionalMilliseconds)))
    }, "buildDate"),
    oO4 = B2((A) => {
      let B = new Date().getUTCFullYear(),
        Q = Math.floor(B / 100) * 100 + Gg(Zg(A));
      if (Q < B) return Q + 100;
      return Q
    }, "parseTwoDigitYear"),
    tO4 = 1576800000000,
    eO4 = B2((A) => {
      if (A.getTime() - new Date().getTime() > tO4) return new Date(Date.UTC(A.getUTCFullYear() - 100, A.getUTCMonth(), A.getUTCDate(), A.getUTCHours(), A.getUTCMinutes(), A.getUTCSeconds(), A.getUTCMilliseconds()));
      return A
    }, "adjustRfc850Year"),
    xx1 = B2((A) => {
      let B = px1.indexOf(A);
      if (B < 0) throw new TypeError(`Invalid month: ${A}`);
      return B + 1
    }, "parseMonthByShortName"),
    AT4 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
    BT4 = B2((A, B, Q) => {
      let I = AT4[B];
      if (B === 1 && QT4(A)) I = 29;
      if (Q > I) throw new TypeError(`Invalid day for ${px1[B]} in ${A}: ${Q}`)
    }, "validateDayOfMonth"),
    QT4 = B2((A) => {
      return A % 4 === 0 && (A % 100 !== 0 || A % 400 === 0)
    }, "isLeapYear"),
    az = B2((A, B, Q, I) => {
      let G = D30(Zg(A));
      if (G < Q || G > I) throw new TypeError(`${B} must be between ${Q} and ${I}, inclusive`);
      return G
    }, "parseDateValue"),
    IT4 = B2((A) => {
      if (A === null || A === void 0) return 0;
      return I30("0." + A) * 1000
    }, "parseMilliseconds"),
    GT4 = B2((A) => {
      let B = A[0],
        Q = 1;
      if (B == "+") Q = 1;
      else if (B == "-") Q = -1;
      else throw new TypeError(`Offset direction, ${B}, must be "+" or "-"`);
      let I = Number(A.substring(1, 3)),
        G = Number(A.substring(4, 6));
      return Q * (I * 60 + G) * 60 * 1000
    }, "parseOffsetToMilliseconds"),
    Zg = B2((A) => {
      let B = 0;
      while (B < A.length - 1 && A.charAt(B) === "0") B++;
      if (B === 0) return A;
      return A.slice(B)
    }, "stripLeadingZeroes"),
    ZT4 = class A extends Error {
      static {
        B2(this, "ServiceException")
      }
      constructor(B) {
        super(B.message);
        Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype), this.name = B.name, this.$fault = B.$fault, this.$metadata = B.$metadata
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return A.prototype.isPrototypeOf(Q) || Boolean(Q.$fault) && Boolean(Q.$metadata) && (Q.$fault === "client" || Q.$fault === "server")
      }
      static[Symbol.hasInstance](B) {
        if (!B) return !1;
        let Q = B;
        if (this === A) return A.isInstance(B);
        if (A.isInstance(B)) {
          if (Q.name && this.name) return this.prototype.isPrototypeOf(B) || Q.name === this.name;
          return this.prototype.isPrototypeOf(B)
        }
        return !1
      }
    },
    W30 = B2((A, B = {}) => {
      Object.entries(B).filter(([, I]) => I !== void 0).forEach(([I, G]) => {
        if (A[I] == null || A[I] === "") A[I] = G
      });
      let Q = A.message || A.Message || "UnknownError";
      return A.message = Q, delete A.Message, A
    }, "decorateServiceException"),
    J30 = B2(({
      output: A,
      parsedBody: B,
      exceptionCtor: Q,
      errorCode: I
    }) => {
      let G = YT4(A),
        Z = G.httpStatusCode ? G.httpStatusCode + "" : void 0,
        D = new Q({
          name: B?.code || B?.Code || I || Z || "UnknownError",
          $fault: "client",
          $metadata: G
        });
      throw W30(D, B)
    }, "throwDefaultError"),
    DT4 = B2((A) => {
      return ({
        output: B,
        parsedBody: Q,
        errorCode: I
      }) => {
        J30({
          output: B,
          parsedBody: Q,
          exceptionCtor: A,
          errorCode: I
        })
      }
    }, "withBaseException"),
    YT4 = B2((A) => ({
      httpStatusCode: A.statusCode,
      requestId: A.headers["x-amzn-requestid"] ?? A.headers["x-amzn-request-id"] ?? A.headers["x-amz-request-id"],
      extendedRequestId: A.headers["x-amz-id-2"],
      cfId: A.headers["x-amz-cf-id"]
    }), "deserializeMetadata"),
    WT4 = B2((A) => {
      switch (A) {
        case "standard":
          return {
            retryMode: "standard", connectionTimeout: 3100
          };
        case "in-region":
          return {
            retryMode: "standard", connectionTimeout: 1100
          };
        case "cross-region":
          return {
            retryMode: "standard", connectionTimeout: 3100
          };
        case "mobile":
          return {
            retryMode: "standard", connectionTimeout: 30000
          };
        default:
          return {}
      }
    }, "loadConfigsForDefaultMode"),
    tB0 = !1,
    JT4 = B2((A) => {
      if (A && !tB0 && parseInt(A.substring(1, A.indexOf("."))) < 16) tB0 = !0
    }, "emitWarningIfUnsupportedVersion"),
    FT4 = B2((A) => {
      let B = [];
      for (let Q in fx1.AlgorithmId) {
        let I = fx1.AlgorithmId[Q];
        if (A[I] === void 0) continue;
        B.push({
          algorithmId: () => I,
          checksumConstructor: () => A[I]
        })
      }
      return {
        addChecksumAlgorithm(Q) {
          B.push(Q)
        },
        checksumAlgorithms() {
          return B
        }
      }
    }, "getChecksumConfiguration"),
    XT4 = B2((A) => {
      let B = {};
      return A.checksumAlgorithms().forEach((Q) => {
        B[Q.algorithmId()] = Q.checksumConstructor()
      }), B
    }, "resolveChecksumRuntimeConfig"),
    VT4 = B2((A) => {
      return {
        setRetryStrategy(B) {
          A.retryStrategy = B
        },
        retryStrategy() {
          return A.retryStrategy
        }
      }
    }, "getRetryConfiguration"),
    CT4 = B2((A) => {
      let B = {};
      return B.retryStrategy = A.retryStrategy(), B
    }, "resolveRetryRuntimeConfig"),
    F30 = B2((A) => {
      return Object.assign(FT4(A), VT4(A))
    }, "getDefaultExtensionConfiguration"),
    KT4 = F30,
    HT4 = B2((A) => {
      return Object.assign(XT4(A), CT4(A))
    }, "resolveDefaultRuntimeConfig"),
    zT4 = B2((A) => Array.isArray(A) ? A : [A], "getArrayIfSingleItem"),
    X30 = B2((A) => {
      for (let Q in A)
        if (A.hasOwnProperty(Q) && A[Q]["#text"] !== void 0) A[Q] = A[Q]["#text"];
        else if (typeof A[Q] === "object" && A[Q] !== null) A[Q] = X30(A[Q]);
      return A
    }, "getValueFromTextNode"),
    wT4 = B2((A) => {
      return A != null
    }, "isSerializableHeaderValue"),
    V_ = B2(function A(B) {
      return Object.assign(new String(B), {
        deserializeJSON() {
          return JSON.parse(String(B))
        },
        toString() {
          return String(B)
        },
        toJSON() {
          return String(B)
        }
      })
    }, "LazyJsonString");
  V_.from = (A) => {
    if (A && typeof A === "object" && (A instanceof V_ || ("deserializeJSON" in A))) return A;
    else if (typeof A === "string" || Object.getPrototypeOf(A) === String.prototype) return V_(String(A));
    return V_(JSON.stringify(A))
  };
  V_.fromObject = V_.from;
  var ET4 = class {
    static {
      B2(this, "NoOpLogger")
    }
    trace() {}
    debug() {}
    info() {}
    warn() {}
    error() {}
  };

  function cx1(A, B, Q) {
    let I, G, Z;
    if (typeof B === "undefined" && typeof Q === "undefined") I = {}, Z = A;
    else if (I = A, typeof B === "function") return G = B, Z = Q, $T4(I, G, Z);
    else Z = B;
    for (let D of Object.keys(Z)) {
      if (!Array.isArray(Z[D])) {
        I[D] = Z[D];
        continue
      }
      V30(I, null, Z, D)
    }
    return I
  }
  B2(cx1, "map");
  var UT4 = B2((A) => {
      let B = {};
      for (let [Q, I] of Object.entries(A || {})) B[Q] = [, I];
      return B
    }, "convertMap"),
    NT4 = B2((A, B) => {
      let Q = {};
      for (let I in B) V30(Q, A, B, I);
      return Q
    }, "take"),
    $T4 = B2((A, B, Q) => {
      return cx1(A, Object.entries(Q).reduce((I, [G, Z]) => {
        if (Array.isArray(Z)) I[G] = Z;
        else if (typeof Z === "function") I[G] = [B, Z()];
        else I[G] = [B, Z];
        return I
      }, {}))
    }, "mapWithFilter"),
    V30 = B2((A, B, Q, I) => {
      if (B !== null) {
        let D = Q[I];
        if (typeof D === "function") D = [, D];
        let [Y = qT4, W = MT4, J = I] = D;
        if (typeof Y === "function" && Y(B[J]) || typeof Y !== "function" && !!Y) A[I] = W(B[J]);
        return
      }
      let [G, Z] = Q[I];
      if (typeof Z === "function") {
        let D, Y = G === void 0 && (D = Z()) != null,
          W = typeof G === "function" && !!G(void 0) || typeof G !== "function" && !!G;
        if (Y) A[I] = D;
        else if (W) A[I] = Z()
      } else {
        let D = G === void 0 && Z != null,
          Y = typeof G === "function" && !!G(Z) || typeof G !== "function" && !!G;
        if (D || Y) A[I] = Z
      }
    }, "applyInstruction"),
    qT4 = B2((A) => A != null, "nonNullish"),
    MT4 = B2((A) => A, "pass");

  function C30(A) {
    if (A.includes(",") || A.includes('"')) A = `"${A.replace(/"/g,"\\\"")}"`;
    return A
  }
  B2(C30, "quoteHeader");
  var LT4 = B2((A) => {
      if (A !== A) return "NaN";
      switch (A) {
        case 1 / 0:
          return "Infinity";
        case -1 / 0:
          return "-Infinity";
        default:
          return A
      }
    }, "serializeFloat"),
    RT4 = B2((A) => A.toISOString().replace(".000Z", "Z"), "serializeDateTime"),
    hx1 = B2((A) => {
      if (A == null) return {};
      if (Array.isArray(A)) return A.filter((B) => B != null).map(hx1);
      if (typeof A === "object") {
        let B = {};
        for (let Q of Object.keys(A)) {
          if (A[Q] == null) continue;
          B[Q] = hx1(A[Q])
        }
        return B
      }
      return A
    }, "_json");

  function K30(A, B, Q) {
    if (Q <= 0 || !Number.isInteger(Q)) throw new Error("Invalid number of delimiters (" + Q + ") for splitEvery.");
    let I = A.split(B);
    if (Q === 1) return I;
    let G = [],
      Z = "";
    for (let D = 0; D < I.length; D++) {
      if (Z === "") Z = I[D];
      else Z += B + I[D];
      if ((D + 1) % Q === 0) G.push(Z), Z = ""
    }
    if (Z !== "") G.push(Z);
    return G
  }
  B2(K30, "splitEvery");
  var OT4 = B2((A) => {
    let B = A.length,
      Q = [],
      I = !1,
      G = void 0,
      Z = 0;
    for (let D = 0; D < B; ++D) {
      let Y = A[D];
      switch (Y) {
        case '"':
          if (G !== "\\") I = !I;
          break;
        case ",":
          if (!I) Q.push(A.slice(Z, D)), Z = D + 1;
          break;
        default:
      }
      G = Y
    }
    return Q.push(A.slice(Z)), Q.map((D) => {
      D = D.trim();
      let Y = D.length;
      if (Y < 2) return D;
      if (D[0] === '"' && D[Y - 1] === '"') D = D.slice(1, Y - 1);
      return D.replace(/\\"/g, '"')
    })
  }, "splitHeader")
})
// @from(Start 3823271, End 3823761)
E30 = z((z30) => {
  Object.defineProperty(z30, "__esModule", {
    value: !0
  });
  z30.fromBase64 = void 0;
  var TT4 = MZ(),
    PT4 = /^[A-Za-z0-9+/]*={0,2}$/,
    ST4 = (A) => {
      if (A.length * 3 % 4 !== 0) throw new TypeError("Incorrect padding on base64 string.");
      if (!PT4.exec(A)) throw new TypeError("Invalid base64 string.");
      let B = TT4.fromString(A, "base64");
      return new Uint8Array(B.buffer, B.byteOffset, B.byteLength)
    };
  z30.fromBase64 = ST4
})
// @from(Start 3823767, End 3824340)
$30 = z((U30) => {
  Object.defineProperty(U30, "__esModule", {
    value: !0
  });
  U30.toBase64 = void 0;
  var _T4 = MZ(),
    jT4 = RQ(),
    yT4 = (A) => {
      let B;
      if (typeof A === "string") B = jT4.fromUtf8(A);
      else B = A;
      if (typeof B !== "object" || typeof B.byteOffset !== "number" || typeof B.byteLength !== "number") throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
      return _T4.fromArrayBuffer(B.buffer, B.byteOffset, B.byteLength).toString("base64")
    };
  U30.toBase64 = yT4
})
// @from(Start 3824346, End 3825042)
L30 = z((kZ8, AG1) => {
  var {
    defineProperty: q30,
    getOwnPropertyDescriptor: kT4,
    getOwnPropertyNames: xT4
  } = Object, fT4 = Object.prototype.hasOwnProperty, lx1 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of xT4(B))
        if (!fT4.call(A, G) && G !== Q) q30(A, G, {
          get: () => B[G],
          enumerable: !(I = kT4(B, G)) || I.enumerable
        })
    }
    return A
  }, M30 = (A, B, Q) => (lx1(A, B, "default"), Q && lx1(Q, B, "default")), vT4 = (A) => lx1(q30({}, "__esModule", {
    value: !0
  }), A), ix1 = {};
  AG1.exports = vT4(ix1);
  M30(ix1, E30(), AG1.exports);
  M30(ix1, $30(), AG1.exports)
})
// @from(Start 3825048, End 3829875)
m30 = z((g30) => {
  Object.defineProperty(g30, "__esModule", {
    value: !0
  });
  g30.ruleSet = void 0;
  var f30 = "required",
    rz = "fn",
    oz = "argv",
    Wg = "ref",
    R30 = !0,
    O30 = "isSet",
    ia = "booleanEquals",
    Yg = "error",
    la = "endpoint",
    jD = "tree",
    nx1 = "PartitionResult",
    T30 = {
      [f30]: !1,
      type: "String"
    },
    P30 = {
      [f30]: !0,
      default: !1,
      type: "Boolean"
    },
    S30 = {
      [Wg]: "Endpoint"
    },
    v30 = {
      [rz]: ia,
      [oz]: [{
        [Wg]: "UseFIPS"
      }, !0]
    },
    b30 = {
      [rz]: ia,
      [oz]: [{
        [Wg]: "UseDualStack"
      }, !0]
    },
    sz = {},
    _30 = {
      [rz]: "getAttr",
      [oz]: [{
        [Wg]: nx1
      }, "supportsFIPS"]
    },
    j30 = {
      [rz]: ia,
      [oz]: [!0, {
        [rz]: "getAttr",
        [oz]: [{
          [Wg]: nx1
        }, "supportsDualStack"]
      }]
    },
    y30 = [v30],
    k30 = [b30],
    x30 = [{
      [Wg]: "Region"
    }],
    bT4 = {
      version: "1.0",
      parameters: {
        Region: T30,
        UseDualStack: P30,
        UseFIPS: P30,
        Endpoint: T30
      },
      rules: [{
        conditions: [{
          [rz]: O30,
          [oz]: [S30]
        }],
        rules: [{
          conditions: y30,
          error: "Invalid Configuration: FIPS and custom endpoint are not supported",
          type: Yg
        }, {
          rules: [{
            conditions: k30,
            error: "Invalid Configuration: Dualstack and custom endpoint are not supported",
            type: Yg
          }, {
            endpoint: {
              url: S30,
              properties: sz,
              headers: sz
            },
            type: la
          }],
          type: jD
        }],
        type: jD
      }, {
        rules: [{
          conditions: [{
            [rz]: O30,
            [oz]: x30
          }],
          rules: [{
            conditions: [{
              [rz]: "aws.partition",
              [oz]: x30,
              assign: nx1
            }],
            rules: [{
              conditions: [v30, b30],
              rules: [{
                conditions: [{
                  [rz]: ia,
                  [oz]: [R30, _30]
                }, j30],
                rules: [{
                  rules: [{
                    endpoint: {
                      url: "https://bedrock-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
                      properties: sz,
                      headers: sz
                    },
                    type: la
                  }],
                  type: jD
                }],
                type: jD
              }, {
                error: "FIPS and DualStack are enabled, but this partition does not support one or both",
                type: Yg
              }],
              type: jD
            }, {
              conditions: y30,
              rules: [{
                conditions: [{
                  [rz]: ia,
                  [oz]: [_30, R30]
                }],
                rules: [{
                  rules: [{
                    endpoint: {
                      url: "https://bedrock-fips.{Region}.{PartitionResult#dnsSuffix}",
                      properties: sz,
                      headers: sz
                    },
                    type: la
                  }],
                  type: jD
                }],
                type: jD
              }, {
                error: "FIPS is enabled but this partition does not support FIPS",
                type: Yg
              }],
              type: jD
            }, {
              conditions: k30,
              rules: [{
                conditions: [j30],
                rules: [{
                  rules: [{
                    endpoint: {
                      url: "https://bedrock.{Region}.{PartitionResult#dualStackDnsSuffix}",
                      properties: sz,
                      headers: sz
                    },
                    type: la
                  }],
                  type: jD
                }],
                type: jD
              }, {
                error: "DualStack is enabled but this partition does not support DualStack",
                type: Yg
              }],
              type: jD
            }, {
              rules: [{
                endpoint: {
                  url: "https://bedrock.{Region}.{PartitionResult#dnsSuffix}",
                  properties: sz,
                  headers: sz
                },
                type: la
              }],
              type: jD
            }],
            type: jD
          }],
          type: jD
        }, {
          error: "Invalid Configuration: Missing Region",
          type: Yg
        }],
        type: jD
      }]
    };
  g30.ruleSet = bT4
})
// @from(Start 3829881, End 3830439)
p30 = z((d30) => {
  Object.defineProperty(d30, "__esModule", {
    value: !0
  });
  d30.defaultEndpointResolver = void 0;
  var gT4 = RL(),
    ax1 = LL(),
    hT4 = m30(),
    mT4 = new ax1.EndpointCache({
      size: 50,
      params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
    }),
    dT4 = (A, B = {}) => {
      return mT4.get(A, () => ax1.resolveEndpoint(hT4.ruleSet, {
        endpointParams: A,
        logger: B.logger
      }))
    };
  d30.defaultEndpointResolver = dT4;
  ax1.customEndpointFunctions.aws = gT4.awsEndpointFunctions
})
// @from(Start 3830445, End 3831653)
a30 = z((i30) => {
  Object.defineProperty(i30, "__esModule", {
    value: !0
  });
  i30.getRuntimeConfig = void 0;
  var uT4 = IB(),
    pT4 = ca(),
    cT4 = FN(),
    c30 = L30(),
    l30 = RQ(),
    lT4 = Ky1(),
    iT4 = p30(),
    nT4 = (A) => {
      return {
        apiVersion: "2023-04-20",
        base64Decoder: A?.base64Decoder ?? c30.fromBase64,
        base64Encoder: A?.base64Encoder ?? c30.toBase64,
        disableHostPrefix: A?.disableHostPrefix ?? !1,
        endpointProvider: A?.endpointProvider ?? iT4.defaultEndpointResolver,
        extensions: A?.extensions ?? [],
        httpAuthSchemeProvider: A?.httpAuthSchemeProvider ?? lT4.defaultBedrockHttpAuthSchemeProvider,
        httpAuthSchemes: A?.httpAuthSchemes ?? [{
          schemeId: "aws.auth#sigv4",
          identityProvider: (B) => B.getIdentityProvider("aws.auth#sigv4"),
          signer: new uT4.AwsSdkSigV4Signer
        }],
        logger: A?.logger ?? new pT4.NoOpLogger,
        serviceId: A?.serviceId ?? "Bedrock",
        urlParser: A?.urlParser ?? cT4.parseUrl,
        utf8Decoder: A?.utf8Decoder ?? l30.fromUtf8,
        utf8Encoder: A?.utf8Encoder ?? l30.toUtf8
      }
    };
  i30.getRuntimeConfig = nT4
})
// @from(Start 3831659, End 3833860)
AQ0 = z((t30) => {
  Object.defineProperty(t30, "__esModule", {
    value: !0
  });
  t30.getRuntimeConfig = void 0;
  var aT4 = X10(),
    sT4 = aT4.__importDefault(V10()),
    rT4 = IB(),
    oT4 = ha(),
    s30 = I_(),
    BG1 = _D(),
    tT4 = G_(),
    r30 = KJ(),
    Jg = qC(),
    o30 = DN(),
    eT4 = Z_(),
    AP4 = vL(),
    BP4 = a30(),
    QP4 = ca(),
    IP4 = Y_(),
    GP4 = ca(),
    ZP4 = (A) => {
      GP4.emitWarningIfUnsupportedVersion(process.version);
      let B = IP4.resolveDefaultsModeConfig(A),
        Q = () => B().then(QP4.loadConfigsForDefaultMode),
        I = BP4.getRuntimeConfig(A);
      rT4.emitWarningIfUnsupportedVersion(process.version);
      let G = {
        profile: A?.profile
      };
      return {
        ...I,
        ...A,
        runtime: "node",
        defaultsMode: B,
        bodyLengthChecker: A?.bodyLengthChecker ?? eT4.calculateBodyLength,
        credentialDefaultProvider: A?.credentialDefaultProvider ?? oT4.defaultProvider,
        defaultUserAgentProvider: A?.defaultUserAgentProvider ?? s30.createDefaultUserAgentProvider({
          serviceId: I.serviceId,
          clientVersion: sT4.default.version
        }),
        maxAttempts: A?.maxAttempts ?? Jg.loadConfig(r30.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, A),
        region: A?.region ?? Jg.loadConfig(BG1.NODE_REGION_CONFIG_OPTIONS, {
          ...BG1.NODE_REGION_CONFIG_FILE_OPTIONS,
          ...G
        }),
        requestHandler: o30.NodeHttpHandler.create(A?.requestHandler ?? Q),
        retryMode: A?.retryMode ?? Jg.loadConfig({
          ...r30.NODE_RETRY_MODE_CONFIG_OPTIONS,
          default: async () => (await Q()).retryMode || AP4.DEFAULT_RETRY_MODE
        }, A),
        sha256: A?.sha256 ?? tT4.Hash.bind(null, "sha256"),
        streamCollector: A?.streamCollector ?? o30.streamCollector,
        useDualstackEndpoint: A?.useDualstackEndpoint ?? Jg.loadConfig(BG1.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, G),
        useFipsEndpoint: A?.useFipsEndpoint ?? Jg.loadConfig(BG1.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, G),
        userAgentAppId: A?.userAgentAppId ?? Jg.loadConfig(s30.NODE_APP_ID_CONFIG_OPTIONS, G)
      }
    };
  t30.getRuntimeConfig = ZP4
})
// @from(Start 3833866, End 3838373)
DQ0 = z((gZ8, ZQ0) => {
  var {
    defineProperty: QG1,
    getOwnPropertyDescriptor: DP4,
    getOwnPropertyNames: YP4
  } = Object, WP4 = Object.prototype.hasOwnProperty, nL = (A, B) => QG1(A, "name", {
    value: B,
    configurable: !0
  }), JP4 = (A, B) => {
    for (var Q in B) QG1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, FP4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of YP4(B))
        if (!WP4.call(A, G) && G !== Q) QG1(A, G, {
          get: () => B[G],
          enumerable: !(I = DP4(B, G)) || I.enumerable
        })
    }
    return A
  }, XP4 = (A) => FP4(QG1({}, "__esModule", {
    value: !0
  }), A), BQ0 = {};
  JP4(BQ0, {
    Field: () => KP4,
    Fields: () => HP4,
    HttpRequest: () => zP4,
    HttpResponse: () => wP4,
    IHttpRequest: () => QQ0.HttpRequest,
    getHttpHandlerExtensionConfiguration: () => VP4,
    isValidHostname: () => GQ0,
    resolveHttpHandlerRuntimeConfig: () => CP4
  });
  ZQ0.exports = XP4(BQ0);
  var VP4 = nL((A) => {
      return {
        setHttpHandler(B) {
          A.httpHandler = B
        },
        httpHandler() {
          return A.httpHandler
        },
        updateHttpClientConfig(B, Q) {
          A.httpHandler?.updateHttpClientConfig(B, Q)
        },
        httpHandlerConfigs() {
          return A.httpHandler.httpHandlerConfigs()
        }
      }
    }, "getHttpHandlerExtensionConfiguration"),
    CP4 = nL((A) => {
      return {
        httpHandler: A.httpHandler()
      }
    }, "resolveHttpHandlerRuntimeConfig"),
    QQ0 = yx1(),
    KP4 = class {
      static {
        nL(this, "Field")
      }
      constructor({
        name: A,
        kind: B = QQ0.FieldPosition.HEADER,
        values: Q = []
      }) {
        this.name = A, this.kind = B, this.values = Q
      }
      add(A) {
        this.values.push(A)
      }
      set(A) {
        this.values = A
      }
      remove(A) {
        this.values = this.values.filter((B) => B !== A)
      }
      toString() {
        return this.values.map((A) => A.includes(",") || A.includes(" ") ? `"${A}"` : A).join(", ")
      }
      get() {
        return this.values
      }
    },
    HP4 = class {
      constructor({
        fields: A = [],
        encoding: B = "utf-8"
      }) {
        this.entries = {}, A.forEach(this.setField.bind(this)), this.encoding = B
      }
      static {
        nL(this, "Fields")
      }
      setField(A) {
        this.entries[A.name.toLowerCase()] = A
      }
      getField(A) {
        return this.entries[A.toLowerCase()]
      }
      removeField(A) {
        delete this.entries[A.toLowerCase()]
      }
      getByType(A) {
        return Object.values(this.entries).filter((B) => B.kind === A)
      }
    },
    zP4 = class A {
      static {
        nL(this, "HttpRequest")
      }
      constructor(B) {
        this.method = B.method || "GET", this.hostname = B.hostname || "localhost", this.port = B.port, this.query = B.query || {}, this.headers = B.headers || {}, this.body = B.body, this.protocol = B.protocol ? B.protocol.slice(-1) !== ":" ? `${B.protocol}:` : B.protocol : "https:", this.path = B.path ? B.path.charAt(0) !== "/" ? `/${B.path}` : B.path : "/", this.username = B.username, this.password = B.password, this.fragment = B.fragment
      }
      static clone(B) {
        let Q = new A({
          ...B,
          headers: {
            ...B.headers
          }
        });
        if (Q.query) Q.query = IQ0(Q.query);
        return Q
      }
      static isInstance(B) {
        if (!B) return !1;
        let Q = B;
        return "method" in Q && "protocol" in Q && "hostname" in Q && "path" in Q && typeof Q.query === "object" && typeof Q.headers === "object"
      }
      clone() {
        return A.clone(this)
      }
    };

  function IQ0(A) {
    return Object.keys(A).reduce((B, Q) => {
      let I = A[Q];
      return {
        ...B,
        [Q]: Array.isArray(I) ? [...I] : I
      }
    }, {})
  }
  nL(IQ0, "cloneQuery");
  var wP4 = class {
    static {
      nL(this, "HttpResponse")
    }
    constructor(A) {
      this.statusCode = A.statusCode, this.reason = A.reason, this.headers = A.headers || {}, this.body = A.body
    }
    static isInstance(A) {
      if (!A) return !1;
      let B = A;
      return typeof B.statusCode === "number" && typeof B.headers === "object"
    }
  };

  function GQ0(A) {
    return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(A)
  }
  nL(GQ0, "isValidHostname")
})
// @from(Start 3838379, End 3838791)
sx1 = z((YQ0) => {
  Object.defineProperty(YQ0, "__esModule", {
    value: !0
  });
  YQ0.default = NP4;
  var EP4 = UP4(Z1("crypto"));

  function UP4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
  var GG1 = new Uint8Array(256),
    IG1 = GG1.length;

  function NP4() {
    if (IG1 > GG1.length - 16) EP4.default.randomFillSync(GG1), IG1 = 0;
    return GG1.slice(IG1, IG1 += 16)
  }
})
// @from(Start 3838797, End 3839058)
FQ0 = z((WQ0) => {
  Object.defineProperty(WQ0, "__esModule", {
    value: !0
  });
  WQ0.default = void 0;
  var qP4 = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
  WQ0.default = qP4
})
// @from(Start 3839064, End 3839400)
na = z((XQ0) => {
  Object.defineProperty(XQ0, "__esModule", {
    value: !0
  });
  XQ0.default = void 0;
  var MP4 = LP4(FQ0());

  function LP4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function RP4(A) {
    return typeof A === "string" && MP4.default.test(A)
  }
  var OP4 = RP4;
  XQ0.default = OP4
})
// @from(Start 3839406, End 3840230)
aa = z((KQ0) => {
  Object.defineProperty(KQ0, "__esModule", {
    value: !0
  });
  KQ0.default = void 0;
  KQ0.unsafeStringify = CQ0;
  var TP4 = PP4(na());

  function PP4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
  var SG = [];
  for (let A = 0; A < 256; ++A) SG.push((A + 256).toString(16).slice(1));

  function CQ0(A, B = 0) {
    return SG[A[B + 0]] + SG[A[B + 1]] + SG[A[B + 2]] + SG[A[B + 3]] + "-" + SG[A[B + 4]] + SG[A[B + 5]] + "-" + SG[A[B + 6]] + SG[A[B + 7]] + "-" + SG[A[B + 8]] + SG[A[B + 9]] + "-" + SG[A[B + 10]] + SG[A[B + 11]] + SG[A[B + 12]] + SG[A[B + 13]] + SG[A[B + 14]] + SG[A[B + 15]]
  }

  function SP4(A, B = 0) {
    let Q = CQ0(A, B);
    if (!TP4.default(Q)) throw TypeError("Stringified UUID is invalid");
    return Q
  }
  var _P4 = SP4;
  KQ0.default = _P4
})
// @from(Start 3840236, End 3841773)
UQ0 = z((wQ0) => {
  Object.defineProperty(wQ0, "__esModule", {
    value: !0
  });
  wQ0.default = void 0;
  var yP4 = xP4(sx1()),
    kP4 = aa();

  function xP4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
  var zQ0, rx1, ox1 = 0,
    tx1 = 0;

  function fP4(A, B, Q) {
    let I = B && Q || 0,
      G = B || new Array(16);
    A = A || {};
    let Z = A.node || zQ0,
      D = A.clockseq !== void 0 ? A.clockseq : rx1;
    if (Z == null || D == null) {
      let V = A.random || (A.rng || yP4.default)();
      if (Z == null) Z = zQ0 = [V[0] | 1, V[1], V[2], V[3], V[4], V[5]];
      if (D == null) D = rx1 = (V[6] << 8 | V[7]) & 16383
    }
    let Y = A.msecs !== void 0 ? A.msecs : Date.now(),
      W = A.nsecs !== void 0 ? A.nsecs : tx1 + 1,
      J = Y - ox1 + (W - tx1) / 1e4;
    if (J < 0 && A.clockseq === void 0) D = D + 1 & 16383;
    if ((J < 0 || Y > ox1) && A.nsecs === void 0) W = 0;
    if (W >= 1e4) throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
    ox1 = Y, tx1 = W, rx1 = D, Y += 12219292800000;
    let F = ((Y & 268435455) * 1e4 + W) % 4294967296;
    G[I++] = F >>> 24 & 255, G[I++] = F >>> 16 & 255, G[I++] = F >>> 8 & 255, G[I++] = F & 255;
    let X = Y / 4294967296 * 1e4 & 268435455;
    G[I++] = X >>> 8 & 255, G[I++] = X & 255, G[I++] = X >>> 24 & 15 | 16, G[I++] = X >>> 16 & 255, G[I++] = D >>> 8 | 128, G[I++] = D & 255;
    for (let V = 0; V < 6; ++V) G[I + V] = Z[V];
    return B || kP4.unsafeStringify(G)
  }
  var vP4 = fP4;
  wQ0.default = vP4
})
// @from(Start 3841779, End 3842657)
ex1 = z((NQ0) => {
  Object.defineProperty(NQ0, "__esModule", {
    value: !0
  });
  NQ0.default = void 0;
  var bP4 = gP4(na());

  function gP4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function hP4(A) {
    if (!bP4.default(A)) throw TypeError("Invalid UUID");
    let B, Q = new Uint8Array(16);
    return Q[0] = (B = parseInt(A.slice(0, 8), 16)) >>> 24, Q[1] = B >>> 16 & 255, Q[2] = B >>> 8 & 255, Q[3] = B & 255, Q[4] = (B = parseInt(A.slice(9, 13), 16)) >>> 8, Q[5] = B & 255, Q[6] = (B = parseInt(A.slice(14, 18), 16)) >>> 8, Q[7] = B & 255, Q[8] = (B = parseInt(A.slice(19, 23), 16)) >>> 8, Q[9] = B & 255, Q[10] = (B = parseInt(A.slice(24, 36), 16)) / 1099511627776 & 255, Q[11] = B / 4294967296 & 255, Q[12] = B >>> 24 & 255, Q[13] = B >>> 16 & 255, Q[14] = B >>> 8 & 255, Q[15] = B & 255, Q
  }
  var mP4 = hP4;
  NQ0.default = mP4
})
// @from(Start 3842663, End 3843923)
Af1 = z((LQ0) => {
  Object.defineProperty(LQ0, "__esModule", {
    value: !0
  });
  LQ0.URL = LQ0.DNS = void 0;
  LQ0.default = lP4;
  var dP4 = aa(),
    uP4 = pP4(ex1());

  function pP4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function cP4(A) {
    A = unescape(encodeURIComponent(A));
    let B = [];
    for (let Q = 0; Q < A.length; ++Q) B.push(A.charCodeAt(Q));
    return B
  }
  var qQ0 = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
  LQ0.DNS = qQ0;
  var MQ0 = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
  LQ0.URL = MQ0;

  function lP4(A, B, Q) {
    function I(G, Z, D, Y) {
      var W;
      if (typeof G === "string") G = cP4(G);
      if (typeof Z === "string") Z = uP4.default(Z);
      if (((W = Z) === null || W === void 0 ? void 0 : W.length) !== 16) throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
      let J = new Uint8Array(16 + G.length);
      if (J.set(Z), J.set(G, Z.length), J = Q(J), J[6] = J[6] & 15 | B, J[8] = J[8] & 63 | 128, D) {
        Y = Y || 0;
        for (let F = 0; F < 16; ++F) D[Y + F] = J[F];
        return D
      }
      return dP4.unsafeStringify(J)
    }
    try {
      I.name = A
    } catch (G) {}
    return I.DNS = qQ0, I.URL = MQ0, I
  }
})
// @from(Start 3843929, End 3844387)
PQ0 = z((OQ0) => {
  Object.defineProperty(OQ0, "__esModule", {
    value: !0
  });
  OQ0.default = void 0;
  var aP4 = sP4(Z1("crypto"));

  function sP4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function rP4(A) {
    if (Array.isArray(A)) A = Buffer.from(A);
    else if (typeof A === "string") A = Buffer.from(A, "utf8");
    return aP4.default.createHash("md5").update(A).digest()
  }
  var oP4 = rP4;
  OQ0.default = oP4
})
// @from(Start 3844393, End 3844717)
yQ0 = z((_Q0) => {
  Object.defineProperty(_Q0, "__esModule", {
    value: !0
  });
  _Q0.default = void 0;
  var tP4 = SQ0(Af1()),
    eP4 = SQ0(PQ0());

  function SQ0(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
  var AS4 = tP4.default("v3", 48, eP4.default),
    BS4 = AS4;
  _Q0.default = BS4
})
// @from(Start 3844723, End 3845027)
fQ0 = z((kQ0) => {
  Object.defineProperty(kQ0, "__esModule", {
    value: !0
  });
  kQ0.default = void 0;
  var QS4 = IS4(Z1("crypto"));

  function IS4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
  var GS4 = {
    randomUUID: QS4.default.randomUUID
  };
  kQ0.default = GS4
})
// @from(Start 3845033, End 3845687)
mQ0 = z((gQ0) => {
  Object.defineProperty(gQ0, "__esModule", {
    value: !0
  });
  gQ0.default = void 0;
  var vQ0 = bQ0(fQ0()),
    ZS4 = bQ0(sx1()),
    DS4 = aa();

  function bQ0(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function YS4(A, B, Q) {
    if (vQ0.default.randomUUID && !B && !A) return vQ0.default.randomUUID();
    A = A || {};
    let I = A.random || (A.rng || ZS4.default)();
    if (I[6] = I[6] & 15 | 64, I[8] = I[8] & 63 | 128, B) {
      Q = Q || 0;
      for (let G = 0; G < 16; ++G) B[Q + G] = I[G];
      return B
    }
    return DS4.unsafeStringify(I)
  }
  var WS4 = YS4;
  gQ0.default = WS4
})
// @from(Start 3845693, End 3846152)
pQ0 = z((dQ0) => {
  Object.defineProperty(dQ0, "__esModule", {
    value: !0
  });
  dQ0.default = void 0;
  var JS4 = FS4(Z1("crypto"));

  function FS4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function XS4(A) {
    if (Array.isArray(A)) A = Buffer.from(A);
    else if (typeof A === "string") A = Buffer.from(A, "utf8");
    return JS4.default.createHash("sha1").update(A).digest()
  }
  var VS4 = XS4;
  dQ0.default = VS4
})
// @from(Start 3846158, End 3846482)
nQ0 = z((lQ0) => {
  Object.defineProperty(lQ0, "__esModule", {
    value: !0
  });
  lQ0.default = void 0;
  var CS4 = cQ0(Af1()),
    KS4 = cQ0(pQ0());

  function cQ0(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
  var HS4 = CS4.default("v5", 80, KS4.default),
    zS4 = HS4;
  lQ0.default = zS4
})
// @from(Start 3846488, End 3846670)
rQ0 = z((aQ0) => {
  Object.defineProperty(aQ0, "__esModule", {
    value: !0
  });
  aQ0.default = void 0;
  var wS4 = "00000000-0000-0000-0000-000000000000";
  aQ0.default = wS4
})
// @from(Start 3846676, End 3847055)
eQ0 = z((oQ0) => {
  Object.defineProperty(oQ0, "__esModule", {
    value: !0
  });
  oQ0.default = void 0;
  var ES4 = US4(na());

  function US4(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }

  function NS4(A) {
    if (!ES4.default(A)) throw TypeError("Invalid UUID");
    return parseInt(A.slice(14, 15), 16)
  }
  var $S4 = NS4;
  oQ0.default = $S4
})
// @from(Start 3847061, End 3848475)
A70 = z((PC) => {
  Object.defineProperty(PC, "__esModule", {
    value: !0
  });
  Object.defineProperty(PC, "NIL", {
    enumerable: !0,
    get: function() {
      return OS4.default
    }
  });
  Object.defineProperty(PC, "parse", {
    enumerable: !0,
    get: function() {
      return _S4.default
    }
  });
  Object.defineProperty(PC, "stringify", {
    enumerable: !0,
    get: function() {
      return SS4.default
    }
  });
  Object.defineProperty(PC, "v1", {
    enumerable: !0,
    get: function() {
      return qS4.default
    }
  });
  Object.defineProperty(PC, "v3", {
    enumerable: !0,
    get: function() {
      return MS4.default
    }
  });
  Object.defineProperty(PC, "v4", {
    enumerable: !0,
    get: function() {
      return LS4.default
    }
  });
  Object.defineProperty(PC, "v5", {
    enumerable: !0,
    get: function() {
      return RS4.default
    }
  });
  Object.defineProperty(PC, "validate", {
    enumerable: !0,
    get: function() {
      return PS4.default
    }
  });
  Object.defineProperty(PC, "version", {
    enumerable: !0,
    get: function() {
      return TS4.default
    }
  });
  var qS4 = EN(UQ0()),
    MS4 = EN(yQ0()),
    LS4 = EN(mQ0()),
    RS4 = EN(nQ0()),
    OS4 = EN(rQ0()),
    TS4 = EN(eQ0()),
    PS4 = EN(na()),
    SS4 = EN(aa()),
    _S4 = EN(ex1());

  function EN(A) {
    return A && A.__esModule ? A : {
      default: A
    }
  }
})
// @from(Start 3848481, End 4024171)
rG0 = z((GD8, sG0) => {
  var {
    defineProperty: CG1,
    getOwnPropertyDescriptor: jS4,
    getOwnPropertyNames: yS4
  } = Object, kS4 = Object.prototype.hasOwnProperty, u = (A, B) => CG1(A, "name", {
    value: B,
    configurable: !0
  }), xS4 = (A, B) => {
    for (var Q in B) CG1(A, Q, {
      get: B[Q],
      enumerable: !0
    })
  }, fS4 = (A, B, Q, I) => {
    if (B && typeof B === "object" || typeof B === "function") {
      for (let G of yS4(B))
        if (!kS4.call(A, G) && G !== Q) CG1(A, G, {
          get: () => B[G],
          enumerable: !(I = jS4(B, G)) || I.enumerable
        })
    }
    return A
  }, vS4 = (A) => fS4(CG1({}, "__esModule", {
    value: !0
  }), A), M70 = {};
  xS4(M70, {
    AccessDeniedException: () => L70,
    ApplicationType: () => aS4,
    AutomatedEvaluationConfigFilterSensitiveLog: () => m70,
    AutomatedEvaluationCustomMetricConfigFilterSensitiveLog: () => g70,
    AutomatedEvaluationCustomMetricSource: () => DG1,
    AutomatedEvaluationCustomMetricSourceFilterSensitiveLog: () => b70,
    BatchDeleteEvaluationJobCommand: () => BG0,
    BatchDeleteEvaluationJobErrorFilterSensitiveLog: () => x70,
    BatchDeleteEvaluationJobItemFilterSensitiveLog: () => f70,
    BatchDeleteEvaluationJobRequestFilterSensitiveLog: () => k70,
    BatchDeleteEvaluationJobResponseFilterSensitiveLog: () => v70,
    Bedrock: () => aG0,
    BedrockClient: () => hY,
    BedrockServiceException: () => jC,
    ByteContentDocFilterSensitiveLog: () => n70,
    CommitmentDuration: () => j_4,
    ConflictException: () => R70,
    CreateEvaluationJobCommand: () => QG0,
    CreateEvaluationJobRequestFilterSensitiveLog: () => dI0,
    CreateGuardrailCommand: () => IG0,
    CreateGuardrailRequestFilterSensitiveLog: () => GI0,
    CreateGuardrailVersionCommand: () => GG0,
    CreateGuardrailVersionRequestFilterSensitiveLog: () => ZI0,
    CreateInferenceProfileCommand: () => ZG0,
    CreateInferenceProfileRequestFilterSensitiveLog: () => UI0,
    CreateMarketplaceModelEndpointCommand: () => DG0,
    CreateModelCopyJobCommand: () => YG0,
    CreateModelCustomizationJobCommand: () => WG0,
    CreateModelCustomizationJobRequestFilterSensitiveLog: () => kI0,
    CreateModelImportJobCommand: () => JG0,
    CreateModelInvocationJobCommand: () => FG0,
    CreatePromptRouterCommand: () => XG0,
    CreatePromptRouterRequestFilterSensitiveLog: () => SI0,
    CreateProvisionedModelThroughputCommand: () => VG0,
    CustomMetricDefinitionFilterSensitiveLog: () => v_4,
    CustomizationConfig: () => Ff1,
    CustomizationType: () => L_4,
    DeleteCustomModelCommand: () => CG0,
    DeleteGuardrailCommand: () => KG0,
    DeleteImportedModelCommand: () => HG0,
    DeleteInferenceProfileCommand: () => zG0,
    DeleteMarketplaceModelEndpointCommand: () => wG0,
    DeleteModelInvocationLoggingConfigurationCommand: () => EG0,
    DeletePromptRouterCommand: () => UG0,
    DeleteProvisionedModelThroughputCommand: () => NG0,
    DeregisterMarketplaceModelEndpointCommand: () => $G0,
    EndpointConfig: () => Bf1,
    EvaluationBedrockModelFilterSensitiveLog: () => c70,
    EvaluationConfig: () => YG1,
    EvaluationConfigFilterSensitiveLog: () => zf1,
    EvaluationDatasetFilterSensitiveLog: () => h70,
    EvaluationDatasetLocation: () => Qf1,
    EvaluationDatasetMetricConfigFilterSensitiveLog: () => Hf1,
    EvaluationInferenceConfig: () => XG1,
    EvaluationInferenceConfigFilterSensitiveLog: () => Mf1,
    EvaluationJobStatus: () => nS4,
    EvaluationJobType: () => B_4,
    EvaluationModelConfig: () => Gf1,
    EvaluationModelConfigFilterSensitiveLog: () => l70,
    EvaluationPrecomputedRagSourceConfig: () => Zf1,
    EvaluationTaskType: () => sS4,
    EvaluatorModelConfig: () => If1,
    ExternalSourceFilterSensitiveLog: () => a70,
    ExternalSourceType: () => oS4,
    ExternalSourcesGenerationConfigurationFilterSensitiveLog: () => i70,
    ExternalSourcesRetrieveAndGenerateConfigurationFilterSensitiveLog: () => s70,
    FineTuningJobStatus: () => f_4,
    FoundationModelLifecycleStatus: () => P_4,
    GenerationConfigurationFilterSensitiveLog: () => r70,
    GetCustomModelCommand: () => qG0,
    GetCustomModelResponseFilterSensitiveLog: () => PI0,
    GetEvaluationJobCommand: () => MG0,
    GetEvaluationJobRequestFilterSensitiveLog: () => o70,
    GetEvaluationJobResponseFilterSensitiveLog: () => uI0,
    GetFoundationModelCommand: () => LG0,
    GetGuardrailCommand: () => RG0,
    GetGuardrailResponseFilterSensitiveLog: () => HI0,
    GetImportedModelCommand: () => OG0,
    GetInferenceProfileCommand: () => TG0,
    GetInferenceProfileResponseFilterSensitiveLog: () => NI0,
    GetMarketplaceModelEndpointCommand: () => PG0,
    GetModelCopyJobCommand: () => SG0,
    GetModelCustomizationJobCommand: () => _G0,
    GetModelCustomizationJobResponseFilterSensitiveLog: () => xI0,
    GetModelImportJobCommand: () => jG0,
    GetModelInvocationJobCommand: () => yG0,
    GetModelInvocationJobResponseFilterSensitiveLog: () => MI0,
    GetModelInvocationLoggingConfigurationCommand: () => kG0,
    GetPromptRouterCommand: () => xG0,
    GetPromptRouterResponseFilterSensitiveLog: () => _I0,
    GetProvisionedModelThroughputCommand: () => fG0,
    GuardrailContentFilterAction: () => G_4,
    GuardrailContentFilterConfigFilterSensitiveLog: () => e70,
    GuardrailContentFilterFilterSensitiveLog: () => DI0,
    GuardrailContentFilterType: () => Y_4,
    GuardrailContentPolicyConfigFilterSensitiveLog: () => Ef1,
    GuardrailContentPolicyFilterSensitiveLog: () => YI0,
    GuardrailContextualGroundingAction: () => W_4,
    GuardrailContextualGroundingFilterConfigFilterSensitiveLog: () => AI0,
    GuardrailContextualGroundingFilterFilterSensitiveLog: () => WI0,
    GuardrailContextualGroundingFilterType: () => J_4,
    GuardrailContextualGroundingPolicyConfigFilterSensitiveLog: () => Uf1,
    GuardrailContextualGroundingPolicyFilterSensitiveLog: () => JI0,
    GuardrailFilterStrength: () => D_4,
    GuardrailManagedWordsConfigFilterSensitiveLog: () => QI0,
    GuardrailManagedWordsFilterSensitiveLog: () => VI0,
    GuardrailManagedWordsType: () => H_4,
    GuardrailModality: () => Z_4,
    GuardrailPiiEntityType: () => X_4,
    GuardrailSensitiveInformationAction: () => F_4,
    GuardrailStatus: () => z_4,
    GuardrailSummaryFilterSensitiveLog: () => zI0,
    GuardrailTopicAction: () => V_4,
    GuardrailTopicConfigFilterSensitiveLog: () => BI0,
    GuardrailTopicFilterSensitiveLog: () => FI0,
    GuardrailTopicPolicyConfigFilterSensitiveLog: () => Nf1,
    GuardrailTopicPolicyFilterSensitiveLog: () => XI0,
    GuardrailTopicType: () => C_4,
    GuardrailWordAction: () => K_4,
    GuardrailWordConfigFilterSensitiveLog: () => II0,
    GuardrailWordFilterSensitiveLog: () => CI0,
    GuardrailWordPolicyConfigFilterSensitiveLog: () => $f1,
    GuardrailWordPolicyFilterSensitiveLog: () => KI0,
    HumanEvaluationConfigFilterSensitiveLog: () => p70,
    HumanEvaluationCustomMetricFilterSensitiveLog: () => d70,
    HumanWorkflowConfigFilterSensitiveLog: () => u70,
    InferenceProfileModelSource: () => Df1,
    InferenceProfileStatus: () => w_4,
    InferenceProfileSummaryFilterSensitiveLog: () => $I0,
    InferenceProfileType: () => E_4,
    InferenceType: () => O_4,
    InternalServerException: () => O70,
    InvocationLogSource: () => Xf1,
    InvocationLogsConfigFilterSensitiveLog: () => TI0,
    KnowledgeBaseConfig: () => JG1,
    KnowledgeBaseConfigFilterSensitiveLog: () => hI0,
    KnowledgeBaseRetrievalConfigurationFilterSensitiveLog: () => qf1,
    KnowledgeBaseRetrieveAndGenerateConfigurationFilterSensitiveLog: () => vI0,
    KnowledgeBaseVectorSearchConfigurationFilterSensitiveLog: () => fI0,
    ListCustomModelsCommand: () => Lf1,
    ListEvaluationJobsCommand: () => Rf1,
    ListFoundationModelsCommand: () => vG0,
    ListGuardrailsCommand: () => Of1,
    ListGuardrailsResponseFilterSensitiveLog: () => wI0,
    ListImportedModelsCommand: () => Tf1,
    ListInferenceProfilesCommand: () => Pf1,
    ListInferenceProfilesResponseFilterSensitiveLog: () => qI0,
    ListMarketplaceModelEndpointsCommand: () => Sf1,
    ListModelCopyJobsCommand: () => _f1,
    ListModelCustomizationJobsCommand: () => jf1,
    ListModelImportJobsCommand: () => yf1,
    ListModelInvocationJobsCommand: () => kf1,
    ListModelInvocationJobsResponseFilterSensitiveLog: () => RI0,
    ListPromptRoutersCommand: () => xf1,
    ListPromptRoutersResponseFilterSensitiveLog: () => yI0,
    ListProvisionedModelThroughputsCommand: () => ff1,
    ListTagsForResourceCommand: () => bG0,
    ModelCopyJobStatus: () => U_4,
    ModelCustomization: () => R_4,
    ModelCustomizationJobStatus: () => x_4,
    ModelDataSource: () => Yf1,
    ModelImportJobStatus: () => N_4,
    ModelInvocationJobInputDataConfig: () => Wf1,
    ModelInvocationJobOutputDataConfig: () => Jf1,
    ModelInvocationJobStatus: () => M_4,
    ModelInvocationJobSummaryFilterSensitiveLog: () => LI0,
    ModelModality: () => T_4,
    PerformanceConfigLatency: () => rS4,
    PromptRouterStatus: () => S_4,
    PromptRouterSummaryFilterSensitiveLog: () => jI0,
    PromptRouterType: () => __4,
    PromptTemplateFilterSensitiveLog: () => wf1,
    ProvisionedModelStatus: () => y_4,
    PutModelInvocationLoggingConfigurationCommand: () => gG0,
    QueryTransformationType: () => tS4,
    RAGConfig: () => FG1,
    RAGConfigFilterSensitiveLog: () => mI0,
    RatingScaleItemValue: () => ZG1,
    RegisterMarketplaceModelEndpointCommand: () => hG0,
    RequestMetadataBaseFiltersFilterSensitiveLog: () => Cf1,
    RequestMetadataFilters: () => Vf1,
    RequestMetadataFiltersFilterSensitiveLog: () => OI0,
    ResourceNotFoundException: () => T70,
    RetrievalFilter: () => WG1,
    RetrievalFilterFilterSensitiveLog: () => b_4,
    RetrieveAndGenerateConfigurationFilterSensitiveLog: () => gI0,
    RetrieveAndGenerateType: () => A_4,
    RetrieveConfigFilterSensitiveLog: () => bI0,
    S3InputFormat: () => q_4,
    SearchType: () => eS4,
    ServiceQuotaExceededException: () => P70,
    ServiceUnavailableException: () => j70,
    SortByProvisionedModels: () => k_4,
    SortJobsBy: () => Q_4,
    SortModelsBy: () => $_4,
    SortOrder: () => I_4,
    Status: () => iS4,
    StopEvaluationJobCommand: () => mG0,
    StopEvaluationJobRequestFilterSensitiveLog: () => t70,
    StopModelCustomizationJobCommand: () => dG0,
    StopModelInvocationJobCommand: () => uG0,
    TagResourceCommand: () => pG0,
    ThrottlingException: () => S70,
    TooManyTagsException: () => y70,
    TrainingDataConfigFilterSensitiveLog: () => KG1,
    UntagResourceCommand: () => cG0,
    UpdateGuardrailCommand: () => lG0,
    UpdateGuardrailRequestFilterSensitiveLog: () => EI0,
    UpdateMarketplaceModelEndpointCommand: () => iG0,
    UpdateProvisionedModelThroughputCommand: () => nG0,
    ValidationException: () => _70,
    __Client: () => j.Client,
    paginateListCustomModels: () => hx4,
    paginateListEvaluationJobs: () => mx4,
    paginateListGuardrails: () => dx4,
    paginateListImportedModels: () => ux4,
    paginateListInferenceProfiles: () => px4,
    paginateListMarketplaceModelEndpoints: () => cx4,
    paginateListModelCopyJobs: () => lx4,
    paginateListModelCustomizationJobs: () => ix4,
    paginateListModelImportJobs: () => nx4,
    paginateListModelInvocationJobs: () => ax4,
    paginateListPromptRouters: () => sx4,
    paginateListProvisionedModelThroughputs: () => rx4
  });
  sG0.exports = vS4(M70);
  var B70 = cS(),
    bS4 = lS(),
    gS4 = iS(),
    Q70 = jL(),
    hS4 = _D(),
    C2 = NI(),
    mS4 = tS(),
    I9 = hz(),
    I70 = KJ(),
    G70 = Ky1(),
    dS4 = u((A) => {
      return Object.assign(A, {
        useDualstackEndpoint: A.useDualstackEndpoint ?? !1,
        useFipsEndpoint: A.useFipsEndpoint ?? !1,
        defaultSigningName: "bedrock"
      })
    }, "resolveClientEndpointParameters"),
    Y9 = {
      UseFIPS: {
        type: "builtInParams",
        name: "useFipsEndpoint"
      },
      Endpoint: {
        type: "builtInParams",
        name: "endpoint"
      },
      Region: {
        type: "builtInParams",
        name: "region"
      },
      UseDualStack: {
        type: "builtInParams",
        name: "useDualstackEndpoint"
      }
    },
    uS4 = AQ0(),
    Z70 = W_(),
    D70 = DQ0(),
    j = ca(),
    pS4 = u((A) => {
      let {
        httpAuthSchemes: B,
        httpAuthSchemeProvider: Q,
        credentials: I
      } = A;
      return {
        setHttpAuthScheme(G) {
          let Z = B.findIndex((D) => D.schemeId === G.schemeId);
          if (Z === -1) B.push(G);
          else B.splice(Z, 1, G)
        },
        httpAuthSchemes() {
          return B
        },
        setHttpAuthSchemeProvider(G) {
          Q = G
        },
        httpAuthSchemeProvider() {
          return Q
        },
        setCredentials(G) {
          I = G
        },
        credentials() {
          return I
        }
      }
    }, "getHttpAuthExtensionConfiguration"),
    cS4 = u((A) => {
      return {
        httpAuthSchemes: A.httpAuthSchemes(),
        httpAuthSchemeProvider: A.httpAuthSchemeProvider(),
        credentials: A.credentials()
      }
    }, "resolveHttpAuthRuntimeConfig"),
    lS4 = u((A, B) => {
      let Q = Object.assign(Z70.getAwsRegionExtensionConfiguration(A), j.getDefaultExtensionConfiguration(A), D70.getHttpHandlerExtensionConfiguration(A), pS4(A));
      return B.forEach((I) => I.configure(Q)), Object.assign(A, Z70.resolveAwsRegionExtensionConfiguration(Q), j.resolveDefaultRuntimeConfig(Q), D70.resolveHttpHandlerRuntimeConfig(Q), cS4(Q))
    }, "resolveRuntimeExtensions"),
    hY = class extends j.Client {
      static {
        u(this, "BedrockClient")
      }
      config;
      constructor(...[A]) {
        let B = uS4.getRuntimeConfig(A || {});
        super(B);
        this.initConfig = B;
        let Q = dS4(B),
          I = Q70.resolveUserAgentConfig(Q),
          G = I70.resolveRetryConfig(I),
          Z = hS4.resolveRegionConfig(G),
          D = B70.resolveHostHeaderConfig(Z),
          Y = I9.resolveEndpointConfig(D),
          W = G70.resolveHttpAuthSchemeConfig(Y),
          J = lS4(W, A?.extensions || []);
        this.config = J, this.middlewareStack.use(Q70.getUserAgentPlugin(this.config)), this.middlewareStack.use(I70.getRetryPlugin(this.config)), this.middlewareStack.use(mS4.getContentLengthPlugin(this.config)), this.middlewareStack.use(B70.getHostHeaderPlugin(this.config)), this.middlewareStack.use(bS4.getLoggerPlugin(this.config)), this.middlewareStack.use(gS4.getRecursionDetectionPlugin(this.config)), this.middlewareStack.use(C2.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
          httpAuthSchemeParametersProvider: G70.defaultBedrockHttpAuthSchemeParametersProvider,
          identityProviderConfigProvider: u(async (F) => new C2.DefaultIdentityProviderConfig({
            "aws.auth#sigv4": F.credentials
          }), "identityProviderConfigProvider")
        })), this.middlewareStack.use(C2.getHttpSigningPlugin(this.config))
      }
      destroy() {
        super.destroy()
      }
    },
    W9 = yz(),
    jC = class A extends j.ServiceException {
      static {
        u(this, "BedrockServiceException")
      }
      constructor(B) {
        super(B);
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    L70 = class A extends jC {
      static {
        u(this, "AccessDeniedException")
      }
      name = "AccessDeniedException";
      $fault = "client";
      constructor(B) {
        super({
          name: "AccessDeniedException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    R70 = class A extends jC {
      static {
        u(this, "ConflictException")
      }
      name = "ConflictException";
      $fault = "client";
      constructor(B) {
        super({
          name: "ConflictException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    Bf1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.sageMaker !== void 0) return Q.sageMaker(B.sageMaker);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(Bf1 || (Bf1 = {}));
  var iS4 = {
      INCOMPATIBLE_ENDPOINT: "INCOMPATIBLE_ENDPOINT",
      REGISTERED: "REGISTERED"
    },
    O70 = class A extends jC {
      static {
        u(this, "InternalServerException")
      }
      name = "InternalServerException";
      $fault = "server";
      constructor(B) {
        super({
          name: "InternalServerException",
          $fault: "server",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    T70 = class A extends jC {
      static {
        u(this, "ResourceNotFoundException")
      }
      name = "ResourceNotFoundException";
      $fault = "client";
      constructor(B) {
        super({
          name: "ResourceNotFoundException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    P70 = class A extends jC {
      static {
        u(this, "ServiceQuotaExceededException")
      }
      name = "ServiceQuotaExceededException";
      $fault = "client";
      constructor(B) {
        super({
          name: "ServiceQuotaExceededException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    S70 = class A extends jC {
      static {
        u(this, "ThrottlingException")
      }
      name = "ThrottlingException";
      $fault = "client";
      constructor(B) {
        super({
          name: "ThrottlingException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    _70 = class A extends jC {
      static {
        u(this, "ValidationException")
      }
      name = "ValidationException";
      $fault = "client";
      constructor(B) {
        super({
          name: "ValidationException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    j70 = class A extends jC {
      static {
        u(this, "ServiceUnavailableException")
      }
      name = "ServiceUnavailableException";
      $fault = "server";
      constructor(B) {
        super({
          name: "ServiceUnavailableException",
          $fault: "server",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype)
      }
    },
    nS4 = {
      COMPLETED: "Completed",
      DELETING: "Deleting",
      FAILED: "Failed",
      IN_PROGRESS: "InProgress",
      STOPPED: "Stopped",
      STOPPING: "Stopping"
    },
    aS4 = {
      MODEL_EVALUATION: "ModelEvaluation",
      RAG_EVALUATION: "RagEvaluation"
    },
    ZG1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.stringValue !== void 0) return Q.stringValue(B.stringValue);
      if (B.floatValue !== void 0) return Q.floatValue(B.floatValue);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(ZG1 || (ZG1 = {}));
  var DG1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.customMetricDefinition !== void 0) return Q.customMetricDefinition(B.customMetricDefinition);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(DG1 || (DG1 = {}));
  var Qf1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.s3Uri !== void 0) return Q.s3Uri(B.s3Uri);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(Qf1 || (Qf1 = {}));
  var sS4 = {
      CLASSIFICATION: "Classification",
      CUSTOM: "Custom",
      GENERATION: "Generation",
      QUESTION_AND_ANSWER: "QuestionAndAnswer",
      SUMMARIZATION: "Summarization"
    },
    If1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.bedrockEvaluatorModels !== void 0) return Q.bedrockEvaluatorModels(B.bedrockEvaluatorModels);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(If1 || (If1 = {}));
  var YG1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.automated !== void 0) return Q.automated(B.automated);
      if (B.human !== void 0) return Q.human(B.human);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(YG1 || (YG1 = {}));
  var rS4 = {
      OPTIMIZED: "optimized",
      STANDARD: "standard"
    },
    Gf1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.bedrockModel !== void 0) return Q.bedrockModel(B.bedrockModel);
      if (B.precomputedInferenceSource !== void 0) return Q.precomputedInferenceSource(B.precomputedInferenceSource);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(Gf1 || (Gf1 = {}));
  var oS4 = {
      BYTE_CONTENT: "BYTE_CONTENT",
      S3: "S3"
    },
    tS4 = {
      QUERY_DECOMPOSITION: "QUERY_DECOMPOSITION"
    },
    eS4 = {
      HYBRID: "HYBRID",
      SEMANTIC: "SEMANTIC"
    },
    A_4 = {
      EXTERNAL_SOURCES: "EXTERNAL_SOURCES",
      KNOWLEDGE_BASE: "KNOWLEDGE_BASE"
    },
    Zf1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.retrieveSourceConfig !== void 0) return Q.retrieveSourceConfig(B.retrieveSourceConfig);
      if (B.retrieveAndGenerateSourceConfig !== void 0) return Q.retrieveAndGenerateSourceConfig(B.retrieveAndGenerateSourceConfig);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(Zf1 || (Zf1 = {}));
  var B_4 = {
      AUTOMATED: "Automated",
      HUMAN: "Human"
    },
    Q_4 = {
      CREATION_TIME: "CreationTime"
    },
    I_4 = {
      ASCENDING: "Ascending",
      DESCENDING: "Descending"
    },
    G_4 = {
      BLOCK: "BLOCK",
      NONE: "NONE"
    },
    Z_4 = {
      IMAGE: "IMAGE",
      TEXT: "TEXT"
    },
    D_4 = {
      HIGH: "HIGH",
      LOW: "LOW",
      MEDIUM: "MEDIUM",
      NONE: "NONE"
    },
    Y_4 = {
      HATE: "HATE",
      INSULTS: "INSULTS",
      MISCONDUCT: "MISCONDUCT",
      PROMPT_ATTACK: "PROMPT_ATTACK",
      SEXUAL: "SEXUAL",
      VIOLENCE: "VIOLENCE"
    },
    W_4 = {
      BLOCK: "BLOCK",
      NONE: "NONE"
    },
    J_4 = {
      GROUNDING: "GROUNDING",
      RELEVANCE: "RELEVANCE"
    },
    F_4 = {
      ANONYMIZE: "ANONYMIZE",
      BLOCK: "BLOCK",
      NONE: "NONE"
    },
    X_4 = {
      ADDRESS: "ADDRESS",
      AGE: "AGE",
      AWS_ACCESS_KEY: "AWS_ACCESS_KEY",
      AWS_SECRET_KEY: "AWS_SECRET_KEY",
      CA_HEALTH_NUMBER: "CA_HEALTH_NUMBER",
      CA_SOCIAL_INSURANCE_NUMBER: "CA_SOCIAL_INSURANCE_NUMBER",
      CREDIT_DEBIT_CARD_CVV: "CREDIT_DEBIT_CARD_CVV",
      CREDIT_DEBIT_CARD_EXPIRY: "CREDIT_DEBIT_CARD_EXPIRY",
      CREDIT_DEBIT_CARD_NUMBER: "CREDIT_DEBIT_CARD_NUMBER",
      DRIVER_ID: "DRIVER_ID",
      EMAIL: "EMAIL",
      INTERNATIONAL_BANK_ACCOUNT_NUMBER: "INTERNATIONAL_BANK_ACCOUNT_NUMBER",
      IP_ADDRESS: "IP_ADDRESS",
      LICENSE_PLATE: "LICENSE_PLATE",
      MAC_ADDRESS: "MAC_ADDRESS",
      NAME: "NAME",
      PASSWORD: "PASSWORD",
      PHONE: "PHONE",
      PIN: "PIN",
      SWIFT_CODE: "SWIFT_CODE",
      UK_NATIONAL_HEALTH_SERVICE_NUMBER: "UK_NATIONAL_HEALTH_SERVICE_NUMBER",
      UK_NATIONAL_INSURANCE_NUMBER: "UK_NATIONAL_INSURANCE_NUMBER",
      UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER: "UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER",
      URL: "URL",
      USERNAME: "USERNAME",
      US_BANK_ACCOUNT_NUMBER: "US_BANK_ACCOUNT_NUMBER",
      US_BANK_ROUTING_NUMBER: "US_BANK_ROUTING_NUMBER",
      US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER: "US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER",
      US_PASSPORT_NUMBER: "US_PASSPORT_NUMBER",
      US_SOCIAL_SECURITY_NUMBER: "US_SOCIAL_SECURITY_NUMBER",
      VEHICLE_IDENTIFICATION_NUMBER: "VEHICLE_IDENTIFICATION_NUMBER"
    },
    V_4 = {
      BLOCK: "BLOCK",
      NONE: "NONE"
    },
    C_4 = {
      DENY: "DENY"
    },
    K_4 = {
      BLOCK: "BLOCK",
      NONE: "NONE"
    },
    H_4 = {
      PROFANITY: "PROFANITY"
    },
    y70 = class A extends jC {
      static {
        u(this, "TooManyTagsException")
      }
      name = "TooManyTagsException";
      $fault = "client";
      resourceName;
      constructor(B) {
        super({
          name: "TooManyTagsException",
          $fault: "client",
          ...B
        });
        Object.setPrototypeOf(this, A.prototype), this.resourceName = B.resourceName
      }
    },
    z_4 = {
      CREATING: "CREATING",
      DELETING: "DELETING",
      FAILED: "FAILED",
      READY: "READY",
      UPDATING: "UPDATING",
      VERSIONING: "VERSIONING"
    },
    Df1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.copyFrom !== void 0) return Q.copyFrom(B.copyFrom);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(Df1 || (Df1 = {}));
  var w_4 = {
      ACTIVE: "ACTIVE"
    },
    E_4 = {
      APPLICATION: "APPLICATION",
      SYSTEM_DEFINED: "SYSTEM_DEFINED"
    },
    U_4 = {
      COMPLETED: "Completed",
      FAILED: "Failed",
      IN_PROGRESS: "InProgress"
    },
    Yf1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.s3DataSource !== void 0) return Q.s3DataSource(B.s3DataSource);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(Yf1 || (Yf1 = {}));
  var N_4 = {
      COMPLETED: "Completed",
      FAILED: "Failed",
      IN_PROGRESS: "InProgress"
    },
    $_4 = {
      CREATION_TIME: "CreationTime"
    },
    q_4 = {
      JSONL: "JSONL"
    },
    Wf1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.s3InputDataConfig !== void 0) return Q.s3InputDataConfig(B.s3InputDataConfig);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(Wf1 || (Wf1 = {}));
  var Jf1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.s3OutputDataConfig !== void 0) return Q.s3OutputDataConfig(B.s3OutputDataConfig);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(Jf1 || (Jf1 = {}));
  var M_4 = {
      COMPLETED: "Completed",
      EXPIRED: "Expired",
      FAILED: "Failed",
      IN_PROGRESS: "InProgress",
      PARTIALLY_COMPLETED: "PartiallyCompleted",
      SCHEDULED: "Scheduled",
      STOPPED: "Stopped",
      STOPPING: "Stopping",
      SUBMITTED: "Submitted",
      VALIDATING: "Validating"
    },
    Ff1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.distillationConfig !== void 0) return Q.distillationConfig(B.distillationConfig);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(Ff1 || (Ff1 = {}));
  var L_4 = {
      CONTINUED_PRE_TRAINING: "CONTINUED_PRE_TRAINING",
      DISTILLATION: "DISTILLATION",
      FINE_TUNING: "FINE_TUNING"
    },
    Xf1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.s3Uri !== void 0) return Q.s3Uri(B.s3Uri);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(Xf1 || (Xf1 = {}));
  var Vf1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.equals !== void 0) return Q.equals(B.equals);
      if (B.notEquals !== void 0) return Q.notEquals(B.notEquals);
      if (B.andAll !== void 0) return Q.andAll(B.andAll);
      if (B.orAll !== void 0) return Q.orAll(B.orAll);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(Vf1 || (Vf1 = {}));
  var R_4 = {
      CONTINUED_PRE_TRAINING: "CONTINUED_PRE_TRAINING",
      DISTILLATION: "DISTILLATION",
      FINE_TUNING: "FINE_TUNING"
    },
    O_4 = {
      ON_DEMAND: "ON_DEMAND",
      PROVISIONED: "PROVISIONED"
    },
    T_4 = {
      EMBEDDING: "EMBEDDING",
      IMAGE: "IMAGE",
      TEXT: "TEXT"
    },
    P_4 = {
      ACTIVE: "ACTIVE",
      LEGACY: "LEGACY"
    },
    S_4 = {
      AVAILABLE: "AVAILABLE"
    },
    __4 = {
      CUSTOM: "custom",
      DEFAULT: "default"
    },
    j_4 = {
      ONE_MONTH: "OneMonth",
      SIX_MONTHS: "SixMonths"
    },
    y_4 = {
      CREATING: "Creating",
      FAILED: "Failed",
      IN_SERVICE: "InService",
      UPDATING: "Updating"
    },
    k_4 = {
      CREATION_TIME: "CreationTime"
    },
    x_4 = {
      COMPLETED: "Completed",
      FAILED: "Failed",
      IN_PROGRESS: "InProgress",
      STOPPED: "Stopped",
      STOPPING: "Stopping"
    },
    f_4 = {
      COMPLETED: "Completed",
      FAILED: "Failed",
      IN_PROGRESS: "InProgress",
      STOPPED: "Stopped",
      STOPPING: "Stopping"
    },
    WG1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.equals !== void 0) return Q.equals(B.equals);
      if (B.notEquals !== void 0) return Q.notEquals(B.notEquals);
      if (B.greaterThan !== void 0) return Q.greaterThan(B.greaterThan);
      if (B.greaterThanOrEquals !== void 0) return Q.greaterThanOrEquals(B.greaterThanOrEquals);
      if (B.lessThan !== void 0) return Q.lessThan(B.lessThan);
      if (B.lessThanOrEquals !== void 0) return Q.lessThanOrEquals(B.lessThanOrEquals);
      if (B.in !== void 0) return Q.in(B.in);
      if (B.notIn !== void 0) return Q.notIn(B.notIn);
      if (B.startsWith !== void 0) return Q.startsWith(B.startsWith);
      if (B.listContains !== void 0) return Q.listContains(B.listContains);
      if (B.stringContains !== void 0) return Q.stringContains(B.stringContains);
      if (B.andAll !== void 0) return Q.andAll(B.andAll);
      if (B.orAll !== void 0) return Q.orAll(B.orAll);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(WG1 || (WG1 = {}));
  var JG1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.retrieveConfig !== void 0) return Q.retrieveConfig(B.retrieveConfig);
      if (B.retrieveAndGenerateConfig !== void 0) return Q.retrieveAndGenerateConfig(B.retrieveAndGenerateConfig);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(JG1 || (JG1 = {}));
  var FG1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.knowledgeBaseConfig !== void 0) return Q.knowledgeBaseConfig(B.knowledgeBaseConfig);
      if (B.precomputedRagSourceConfig !== void 0) return Q.precomputedRagSourceConfig(B.precomputedRagSourceConfig);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(FG1 || (FG1 = {}));
  var XG1;
  ((A) => {
    A.visit = u((B, Q) => {
      if (B.models !== void 0) return Q.models(B.models);
      if (B.ragConfigs !== void 0) return Q.ragConfigs(B.ragConfigs);
      return Q._(B.$unknown[0], B.$unknown[1])
    }, "visit")
  })(XG1 || (XG1 = {}));
  var k70 = u((A) => ({
      ...A,
      ...A.jobIdentifiers && {
        jobIdentifiers: j.SENSITIVE_STRING
      }
    }), "BatchDeleteEvaluationJobRequestFilterSensitiveLog"),
    x70 = u((A) => ({
      ...A,
      ...A.jobIdentifier && {
        jobIdentifier: j.SENSITIVE_STRING
      }
    }), "BatchDeleteEvaluationJobErrorFilterSensitiveLog"),
    f70 = u((A) => ({
      ...A,
      ...A.jobIdentifier && {
        jobIdentifier: j.SENSITIVE_STRING
      }
    }), "BatchDeleteEvaluationJobItemFilterSensitiveLog"),
    v70 = u((A) => ({
      ...A,
      ...A.errors && {
        errors: A.errors.map((B) => x70(B))
      },
      ...A.evaluationJobs && {
        evaluationJobs: A.evaluationJobs.map((B) => f70(B))
      }
    }), "BatchDeleteEvaluationJobResponseFilterSensitiveLog"),
    v_4 = u((A) => ({
      ...A,
      ...A.name && {
        name: j.SENSITIVE_STRING
      },
      ...A.ratingScale && {
        ratingScale: A.ratingScale.map((B) => B)
      }
    }), "CustomMetricDefinitionFilterSensitiveLog"),
    b70 = u((A) => {
      if (A.customMetricDefinition !== void 0) return {
        customMetricDefinition: j.SENSITIVE_STRING
      };
      if (A.$unknown !== void 0) return {
        [A.$unknown[0]]: "UNKNOWN"
      }
    }, "AutomatedEvaluationCustomMetricSourceFilterSensitiveLog"),
    g70 = u((A) => ({
      ...A,
      ...A.customMetrics && {
        customMetrics: A.customMetrics.map((B) => b70(B))
      }
    }), "AutomatedEvaluationCustomMetricConfigFilterSensitiveLog"),
    h70 = u((A) => ({
      ...A,
      ...A.name && {
        name: j.SENSITIVE_STRING
      },
      ...A.datasetLocation && {
        datasetLocation: A.datasetLocation
      }
    }), "EvaluationDatasetFilterSensitiveLog"),
    Hf1 = u((A) => ({
      ...A,
      ...A.dataset && {
        dataset: h70(A.dataset)
      },
      ...A.metricNames && {
        metricNames: j.SENSITIVE_STRING
      }
    }), "EvaluationDatasetMetricConfigFilterSensitiveLog"),
    m70 = u((A) => ({
      ...A,
      ...A.datasetMetricConfigs && {
        datasetMetricConfigs: A.datasetMetricConfigs.map((B) => Hf1(B))
      },
      ...A.evaluatorModelConfig && {
        evaluatorModelConfig: A.evaluatorModelConfig
      },
      ...A.customMetricConfig && {
        customMetricConfig: g70(A.customMetricConfig)
      }
    }), "AutomatedEvaluationConfigFilterSensitiveLog"),
    d70 = u((A) => ({
      ...A,
      ...A.name && {
        name: j.SENSITIVE_STRING
      },
      ...A.description && {
        description: j.SENSITIVE_STRING
      }
    }), "HumanEvaluationCustomMetricFilterSensitiveLog"),
    u70 = u((A) => ({
      ...A,
      ...A.instructions && {
        instructions: j.SENSITIVE_STRING
      }
    }), "HumanWorkflowConfigFilterSensitiveLog"),
    p70 = u((A) => ({
      ...A,
      ...A.humanWorkflowConfig && {
        humanWorkflowConfig: u70(A.humanWorkflowConfig)
      },
      ...A.customMetrics && {
        customMetrics: A.customMetrics.map((B) => d70(B))
      },
      ...A.datasetMetricConfigs && {
        datasetMetricConfigs: A.datasetMetricConfigs.map((B) => Hf1(B))
      }
    }), "HumanEvaluationConfigFilterSensitiveLog"),
    zf1 = u((A) => {
      if (A.automated !== void 0) return {
        automated: m70(A.automated)
      };
      if (A.human !== void 0) return {
        human: p70(A.human)
      };
      if (A.$unknown !== void 0) return {
        [A.$unknown[0]]: "UNKNOWN"
      }
    }, "EvaluationConfigFilterSensitiveLog"),
    c70 = u((A) => ({
      ...A,
      ...A.inferenceParams && {
        inferenceParams: j.SENSITIVE_STRING
      }
    }), "EvaluationBedrockModelFilterSensitiveLog"),
    l70 = u((A) => {
      if (A.bedrockModel !== void 0) return {
        bedrockModel: c70(A.bedrockModel)
      };
      if (A.precomputedInferenceSource !== void 0) return {
        precomputedInferenceSource: A.precomputedInferenceSource
      };
      if (A.$unknown !== void 0) return {
        [A.$unknown[0]]: "UNKNOWN"
      }
    }, "EvaluationModelConfigFilterSensitiveLog"),
    wf1 = u((A) => ({
      ...A,
      ...A.textPromptTemplate && {
        textPromptTemplate: j.SENSITIVE_STRING
      }
    }), "PromptTemplateFilterSensitiveLog"),
    i70 = u((A) => ({
      ...A,
      ...A.promptTemplate && {
        promptTemplate: wf1(A.promptTemplate)
      }
    }), "ExternalSourcesGenerationConfigurationFilterSensitiveLog"),
    n70 = u((A) => ({
      ...A,
      ...A.identifier && {
        identifier: j.SENSITIVE_STRING
      },
      ...A.data && {
        data: j.SENSITIVE_STRING
      }
    }), "ByteContentDocFilterSensitiveLog"),
    a70 = u((A) => ({
      ...A,
      ...A.byteContent && {
        byteContent: n70(A.byteContent)
      }
    }), "ExternalSourceFilterSensitiveLog"),
    s70 = u((A) => ({
      ...A,
      ...A.sources && {
        sources: A.sources.map((B) => a70(B))
      },
      ...A.generationConfiguration && {
        generationConfiguration: i70(A.generationConfiguration)
      }
    }), "ExternalSourcesRetrieveAndGenerateConfigurationFilterSensitiveLog"),
    r70 = u((A) => ({
      ...A,
      ...A.promptTemplate && {
        promptTemplate: wf1(A.promptTemplate)
      }
    }), "GenerationConfigurationFilterSensitiveLog"),
    o70 = u((A) => ({
      ...A,
      ...A.jobIdentifier && {
        jobIdentifier: j.SENSITIVE_STRING
      }
    }), "GetEvaluationJobRequestFilterSensitiveLog"),
    t70 = u((A) => ({
      ...A,
      ...A.jobIdentifier && {
        jobIdentifier: j.SENSITIVE_STRING
      }
    }), "StopEvaluationJobRequestFilterSensitiveLog"),
    e70 = u((A) => ({
      ...A,
      ...A.inputModalities && {
        inputModalities: j.SENSITIVE_STRING
      },
      ...A.outputModalities && {
        outputModalities: j.SENSITIVE_STRING
      },
      ...A.inputAction && {
        inputAction: j.SENSITIVE_STRING
      },
      ...A.outputAction && {
        outputAction: j.SENSITIVE_STRING
      }
    }), "GuardrailContentFilterConfigFilterSensitiveLog"),
    Ef1 = u((A) => ({
      ...A,
      ...A.filtersConfig && {
        filtersConfig: A.filtersConfig.map((B) => e70(B))
      }
    }), "GuardrailContentPolicyConfigFilterSensitiveLog"),
    AI0 = u((A) => ({
      ...A,
      ...A.action && {
        action: j.SENSITIVE_STRING
      }
    }), "GuardrailContextualGroundingFilterConfigFilterSensitiveLog"),
    Uf1 = u((A) => ({
      ...A,
      ...A.filtersConfig && {
        filtersConfig: A.filtersConfig.map((B) => AI0(B))
      }
    }), "GuardrailContextualGroundingPolicyConfigFilterSensitiveLog"),
    BI0 = u((A) => ({
      ...A,
      ...A.name && {
        name: j.SENSITIVE_STRING
      },
      ...A.definition && {
        definition: j.SENSITIVE_STRING
      },
      ...A.examples && {
        examples: j.SENSITIVE_STRING
      },
      ...A.inputAction && {
        inputAction: j.SENSITIVE_STRING
      },
      ...A.outputAction && {
        outputAction: j.SENSITIVE_STRING
      }
    }), "GuardrailTopicConfigFilterSensitiveLog"),
    Nf1 = u((A) => ({
      ...A,
      ...A.topicsConfig && {
        topicsConfig: A.topicsConfig.map((B) => BI0(B))
      }
    }), "GuardrailTopicPolicyConfigFilterSensitiveLog"),
    QI0 = u((A) => ({
      ...A,
      ...A.inputAction && {
        inputAction: j.SENSITIVE_STRING
      },
      ...A.outputAction && {
        outputAction: j.SENSITIVE_STRING
      }
    }), "GuardrailManagedWordsConfigFilterSensitiveLog"),
    II0 = u((A) => ({
      ...A,
      ...A.inputAction && {
        inputAction: j.SENSITIVE_STRING
      },
      ...A.outputAction && {
        outputAction: j.SENSITIVE_STRING
      }
    }), "GuardrailWordConfigFilterSensitiveLog"),
    $f1 = u((A) => ({
      ...A,
      ...A.wordsConfig && {
        wordsConfig: A.wordsConfig.map((B) => II0(B))
      },
      ...A.managedWordListsConfig && {
        managedWordListsConfig: A.managedWordListsConfig.map((B) => QI0(B))
      }
    }), "GuardrailWordPolicyConfigFilterSensitiveLog"),
    GI0 = u((A) => ({
      ...A,
      ...A.name && {
        name: j.SENSITIVE_STRING
      },
      ...A.description && {
        description: j.SENSITIVE_STRING
      },
      ...A.topicPolicyConfig && {
        topicPolicyConfig: Nf1(A.topicPolicyConfig)
      },
      ...A.contentPolicyConfig && {
        contentPolicyConfig: Ef1(A.contentPolicyConfig)
      },
      ...A.wordPolicyConfig && {
        wordPolicyConfig: $f1(A.wordPolicyConfig)
      },
      ...A.contextualGroundingPolicyConfig && {
        contextualGroundingPolicyConfig: Uf1(A.contextualGroundingPolicyConfig)
      },
      ...A.blockedInputMessaging && {
        blockedInputMessaging: j.SENSITIVE_STRING
      },
      ...A.blockedOutputsMessaging && {
        blockedOutputsMessaging: j.SENSITIVE_STRING
      }
    }), "CreateGuardrailRequestFilterSensitiveLog"),
    ZI0 = u((A) => ({
      ...A,
      ...A.description && {
        description: j.SENSITIVE_STRING
      }
    }), "CreateGuardrailVersionRequestFilterSensitiveLog"),
    DI0 = u((A) => ({
      ...A,
      ...A.inputModalities && {
        inputModalities: j.SENSITIVE_STRING
      },
      ...A.outputModalities && {
        outputModalities: j.SENSITIVE_STRING
      },
      ...A.inputAction && {
        inputAction: j.SENSITIVE_STRING
      },
      ...A.outputAction && {
        outputAction: j.SENSITIVE_STRING
      }
    }), "GuardrailContentFilterFilterSensitiveLog"),
    YI0 = u((A) => ({
      ...A,
      ...A.filters && {
        filters: A.filters.map((B) => DI0(B))
      }
    }), "GuardrailContentPolicyFilterSensitiveLog"),
    WI0 = u((A) => ({
      ...A,
      ...A.action && {
        action: j.SENSITIVE_STRING
      }
    }), "GuardrailContextualGroundingFilterFilterSensitiveLog"),
    JI0 = u((A) => ({
      ...A,
      ...A.filters && {
        filters: A.filters.map((B) => WI0(B))
      }
    }), "GuardrailContextualGroundingPolicyFilterSensitiveLog"),
    FI0 = u((A) => ({
      ...A,
      ...A.name && {
        name: j.SENSITIVE_STRING
      },
      ...A.definition && {
        definition: j.SENSITIVE_STRING
      },
      ...A.examples && {
        examples: j.SENSITIVE_STRING
      },
      ...A.inputAction && {
        inputAction: j.SENSITIVE_STRING
      },
      ...A.outputAction && {
        outputAction: j.SENSITIVE_STRING
      }
    }), "GuardrailTopicFilterSensitiveLog"),
    XI0 = u((A) => ({
      ...A,
      ...A.topics && {
        topics: A.topics.map((B) => FI0(B))
      }
    }), "GuardrailTopicPolicyFilterSensitiveLog"),
    VI0 = u((A) => ({
      ...A,
      ...A.inputAction && {
        inputAction: j.SENSITIVE_STRING
      },
      ...A.outputAction && {
        outputAction: j.SENSITIVE_STRING
      }
    }), "GuardrailManagedWordsFilterSensitiveLog"),
    CI0 = u((A) => ({
      ...A,
      ...A.inputAction && {
        inputAction: j.SENSITIVE_STRING
      },
      ...A.outputAction && {
        outputAction: j.SENSITIVE_STRING
      }
    }), "GuardrailWordFilterSensitiveLog"),
    KI0 = u((A) => ({
      ...A,
      ...A.words && {
        words: A.words.map((B) => CI0(B))
      },
      ...A.managedWordLists && {
        managedWordLists: A.managedWordLists.map((B) => VI0(B))
      }
    }), "GuardrailWordPolicyFilterSensitiveLog"),
    HI0 = u((A) => ({
      ...A,
      ...A.name && {
        name: j.SENSITIVE_STRING
      },
      ...A.description && {
        description: j.SENSITIVE_STRING
      },
      ...A.topicPolicy && {
        topicPolicy: XI0(A.topicPolicy)
      },
      ...A.contentPolicy && {
        contentPolicy: YI0(A.contentPolicy)
      },
      ...A.wordPolicy && {
        wordPolicy: KI0(A.wordPolicy)
      },
      ...A.contextualGroundingPolicy && {
        contextualGroundingPolicy: JI0(A.contextualGroundingPolicy)
      },
      ...A.statusReasons && {
        statusReasons: j.SENSITIVE_STRING
      },
      ...A.failureRecommendations && {
        failureRecommendations: j.SENSITIVE_STRING
      },
      ...A.blockedInputMessaging && {
        blockedInputMessaging: j.SENSITIVE_STRING
      },
      ...A.blockedOutputsMessaging && {
        blockedOutputsMessaging: j.SENSITIVE_STRING
      }
    }), "GetGuardrailResponseFilterSensitiveLog"),
    zI0 = u((A) => ({
      ...A,
      ...A.name && {
        name: j.SENSITIVE_STRING
      },
      ...A.description && {
        description: j.SENSITIVE_STRING
      }
    }), "GuardrailSummaryFilterSensitiveLog"),
    wI0 = u((A) => ({
      ...A,
      ...A.guardrails && {
        guardrails: A.guardrails.map((B) => zI0(B))
      }
    }), "ListGuardrailsResponseFilterSensitiveLog"),
    EI0 = u((A) => ({
      ...A,
      ...A.name && {
        name: j.SENSITIVE_STRING
      },
      ...A.description && {
        description: j.SENSITIVE_STRING
      },
      ...A.topicPolicyConfig && {
        topicPolicyConfig: Nf1(A.topicPolicyConfig)
      },
      ...A.contentPolicyConfig && {
        contentPolicyConfig: Ef1(A.contentPolicyConfig)
      },
      ...A.wordPolicyConfig && {
        wordPolicyConfig: $f1(A.wordPolicyConfig)
      },
      ...A.contextualGroundingPolicyConfig && {
        contextualGroundingPolicyConfig: Uf1(A.contextualGroundingPolicyConfig)
      },
      ...A.blockedInputMessaging && {
        blockedInputMessaging: j.SENSITIVE_STRING
      },
      ...A.blockedOutputsMessaging && {
        blockedOutputsMessaging: j.SENSITIVE_STRING
      }
    }), "UpdateGuardrailRequestFilterSensitiveLog"),
    UI0 = u((A) => ({
      ...A,
      ...A.description && {
        description: j.SENSITIVE_STRING
      },
      ...A.modelSource && {
        modelSource: A.modelSource
      }
    }), "CreateInferenceProfileRequestFilterSensitiveLog"),
    NI0 = u((A) => ({
      ...A,
      ...A.description && {
        description: j.SENSITIVE_STRING
      }
    }), "GetInferenceProfileResponseFilterSensitiveLog"),
    $I0 = u((A) => ({
      ...A,
      ...A.description && {
        description: j.SENSITIVE_STRING
      }
    }), "InferenceProfileSummaryFilterSensitiveLog"),
    qI0 = u((A) => ({
      ...A,
      ...A.inferenceProfileSummaries && {
        inferenceProfileSummaries: A.inferenceProfileSummaries.map((B) => $I0(B))
      }
    }), "ListInferenceProfilesResponseFilterSensitiveLog"),
    MI0 = u((A) => ({
      ...A,
      ...A.message && {
        message: j.SENSITIVE_STRING
      },
      ...A.inputDataConfig && {
        inputDataConfig: A.inputDataConfig
      },
      ...A.outputDataConfig && {
        outputDataConfig: A.outputDataConfig
      }
    }), "GetModelInvocationJobResponseFilterSensitiveLog"),
    LI0 = u((A) => ({
      ...A,
      ...A.message && {
        message: j.SENSITIVE_STRING
      },
      ...A.inputDataConfig && {
        inputDataConfig: A.inputDataConfig
      },
      ...A.outputDataConfig && {
        outputDataConfig: A.outputDataConfig
      }
    }), "ModelInvocationJobSummaryFilterSensitiveLog"),
    RI0 = u((A) => ({
      ...A,
      ...A.invocationJobSummaries && {
        invocationJobSummaries: A.invocationJobSummaries.map((B) => LI0(B))
      }
    }), "ListModelInvocationJobsResponseFilterSensitiveLog"),
    Cf1 = u((A) => ({
      ...A,
      ...A.equals && {
        equals: j.SENSITIVE_STRING
      },
      ...A.notEquals && {
        notEquals: j.SENSITIVE_STRING
      }
    }), "RequestMetadataBaseFiltersFilterSensitiveLog"),
    OI0 = u((A) => {
      if (A.equals !== void 0) return {
        equals: j.SENSITIVE_STRING
      };
      if (A.notEquals !== void 0) return {
        notEquals: j.SENSITIVE_STRING
      };
      if (A.andAll !== void 0) return {
        andAll: A.andAll.map((B) => Cf1(B))
      };
      if (A.orAll !== void 0) return {
        orAll: A.orAll.map((B) => Cf1(B))
      };
      if (A.$unknown !== void 0) return {
        [A.$unknown[0]]: "UNKNOWN"
      }
    }, "RequestMetadataFiltersFilterSensitiveLog"),
    TI0 = u((A) => ({
      ...A,
      ...A.invocationLogSource && {
        invocationLogSource: A.invocationLogSource
      },
      ...A.requestMetadataFilters && {
        requestMetadataFilters: OI0(A.requestMetadataFilters)
      }
    }), "InvocationLogsConfigFilterSensitiveLog"),
    KG1 = u((A) => ({
      ...A,
      ...A.invocationLogsConfig && {
        invocationLogsConfig: TI0(A.invocationLogsConfig)
      }
    }), "TrainingDataConfigFilterSensitiveLog"),
    PI0 = u((A) => ({
      ...A,
      ...A.trainingDataConfig && {
        trainingDataConfig: KG1(A.trainingDataConfig)
      },
      ...A.customizationConfig && {
        customizationConfig: A.customizationConfig
      }
    }), "GetCustomModelResponseFilterSensitiveLog"),
    SI0 = u((A) => ({
      ...A,
      ...A.description && {
        description: j.SENSITIVE_STRING
      }
    }), "CreatePromptRouterRequestFilterSensitiveLog"),
    _I0 = u((A) => ({
      ...A,
      ...A.description && {
        description: j.SENSITIVE_STRING
      }
    }), "GetPromptRouterResponseFilterSensitiveLog"),
    jI0 = u((A) => ({
      ...A,
      ...A.description && {
        description: j.SENSITIVE_STRING
      }
    }), "PromptRouterSummaryFilterSensitiveLog"),
    yI0 = u((A) => ({
      ...A,
      ...A.promptRouterSummaries && {
        promptRouterSummaries: A.promptRouterSummaries.map((B) => jI0(B))
      }
    }), "ListPromptRoutersResponseFilterSensitiveLog"),
    kI0 = u((A) => ({
      ...A,
      ...A.trainingDataConfig && {
        trainingDataConfig: KG1(A.trainingDataConfig)
      },
      ...A.customizationConfig && {
        customizationConfig: A.customizationConfig
      }
    }), "CreateModelCustomizationJobRequestFilterSensitiveLog"),
    xI0 = u((A) => ({
      ...A,
      ...A.trainingDataConfig && {
        trainingDataConfig: KG1(A.trainingDataConfig)
      },
      ...A.customizationConfig && {
        customizationConfig: A.customizationConfig
      }
    }), "GetModelCustomizationJobResponseFilterSensitiveLog"),
    b_4 = u((A) => {
      if (A.equals !== void 0) return {
        equals: A.equals
      };
      if (A.notEquals !== void 0) return {
        notEquals: A.notEquals
      };
      if (A.greaterThan !== void 0) return {
        greaterThan: A.greaterThan
      };
      if (A.greaterThanOrEquals !== void 0) return {
        greaterThanOrEquals: A.greaterThanOrEquals
      };
      if (A.lessThan !== void 0) return {
        lessThan: A.lessThan
      };
      if (A.lessThanOrEquals !== void 0) return {
        lessThanOrEquals: A.lessThanOrEquals
      };
      if (A.in !== void 0) return {
        in: A.in
      };
      if (A.notIn !== void 0) return {
        notIn: A.notIn
      };
      if (A.startsWith !== void 0) return {
        startsWith: A.startsWith
      };
      if (A.listContains !== void 0) return {
        listContains: A.listContains
      };
      if (A.stringContains !== void 0) return {
        stringContains: A.stringContains
      };
      if (A.andAll !== void 0) return {
        andAll: j.SENSITIVE_STRING
      };
      if (A.orAll !== void 0) return {
        orAll: j.SENSITIVE_STRING
      };
      if (A.$unknown !== void 0) return {
        [A.$unknown[0]]: "UNKNOWN"
      }
    }, "RetrievalFilterFilterSensitiveLog"),
    fI0 = u((A) => ({
      ...A,
      ...A.filter && {
        filter: j.SENSITIVE_STRING
      }
    }), "KnowledgeBaseVectorSearchConfigurationFilterSensitiveLog"),
    qf1 = u((A) => ({
      ...A,
      ...A.vectorSearchConfiguration && {
        vectorSearchConfiguration: fI0(A.vectorSearchConfiguration)
      }
    }), "KnowledgeBaseRetrievalConfigurationFilterSensitiveLog"),
    vI0 = u((A) => ({
      ...A,
      ...A.retrievalConfiguration && {
        retrievalConfiguration: qf1(A.retrievalConfiguration)
      },
      ...A.generationConfiguration && {
        generationConfiguration: r70(A.generationConfiguration)
      }
    }), "KnowledgeBaseRetrieveAndGenerateConfigurationFilterSensitiveLog"),
    bI0 = u((A) => ({
      ...A,
      ...A.knowledgeBaseRetrievalConfiguration && {
        knowledgeBaseRetrievalConfiguration: qf1(A.knowledgeBaseRetrievalConfiguration)
      }
    }), "RetrieveConfigFilterSensitiveLog"),
    gI0 = u((A) => ({
      ...A,
      ...A.knowledgeBaseConfiguration && {
        knowledgeBaseConfiguration: vI0(A.knowledgeBaseConfiguration)
      },
      ...A.externalSourcesConfiguration && {
        externalSourcesConfiguration: s70(A.externalSourcesConfiguration)
      }
    }), "RetrieveAndGenerateConfigurationFilterSensitiveLog"),
    hI0 = u((A) => {
      if (A.retrieveConfig !== void 0) return {
        retrieveConfig: bI0(A.retrieveConfig)
      };
      if (A.retrieveAndGenerateConfig !== void 0) return {
        retrieveAndGenerateConfig: gI0(A.retrieveAndGenerateConfig)
      };
      if (A.$unknown !== void 0) return {
        [A.$unknown[0]]: "UNKNOWN"
      }
    }, "KnowledgeBaseConfigFilterSensitiveLog"),
    mI0 = u((A) => {
      if (A.knowledgeBaseConfig !== void 0) return {
        knowledgeBaseConfig: hI0(A.knowledgeBaseConfig)
      };
      if (A.precomputedRagSourceConfig !== void 0) return {
        precomputedRagSourceConfig: A.precomputedRagSourceConfig
      };
      if (A.$unknown !== void 0) return {
        [A.$unknown[0]]: "UNKNOWN"
      }
    }, "RAGConfigFilterSensitiveLog"),
    Mf1 = u((A) => {
      if (A.models !== void 0) return {
        models: A.models.map((B) => l70(B))
      };
      if (A.ragConfigs !== void 0) return {
        ragConfigs: A.ragConfigs.map((B) => mI0(B))
      };
      if (A.$unknown !== void 0) return {
        [A.$unknown[0]]: "UNKNOWN"
      }
    }, "EvaluationInferenceConfigFilterSensitiveLog"),
    dI0 = u((A) => ({
      ...A,
      ...A.jobDescription && {
        jobDescription: j.SENSITIVE_STRING
      },
      ...A.evaluationConfig && {
        evaluationConfig: zf1(A.evaluationConfig)
      },
      ...A.inferenceConfig && {
        inferenceConfig: Mf1(A.inferenceConfig)
      }
    }), "CreateEvaluationJobRequestFilterSensitiveLog"),
    uI0 = u((A) => ({
      ...A,
      ...A.jobDescription && {
        jobDescription: j.SENSITIVE_STRING
      },
      ...A.evaluationConfig && {
        evaluationConfig: zf1(A.evaluationConfig)
      },
      ...A.inferenceConfig && {
        inferenceConfig: Mf1(A.inferenceConfig)
      }
    }), "GetEvaluationJobResponseFilterSensitiveLog"),
    u2 = IB(),
    yC = A70(),
    g_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/evaluation-jobs/batch-delete");
      let G;
      return G = JSON.stringify(j.take(A, {
        jobIdentifiers: u((Z) => j._json(Z), "jobIdentifiers")
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_BatchDeleteEvaluationJobCommand"),
    h_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/evaluation-jobs");
      let G;
      return G = JSON.stringify(j.take(A, {
        applicationType: [],
        clientRequestToken: [!0, (Z) => Z ?? yC.v4()],
        customerEncryptionKeyId: [],
        evaluationConfig: u((Z) => Xk4(Z, B), "evaluationConfig"),
        inferenceConfig: u((Z) => Vk4(Z, B), "inferenceConfig"),
        jobDescription: [],
        jobName: [],
        jobTags: u((Z) => j._json(Z), "jobTags"),
        outputDataConfig: u((Z) => j._json(Z), "outputDataConfig"),
        roleArn: []
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_CreateEvaluationJobCommand"),
    m_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/guardrails");
      let G;
      return G = JSON.stringify(j.take(A, {
        blockedInputMessaging: [],
        blockedOutputsMessaging: [],
        clientRequestToken: [!0, (Z) => Z ?? yC.v4()],
        contentPolicyConfig: u((Z) => j._json(Z), "contentPolicyConfig"),
        contextualGroundingPolicyConfig: u((Z) => cI0(Z, B), "contextualGroundingPolicyConfig"),
        description: [],
        kmsKeyId: [],
        name: [],
        sensitiveInformationPolicyConfig: u((Z) => j._json(Z), "sensitiveInformationPolicyConfig"),
        tags: u((Z) => j._json(Z), "tags"),
        topicPolicyConfig: u((Z) => j._json(Z), "topicPolicyConfig"),
        wordPolicyConfig: u((Z) => j._json(Z), "wordPolicyConfig")
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_CreateGuardrailCommand"),
    d_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/guardrails/{guardrailIdentifier}"), Q.p("guardrailIdentifier", () => A.guardrailIdentifier, "{guardrailIdentifier}", !1);
      let G;
      return G = JSON.stringify(j.take(A, {
        clientRequestToken: [!0, (Z) => Z ?? yC.v4()],
        description: []
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_CreateGuardrailVersionCommand"),
    u_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/inference-profiles");
      let G;
      return G = JSON.stringify(j.take(A, {
        clientRequestToken: [!0, (Z) => Z ?? yC.v4()],
        description: [],
        inferenceProfileName: [],
        modelSource: u((Z) => j._json(Z), "modelSource"),
        tags: u((Z) => j._json(Z), "tags")
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_CreateInferenceProfileCommand"),
    p_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/marketplace-model/endpoints");
      let G;
      return G = JSON.stringify(j.take(A, {
        acceptEula: [],
        clientRequestToken: [!0, (Z) => Z ?? yC.v4()],
        endpointConfig: u((Z) => j._json(Z), "endpointConfig"),
        endpointName: [],
        modelSourceIdentifier: [],
        tags: u((Z) => j._json(Z), "tags")
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_CreateMarketplaceModelEndpointCommand"),
    c_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/model-copy-jobs");
      let G;
      return G = JSON.stringify(j.take(A, {
        clientRequestToken: [!0, (Z) => Z ?? yC.v4()],
        modelKmsKeyId: [],
        sourceModelArn: [],
        targetModelName: [],
        targetModelTags: u((Z) => j._json(Z), "targetModelTags")
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_CreateModelCopyJobCommand"),
    l_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/model-customization-jobs");
      let G;
      return G = JSON.stringify(j.take(A, {
        baseModelIdentifier: [],
        clientRequestToken: [!0, (Z) => Z ?? yC.v4()],
        customModelKmsKeyId: [],
        customModelName: [],
        customModelTags: u((Z) => j._json(Z), "customModelTags"),
        customizationConfig: u((Z) => j._json(Z), "customizationConfig"),
        customizationType: [],
        hyperParameters: u((Z) => j._json(Z), "hyperParameters"),
        jobName: [],
        jobTags: u((Z) => j._json(Z), "jobTags"),
        outputDataConfig: u((Z) => j._json(Z), "outputDataConfig"),
        roleArn: [],
        trainingDataConfig: u((Z) => j._json(Z), "trainingDataConfig"),
        validationDataConfig: u((Z) => j._json(Z), "validationDataConfig"),
        vpcConfig: u((Z) => j._json(Z), "vpcConfig")
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_CreateModelCustomizationJobCommand"),
    i_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/model-import-jobs");
      let G;
      return G = JSON.stringify(j.take(A, {
        clientRequestToken: [],
        importedModelKmsKeyId: [],
        importedModelName: [],
        importedModelTags: u((Z) => j._json(Z), "importedModelTags"),
        jobName: [],
        jobTags: u((Z) => j._json(Z), "jobTags"),
        modelDataSource: u((Z) => j._json(Z), "modelDataSource"),
        roleArn: [],
        vpcConfig: u((Z) => j._json(Z), "vpcConfig")
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_CreateModelImportJobCommand"),
    n_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/model-invocation-job");
      let G;
      return G = JSON.stringify(j.take(A, {
        clientRequestToken: [!0, (Z) => Z ?? yC.v4()],
        inputDataConfig: u((Z) => j._json(Z), "inputDataConfig"),
        jobName: [],
        modelId: [],
        outputDataConfig: u((Z) => j._json(Z), "outputDataConfig"),
        roleArn: [],
        tags: u((Z) => j._json(Z), "tags"),
        timeoutDurationInHours: [],
        vpcConfig: u((Z) => j._json(Z), "vpcConfig")
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_CreateModelInvocationJobCommand"),
    a_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/prompt-routers");
      let G;
      return G = JSON.stringify(j.take(A, {
        clientRequestToken: [!0, (Z) => Z ?? yC.v4()],
        description: [],
        fallbackModel: u((Z) => j._json(Z), "fallbackModel"),
        models: u((Z) => j._json(Z), "models"),
        promptRouterName: [],
        routingCriteria: u((Z) => jk4(Z, B), "routingCriteria"),
        tags: u((Z) => j._json(Z), "tags")
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_CreatePromptRouterCommand"),
    s_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/provisioned-model-throughput");
      let G;
      return G = JSON.stringify(j.take(A, {
        clientRequestToken: [!0, (Z) => Z ?? yC.v4()],
        commitmentDuration: [],
        modelId: [],
        modelUnits: [],
        provisionedModelName: [],
        tags: u((Z) => j._json(Z), "tags")
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_CreateProvisionedModelThroughputCommand"),
    r_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/custom-models/{modelIdentifier}"), Q.p("modelIdentifier", () => A.modelIdentifier, "{modelIdentifier}", !1);
      let G;
      return Q.m("DELETE").h(I).b(G), Q.build()
    }, "se_DeleteCustomModelCommand"),
    o_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/guardrails/{guardrailIdentifier}"), Q.p("guardrailIdentifier", () => A.guardrailIdentifier, "{guardrailIdentifier}", !1);
      let G = j.map({
          [VG1]: [, A[VG1]]
        }),
        Z;
      return Q.m("DELETE").h(I).q(G).b(Z), Q.build()
    }, "se_DeleteGuardrailCommand"),
    t_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/imported-models/{modelIdentifier}"), Q.p("modelIdentifier", () => A.modelIdentifier, "{modelIdentifier}", !1);
      let G;
      return Q.m("DELETE").h(I).b(G), Q.build()
    }, "se_DeleteImportedModelCommand"),
    e_4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/inference-profiles/{inferenceProfileIdentifier}"), Q.p("inferenceProfileIdentifier", () => A.inferenceProfileIdentifier, "{inferenceProfileIdentifier}", !1);
      let G;
      return Q.m("DELETE").h(I).b(G), Q.build()
    }, "se_DeleteInferenceProfileCommand"),
    Aj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/marketplace-model/endpoints/{endpointArn}"), Q.p("endpointArn", () => A.endpointArn, "{endpointArn}", !1);
      let G;
      return Q.m("DELETE").h(I).b(G), Q.build()
    }, "se_DeleteMarketplaceModelEndpointCommand"),
    Bj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/logging/modelinvocations");
      let G;
      return Q.m("DELETE").h(I).b(G), Q.build()
    }, "se_DeleteModelInvocationLoggingConfigurationCommand"),
    Qj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/prompt-routers/{promptRouterArn}"), Q.p("promptRouterArn", () => A.promptRouterArn, "{promptRouterArn}", !1);
      let G;
      return Q.m("DELETE").h(I).b(G), Q.build()
    }, "se_DeletePromptRouterCommand"),
    Ij4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/provisioned-model-throughput/{provisionedModelId}"), Q.p("provisionedModelId", () => A.provisionedModelId, "{provisionedModelId}", !1);
      let G;
      return Q.m("DELETE").h(I).b(G), Q.build()
    }, "se_DeleteProvisionedModelThroughputCommand"),
    Gj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/marketplace-model/endpoints/{endpointArn}/registration"), Q.p("endpointArn", () => A.endpointArn, "{endpointArn}", !1);
      let G;
      return Q.m("DELETE").h(I).b(G), Q.build()
    }, "se_DeregisterMarketplaceModelEndpointCommand"),
    Zj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/custom-models/{modelIdentifier}"), Q.p("modelIdentifier", () => A.modelIdentifier, "{modelIdentifier}", !1);
      let G;
      return Q.m("GET").h(I).b(G), Q.build()
    }, "se_GetCustomModelCommand"),
    Dj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/evaluation-jobs/{jobIdentifier}"), Q.p("jobIdentifier", () => A.jobIdentifier, "{jobIdentifier}", !1);
      let G;
      return Q.m("GET").h(I).b(G), Q.build()
    }, "se_GetEvaluationJobCommand"),
    Yj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/foundation-models/{modelIdentifier}"), Q.p("modelIdentifier", () => A.modelIdentifier, "{modelIdentifier}", !1);
      let G;
      return Q.m("GET").h(I).b(G), Q.build()
    }, "se_GetFoundationModelCommand"),
    Wj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/guardrails/{guardrailIdentifier}"), Q.p("guardrailIdentifier", () => A.guardrailIdentifier, "{guardrailIdentifier}", !1);
      let G = j.map({
          [VG1]: [, A[VG1]]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_GetGuardrailCommand"),
    Jj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/imported-models/{modelIdentifier}"), Q.p("modelIdentifier", () => A.modelIdentifier, "{modelIdentifier}", !1);
      let G;
      return Q.m("GET").h(I).b(G), Q.build()
    }, "se_GetImportedModelCommand"),
    Fj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/inference-profiles/{inferenceProfileIdentifier}"), Q.p("inferenceProfileIdentifier", () => A.inferenceProfileIdentifier, "{inferenceProfileIdentifier}", !1);
      let G;
      return Q.m("GET").h(I).b(G), Q.build()
    }, "se_GetInferenceProfileCommand"),
    Xj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/marketplace-model/endpoints/{endpointArn}"), Q.p("endpointArn", () => A.endpointArn, "{endpointArn}", !1);
      let G;
      return Q.m("GET").h(I).b(G), Q.build()
    }, "se_GetMarketplaceModelEndpointCommand"),
    Vj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/model-copy-jobs/{jobArn}"), Q.p("jobArn", () => A.jobArn, "{jobArn}", !1);
      let G;
      return Q.m("GET").h(I).b(G), Q.build()
    }, "se_GetModelCopyJobCommand"),
    Cj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/model-customization-jobs/{jobIdentifier}"), Q.p("jobIdentifier", () => A.jobIdentifier, "{jobIdentifier}", !1);
      let G;
      return Q.m("GET").h(I).b(G), Q.build()
    }, "se_GetModelCustomizationJobCommand"),
    Kj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/model-import-jobs/{jobIdentifier}"), Q.p("jobIdentifier", () => A.jobIdentifier, "{jobIdentifier}", !1);
      let G;
      return Q.m("GET").h(I).b(G), Q.build()
    }, "se_GetModelImportJobCommand"),
    Hj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/model-invocation-job/{jobIdentifier}"), Q.p("jobIdentifier", () => A.jobIdentifier, "{jobIdentifier}", !1);
      let G;
      return Q.m("GET").h(I).b(G), Q.build()
    }, "se_GetModelInvocationJobCommand"),
    zj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/logging/modelinvocations");
      let G;
      return Q.m("GET").h(I).b(G), Q.build()
    }, "se_GetModelInvocationLoggingConfigurationCommand"),
    wj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/prompt-routers/{promptRouterArn}"), Q.p("promptRouterArn", () => A.promptRouterArn, "{promptRouterArn}", !1);
      let G;
      return Q.m("GET").h(I).b(G), Q.build()
    }, "se_GetPromptRouterCommand"),
    Ej4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/provisioned-model-throughput/{provisionedModelId}"), Q.p("provisionedModelId", () => A.provisionedModelId, "{provisionedModelId}", !1);
      let G;
      return Q.m("GET").h(I).b(G), Q.build()
    }, "se_GetProvisionedModelThroughputCommand"),
    Uj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/custom-models");
      let G = j.map({
          [bY]: [() => A.creationTimeBefore !== void 0, () => j.serializeDateTime(A[bY]).toString()],
          [vY]: [() => A.creationTimeAfter !== void 0, () => j.serializeDateTime(A[vY]).toString()],
          [gY]: [, A[gY]],
          [V70]: [, A[V70]],
          [H70]: [, A[H70]],
          [tB]: [() => A.maxResults !== void 0, () => A[tB].toString()],
          [eB]: [, A[eB]],
          [RZ]: [, A[RZ]],
          [OZ]: [, A[OZ]],
          [w70]: [() => A.isOwned !== void 0, () => A[w70].toString()]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListCustomModelsCommand"),
    Nj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/evaluation-jobs");
      let G = j.map({
          [vY]: [() => A.creationTimeAfter !== void 0, () => j.serializeDateTime(A[vY]).toString()],
          [bY]: [() => A.creationTimeBefore !== void 0, () => j.serializeDateTime(A[bY]).toString()],
          [HX]: [, A[HX]],
          [J70]: [, A[J70]],
          [gY]: [, A[gY]],
          [tB]: [() => A.maxResults !== void 0, () => A[tB].toString()],
          [eB]: [, A[eB]],
          [RZ]: [, A[RZ]],
          [OZ]: [, A[OZ]]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListEvaluationJobsCommand"),
    $j4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/foundation-models");
      let G = j.map({
          [K70]: [, A[K70]],
          [F70]: [, A[F70]],
          [C70]: [, A[C70]],
          [X70]: [, A[X70]]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListFoundationModelsCommand"),
    qj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/guardrails");
      let G = j.map({
          [z70]: [, A[z70]],
          [tB]: [() => A.maxResults !== void 0, () => A[tB].toString()],
          [eB]: [, A[eB]]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListGuardrailsCommand"),
    Mj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/imported-models");
      let G = j.map({
          [bY]: [() => A.creationTimeBefore !== void 0, () => j.serializeDateTime(A[bY]).toString()],
          [vY]: [() => A.creationTimeAfter !== void 0, () => j.serializeDateTime(A[vY]).toString()],
          [gY]: [, A[gY]],
          [tB]: [() => A.maxResults !== void 0, () => A[tB].toString()],
          [eB]: [, A[eB]],
          [RZ]: [, A[RZ]],
          [OZ]: [, A[OZ]]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListImportedModelsCommand"),
    Lj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/inference-profiles");
      let G = j.map({
          [tB]: [() => A.maxResults !== void 0, () => A[tB].toString()],
          [eB]: [, A[eB]],
          [Kf1]: [, A[vx4]]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListInferenceProfilesCommand"),
    Rj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/marketplace-model/endpoints");
      let G = j.map({
          [tB]: [() => A.maxResults !== void 0, () => A[tB].toString()],
          [eB]: [, A[eB]],
          [xx4]: [, A[kx4]]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListMarketplaceModelEndpointsCommand"),
    Oj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/model-copy-jobs");
      let G = j.map({
          [vY]: [() => A.creationTimeAfter !== void 0, () => j.serializeDateTime(A[vY]).toString()],
          [bY]: [() => A.creationTimeBefore !== void 0, () => j.serializeDateTime(A[bY]).toString()],
          [HX]: [, A[HX]],
          [U70]: [, A[U70]],
          [N70]: [, A[N70]],
          [fx4]: [, A[bx4]],
          [tB]: [() => A.maxResults !== void 0, () => A[tB].toString()],
          [eB]: [, A[eB]],
          [RZ]: [, A[RZ]],
          [OZ]: [, A[OZ]]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListModelCopyJobsCommand"),
    Tj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/model-customization-jobs");
      let G = j.map({
          [vY]: [() => A.creationTimeAfter !== void 0, () => j.serializeDateTime(A[vY]).toString()],
          [bY]: [() => A.creationTimeBefore !== void 0, () => j.serializeDateTime(A[bY]).toString()],
          [HX]: [, A[HX]],
          [gY]: [, A[gY]],
          [tB]: [() => A.maxResults !== void 0, () => A[tB].toString()],
          [eB]: [, A[eB]],
          [RZ]: [, A[RZ]],
          [OZ]: [, A[OZ]]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListModelCustomizationJobsCommand"),
    Pj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/model-import-jobs");
      let G = j.map({
          [vY]: [() => A.creationTimeAfter !== void 0, () => j.serializeDateTime(A[vY]).toString()],
          [bY]: [() => A.creationTimeBefore !== void 0, () => j.serializeDateTime(A[bY]).toString()],
          [HX]: [, A[HX]],
          [gY]: [, A[gY]],
          [tB]: [() => A.maxResults !== void 0, () => A[tB].toString()],
          [eB]: [, A[eB]],
          [RZ]: [, A[RZ]],
          [OZ]: [, A[OZ]]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListModelImportJobsCommand"),
    Sj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/model-invocation-jobs");
      let G = j.map({
          [$70]: [() => A.submitTimeAfter !== void 0, () => j.serializeDateTime(A[$70]).toString()],
          [q70]: [() => A.submitTimeBefore !== void 0, () => j.serializeDateTime(A[q70]).toString()],
          [HX]: [, A[HX]],
          [gY]: [, A[gY]],
          [tB]: [() => A.maxResults !== void 0, () => A[tB].toString()],
          [eB]: [, A[eB]],
          [RZ]: [, A[RZ]],
          [OZ]: [, A[OZ]]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListModelInvocationJobsCommand"),
    _j4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/prompt-routers");
      let G = j.map({
          [tB]: [() => A.maxResults !== void 0, () => A[tB].toString()],
          [eB]: [, A[eB]],
          [Kf1]: [, A[Kf1]]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListPromptRoutersCommand"),
    jj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/provisioned-model-throughputs");
      let G = j.map({
          [vY]: [() => A.creationTimeAfter !== void 0, () => j.serializeDateTime(A[vY]).toString()],
          [bY]: [() => A.creationTimeBefore !== void 0, () => j.serializeDateTime(A[bY]).toString()],
          [HX]: [, A[HX]],
          [E70]: [, A[E70]],
          [gY]: [, A[gY]],
          [tB]: [() => A.maxResults !== void 0, () => A[tB].toString()],
          [eB]: [, A[eB]],
          [RZ]: [, A[RZ]],
          [OZ]: [, A[OZ]]
        }),
        Z;
      return Q.m("GET").h(I).q(G).b(Z), Q.build()
    }, "se_ListProvisionedModelThroughputsCommand"),
    yj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/listTagsForResource");
      let G;
      return G = JSON.stringify(j.take(A, {
        resourceARN: []
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_ListTagsForResourceCommand"),
    kj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/logging/modelinvocations");
      let G;
      return G = JSON.stringify(j.take(A, {
        loggingConfig: u((Z) => j._json(Z), "loggingConfig")
      })), Q.m("PUT").h(I).b(G), Q.build()
    }, "se_PutModelInvocationLoggingConfigurationCommand"),
    xj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/marketplace-model/endpoints/{endpointIdentifier}/registration"), Q.p("endpointIdentifier", () => A.endpointIdentifier, "{endpointIdentifier}", !1);
      let G;
      return G = JSON.stringify(j.take(A, {
        modelSourceIdentifier: []
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_RegisterMarketplaceModelEndpointCommand"),
    fj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/evaluation-job/{jobIdentifier}/stop"), Q.p("jobIdentifier", () => A.jobIdentifier, "{jobIdentifier}", !1);
      let G;
      return Q.m("POST").h(I).b(G), Q.build()
    }, "se_StopEvaluationJobCommand"),
    vj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/model-customization-jobs/{jobIdentifier}/stop"), Q.p("jobIdentifier", () => A.jobIdentifier, "{jobIdentifier}", !1);
      let G;
      return Q.m("POST").h(I).b(G), Q.build()
    }, "se_StopModelCustomizationJobCommand"),
    bj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {};
      Q.bp("/model-invocation-job/{jobIdentifier}/stop"), Q.p("jobIdentifier", () => A.jobIdentifier, "{jobIdentifier}", !1);
      let G;
      return Q.m("POST").h(I).b(G), Q.build()
    }, "se_StopModelInvocationJobCommand"),
    gj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/tagResource");
      let G;
      return G = JSON.stringify(j.take(A, {
        resourceARN: [],
        tags: u((Z) => j._json(Z), "tags")
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_TagResourceCommand"),
    hj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/untagResource");
      let G;
      return G = JSON.stringify(j.take(A, {
        resourceARN: [],
        tagKeys: u((Z) => j._json(Z), "tagKeys")
      })), Q.m("POST").h(I).b(G), Q.build()
    }, "se_UntagResourceCommand"),
    mj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/guardrails/{guardrailIdentifier}"), Q.p("guardrailIdentifier", () => A.guardrailIdentifier, "{guardrailIdentifier}", !1);
      let G;
      return G = JSON.stringify(j.take(A, {
        blockedInputMessaging: [],
        blockedOutputsMessaging: [],
        contentPolicyConfig: u((Z) => j._json(Z), "contentPolicyConfig"),
        contextualGroundingPolicyConfig: u((Z) => cI0(Z, B), "contextualGroundingPolicyConfig"),
        description: [],
        kmsKeyId: [],
        name: [],
        sensitiveInformationPolicyConfig: u((Z) => j._json(Z), "sensitiveInformationPolicyConfig"),
        topicPolicyConfig: u((Z) => j._json(Z), "topicPolicyConfig"),
        wordPolicyConfig: u((Z) => j._json(Z), "wordPolicyConfig")
      })), Q.m("PUT").h(I).b(G), Q.build()
    }, "se_UpdateGuardrailCommand"),
    dj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/marketplace-model/endpoints/{endpointArn}"), Q.p("endpointArn", () => A.endpointArn, "{endpointArn}", !1);
      let G;
      return G = JSON.stringify(j.take(A, {
        clientRequestToken: [!0, (Z) => Z ?? yC.v4()],
        endpointConfig: u((Z) => j._json(Z), "endpointConfig")
      })), Q.m("PATCH").h(I).b(G), Q.build()
    }, "se_UpdateMarketplaceModelEndpointCommand"),
    uj4 = u(async (A, B) => {
      let Q = C2.requestBuilder(A, B),
        I = {
          "content-type": "application/json"
        };
      Q.bp("/provisioned-model-throughput/{provisionedModelId}"), Q.p("provisionedModelId", () => A.provisionedModelId, "{provisionedModelId}", !1);
      let G;
      return G = JSON.stringify(j.take(A, {
        desiredModelId: [],
        desiredProvisionedModelName: []
      })), Q.m("PATCH").h(I).b(G), Q.build()
    }, "se_UpdateProvisionedModelThroughputCommand"),
    pj4 = u(async (A, B) => {
      if (A.statusCode !== 202 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          errors: j._json,
          evaluationJobs: j._json
        });
      return Object.assign(Q, G), Q
    }, "de_BatchDeleteEvaluationJobCommand"),
    cj4 = u(async (A, B) => {
      if (A.statusCode !== 202 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          jobArn: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_CreateEvaluationJobCommand"),
    lj4 = u(async (A, B) => {
      if (A.statusCode !== 202 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          createdAt: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "createdAt"),
          guardrailArn: j.expectString,
          guardrailId: j.expectString,
          version: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_CreateGuardrailCommand"),
    ij4 = u(async (A, B) => {
      if (A.statusCode !== 202 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          guardrailId: j.expectString,
          version: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_CreateGuardrailVersionCommand"),
    nj4 = u(async (A, B) => {
      if (A.statusCode !== 201 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          inferenceProfileArn: j.expectString,
          status: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_CreateInferenceProfileCommand"),
    aj4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          marketplaceModelEndpoint: u((Z) => HG1(Z, B), "marketplaceModelEndpoint")
        });
      return Object.assign(Q, G), Q
    }, "de_CreateMarketplaceModelEndpointCommand"),
    sj4 = u(async (A, B) => {
      if (A.statusCode !== 201 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          jobArn: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_CreateModelCopyJobCommand"),
    rj4 = u(async (A, B) => {
      if (A.statusCode !== 201 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          jobArn: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_CreateModelCustomizationJobCommand"),
    oj4 = u(async (A, B) => {
      if (A.statusCode !== 201 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          jobArn: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_CreateModelImportJobCommand"),
    tj4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          jobArn: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_CreateModelInvocationJobCommand"),
    ej4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          promptRouterArn: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_CreatePromptRouterCommand"),
    Ay4 = u(async (A, B) => {
      if (A.statusCode !== 201 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          provisionedModelArn: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_CreateProvisionedModelThroughputCommand"),
    By4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_DeleteCustomModelCommand"),
    Qy4 = u(async (A, B) => {
      if (A.statusCode !== 202 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_DeleteGuardrailCommand"),
    Iy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_DeleteImportedModelCommand"),
    Gy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_DeleteInferenceProfileCommand"),
    Zy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_DeleteMarketplaceModelEndpointCommand"),
    Dy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_DeleteModelInvocationLoggingConfigurationCommand"),
    Yy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_DeletePromptRouterCommand"),
    Wy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_DeleteProvisionedModelThroughputCommand"),
    Jy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_DeregisterMarketplaceModelEndpointCommand"),
    Fy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          baseModelArn: j.expectString,
          creationTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "creationTime"),
          customizationConfig: u((Z) => j._json(u2.awsExpectUnion(Z)), "customizationConfig"),
          customizationType: j.expectString,
          hyperParameters: j._json,
          jobArn: j.expectString,
          jobName: j.expectString,
          modelArn: j.expectString,
          modelKmsKeyArn: j.expectString,
          modelName: j.expectString,
          outputDataConfig: j._json,
          trainingDataConfig: j._json,
          trainingMetrics: u((Z) => eI0(Z, B), "trainingMetrics"),
          validationDataConfig: j._json,
          validationMetrics: u((Z) => AG0(Z, B), "validationMetrics")
        });
      return Object.assign(Q, G), Q
    }, "de_GetCustomModelCommand"),
    Xy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          applicationType: j.expectString,
          creationTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "creationTime"),
          customerEncryptionKeyId: j.expectString,
          evaluationConfig: u((Z) => uk4(u2.awsExpectUnion(Z), B), "evaluationConfig"),
          failureMessages: j._json,
          inferenceConfig: u((Z) => pk4(u2.awsExpectUnion(Z), B), "inferenceConfig"),
          jobArn: j.expectString,
          jobDescription: j.expectString,
          jobName: j.expectString,
          jobType: j.expectString,
          lastModifiedTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "lastModifiedTime"),
          outputDataConfig: j._json,
          roleArn: j.expectString,
          status: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_GetEvaluationJobCommand"),
    Vy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          modelDetails: j._json
        });
      return Object.assign(Q, G), Q
    }, "de_GetFoundationModelCommand"),
    Cy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          blockedInputMessaging: j.expectString,
          blockedOutputsMessaging: j.expectString,
          contentPolicy: j._json,
          contextualGroundingPolicy: u((Z) => Ax4(Z, B), "contextualGroundingPolicy"),
          createdAt: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "createdAt"),
          description: j.expectString,
          failureRecommendations: j._json,
          guardrailArn: j.expectString,
          guardrailId: j.expectString,
          kmsKeyArn: j.expectString,
          name: j.expectString,
          sensitiveInformationPolicy: j._json,
          status: j.expectString,
          statusReasons: j._json,
          topicPolicy: j._json,
          updatedAt: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "updatedAt"),
          version: j.expectString,
          wordPolicy: j._json
        });
      return Object.assign(Q, G), Q
    }, "de_GetGuardrailCommand"),
    Ky4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          creationTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "creationTime"),
          customModelUnits: j._json,
          instructSupported: j.expectBoolean,
          jobArn: j.expectString,
          jobName: j.expectString,
          modelArchitecture: j.expectString,
          modelArn: j.expectString,
          modelDataSource: u((Z) => j._json(u2.awsExpectUnion(Z)), "modelDataSource"),
          modelKmsKeyArn: j.expectString,
          modelName: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_GetImportedModelCommand"),
    Hy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          createdAt: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "createdAt"),
          description: j.expectString,
          inferenceProfileArn: j.expectString,
          inferenceProfileId: j.expectString,
          inferenceProfileName: j.expectString,
          models: j._json,
          status: j.expectString,
          type: j.expectString,
          updatedAt: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "updatedAt")
        });
      return Object.assign(Q, G), Q
    }, "de_GetInferenceProfileCommand"),
    zy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          marketplaceModelEndpoint: u((Z) => HG1(Z, B), "marketplaceModelEndpoint")
        });
      return Object.assign(Q, G), Q
    }, "de_GetMarketplaceModelEndpointCommand"),
    wy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          creationTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "creationTime"),
          failureMessage: j.expectString,
          jobArn: j.expectString,
          sourceAccountId: j.expectString,
          sourceModelArn: j.expectString,
          sourceModelName: j.expectString,
          status: j.expectString,
          targetModelArn: j.expectString,
          targetModelKmsKeyArn: j.expectString,
          targetModelName: j.expectString,
          targetModelTags: j._json
        });
      return Object.assign(Q, G), Q
    }, "de_GetModelCopyJobCommand"),
    Ey4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          baseModelArn: j.expectString,
          clientRequestToken: j.expectString,
          creationTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "creationTime"),
          customizationConfig: u((Z) => j._json(u2.awsExpectUnion(Z)), "customizationConfig"),
          customizationType: j.expectString,
          endTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "endTime"),
          failureMessage: j.expectString,
          hyperParameters: j._json,
          jobArn: j.expectString,
          jobName: j.expectString,
          lastModifiedTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "lastModifiedTime"),
          outputDataConfig: j._json,
          outputModelArn: j.expectString,
          outputModelKmsKeyArn: j.expectString,
          outputModelName: j.expectString,
          roleArn: j.expectString,
          status: j.expectString,
          trainingDataConfig: j._json,
          trainingMetrics: u((Z) => eI0(Z, B), "trainingMetrics"),
          validationDataConfig: j._json,
          validationMetrics: u((Z) => AG0(Z, B), "validationMetrics"),
          vpcConfig: j._json
        });
      return Object.assign(Q, G), Q
    }, "de_GetModelCustomizationJobCommand"),
    Uy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          creationTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "creationTime"),
          endTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "endTime"),
          failureMessage: j.expectString,
          importedModelArn: j.expectString,
          importedModelKmsKeyArn: j.expectString,
          importedModelName: j.expectString,
          jobArn: j.expectString,
          jobName: j.expectString,
          lastModifiedTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "lastModifiedTime"),
          modelDataSource: u((Z) => j._json(u2.awsExpectUnion(Z)), "modelDataSource"),
          roleArn: j.expectString,
          status: j.expectString,
          vpcConfig: j._json
        });
      return Object.assign(Q, G), Q
    }, "de_GetModelImportJobCommand"),
    Ny4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          clientRequestToken: j.expectString,
          endTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "endTime"),
          inputDataConfig: u((Z) => j._json(u2.awsExpectUnion(Z)), "inputDataConfig"),
          jobArn: j.expectString,
          jobExpirationTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "jobExpirationTime"),
          jobName: j.expectString,
          lastModifiedTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "lastModifiedTime"),
          message: j.expectString,
          modelId: j.expectString,
          outputDataConfig: u((Z) => j._json(u2.awsExpectUnion(Z)), "outputDataConfig"),
          roleArn: j.expectString,
          status: j.expectString,
          submitTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "submitTime"),
          timeoutDurationInHours: j.expectInt32,
          vpcConfig: j._json
        });
      return Object.assign(Q, G), Q
    }, "de_GetModelInvocationJobCommand"),
    $y4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          loggingConfig: j._json
        });
      return Object.assign(Q, G), Q
    }, "de_GetModelInvocationLoggingConfigurationCommand"),
    qy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          createdAt: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "createdAt"),
          description: j.expectString,
          fallbackModel: j._json,
          models: j._json,
          promptRouterArn: j.expectString,
          promptRouterName: j.expectString,
          routingCriteria: u((Z) => tI0(Z, B), "routingCriteria"),
          status: j.expectString,
          type: j.expectString,
          updatedAt: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "updatedAt")
        });
      return Object.assign(Q, G), Q
    }, "de_GetPromptRouterCommand"),
    My4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          commitmentDuration: j.expectString,
          commitmentExpirationTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "commitmentExpirationTime"),
          creationTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "creationTime"),
          desiredModelArn: j.expectString,
          desiredModelUnits: j.expectInt32,
          failureMessage: j.expectString,
          foundationModelArn: j.expectString,
          lastModifiedTime: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "lastModifiedTime"),
          modelArn: j.expectString,
          modelUnits: j.expectInt32,
          provisionedModelArn: j.expectString,
          provisionedModelName: j.expectString,
          status: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_GetProvisionedModelThroughputCommand"),
    Ly4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          modelSummaries: u((Z) => dk4(Z, B), "modelSummaries"),
          nextToken: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_ListCustomModelsCommand"),
    Ry4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          jobSummaries: u((Z) => ck4(Z, B), "jobSummaries"),
          nextToken: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_ListEvaluationJobsCommand"),
    Oy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          modelSummaries: j._json
        });
      return Object.assign(Q, G), Q
    }, "de_ListFoundationModelsCommand"),
    Ty4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          guardrails: u((Z) => Bx4(Z, B), "guardrails"),
          nextToken: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_ListGuardrailsCommand"),
    Py4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          modelSummaries: u((Z) => Gx4(Z, B), "modelSummaries"),
          nextToken: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_ListImportedModelsCommand"),
    Sy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          inferenceProfileSummaries: u((Z) => Zx4(Z, B), "inferenceProfileSummaries"),
          nextToken: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_ListInferenceProfilesCommand"),
    _y4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          marketplaceModelEndpoints: u((Z) => Fx4(Z, B), "marketplaceModelEndpoints"),
          nextToken: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_ListMarketplaceModelEndpointsCommand"),
    jy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          modelCopyJobSummaries: u((Z) => Vx4(Z, B), "modelCopyJobSummaries"),
          nextToken: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_ListModelCopyJobsCommand"),
    yy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          modelCustomizationJobSummaries: u((Z) => Kx4(Z, B), "modelCustomizationJobSummaries"),
          nextToken: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_ListModelCustomizationJobsCommand"),
    ky4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          modelImportJobSummaries: u((Z) => zx4(Z, B), "modelImportJobSummaries"),
          nextToken: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_ListModelImportJobsCommand"),
    xy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          invocationJobSummaries: u((Z) => Ex4(Z, B), "invocationJobSummaries"),
          nextToken: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_ListModelInvocationJobsCommand"),
    fy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          nextToken: j.expectString,
          promptRouterSummaries: u((Z) => Nx4(Z, B), "promptRouterSummaries")
        });
      return Object.assign(Q, G), Q
    }, "de_ListPromptRoutersCommand"),
    vy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          nextToken: j.expectString,
          provisionedModelSummaries: u((Z) => qx4(Z, B), "provisionedModelSummaries")
        });
      return Object.assign(Q, G), Q
    }, "de_ListProvisionedModelThroughputsCommand"),
    by4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          tags: j._json
        });
      return Object.assign(Q, G), Q
    }, "de_ListTagsForResourceCommand"),
    gy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_PutModelInvocationLoggingConfigurationCommand"),
    hy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          marketplaceModelEndpoint: u((Z) => HG1(Z, B), "marketplaceModelEndpoint")
        });
      return Object.assign(Q, G), Q
    }, "de_RegisterMarketplaceModelEndpointCommand"),
    my4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_StopEvaluationJobCommand"),
    dy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_StopModelCustomizationJobCommand"),
    uy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_StopModelInvocationJobCommand"),
    py4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_TagResourceCommand"),
    cy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_UntagResourceCommand"),
    ly4 = u(async (A, B) => {
      if (A.statusCode !== 202 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          guardrailArn: j.expectString,
          guardrailId: j.expectString,
          updatedAt: u((Z) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Z)), "updatedAt"),
          version: j.expectString
        });
      return Object.assign(Q, G), Q
    }, "de_UpdateGuardrailCommand"),
    iy4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
          $metadata: P2(A)
        }),
        I = j.expectNonNull(j.expectObject(await u2.parseJsonBody(A.body, B)), "body"),
        G = j.take(I, {
          marketplaceModelEndpoint: u((Z) => HG1(Z, B), "marketplaceModelEndpoint")
        });
      return Object.assign(Q, G), Q
    }, "de_UpdateMarketplaceModelEndpointCommand"),
    ny4 = u(async (A, B) => {
      if (A.statusCode !== 200 && A.statusCode >= 300) return J9(A, B);
      let Q = j.map({
        $metadata: P2(A)
      });
      return await j.collectBody(A.body, B), Q
    }, "de_UpdateProvisionedModelThroughputCommand"),
    J9 = u(async (A, B) => {
      let Q = {
          ...A,
          body: await u2.parseJsonErrorBody(A.body, B)
        },
        I = u2.loadRestJsonErrorCode(A, Q.body);
      switch (I) {
        case "AccessDeniedException":
        case "com.amazonaws.bedrock#AccessDeniedException":
          throw await sy4(Q, B);
        case "ConflictException":
        case "com.amazonaws.bedrock#ConflictException":
          throw await ry4(Q, B);
        case "InternalServerException":
        case "com.amazonaws.bedrock#InternalServerException":
          throw await oy4(Q, B);
        case "ResourceNotFoundException":
        case "com.amazonaws.bedrock#ResourceNotFoundException":
          throw await ty4(Q, B);
        case "ThrottlingException":
        case "com.amazonaws.bedrock#ThrottlingException":
          throw await Bk4(Q, B);
        case "ValidationException":
        case "com.amazonaws.bedrock#ValidationException":
          throw await Ik4(Q, B);
        case "ServiceQuotaExceededException":
        case "com.amazonaws.bedrock#ServiceQuotaExceededException":
          throw await ey4(Q, B);
        case "TooManyTagsException":
        case "com.amazonaws.bedrock#TooManyTagsException":
          throw await Qk4(Q, B);
        case "ServiceUnavailableException":
        case "com.amazonaws.bedrock#ServiceUnavailableException":
          throw await Ak4(Q, B);
        default:
          let G = Q.body;
          return ay4({
            output: A,
            parsedBody: G,
            errorCode: I
          })
      }
    }, "de_CommandError"),
    ay4 = j.withBaseException(jC),
    sy4 = u(async (A, B) => {
      let Q = j.map({}),
        I = A.body,
        G = j.take(I, {
          message: j.expectString
        });
      Object.assign(Q, G);
      let Z = new L70({
        $metadata: P2(A),
        ...Q
      });
      return j.decorateServiceException(Z, A.body)
    }, "de_AccessDeniedExceptionRes"),
    ry4 = u(async (A, B) => {
      let Q = j.map({}),
        I = A.body,
        G = j.take(I, {
          message: j.expectString
        });
      Object.assign(Q, G);
      let Z = new R70({
        $metadata: P2(A),
        ...Q
      });
      return j.decorateServiceException(Z, A.body)
    }, "de_ConflictExceptionRes"),
    oy4 = u(async (A, B) => {
      let Q = j.map({}),
        I = A.body,
        G = j.take(I, {
          message: j.expectString
        });
      Object.assign(Q, G);
      let Z = new O70({
        $metadata: P2(A),
        ...Q
      });
      return j.decorateServiceException(Z, A.body)
    }, "de_InternalServerExceptionRes"),
    ty4 = u(async (A, B) => {
      let Q = j.map({}),
        I = A.body,
        G = j.take(I, {
          message: j.expectString
        });
      Object.assign(Q, G);
      let Z = new T70({
        $metadata: P2(A),
        ...Q
      });
      return j.decorateServiceException(Z, A.body)
    }, "de_ResourceNotFoundExceptionRes"),
    ey4 = u(async (A, B) => {
      let Q = j.map({}),
        I = A.body,
        G = j.take(I, {
          message: j.expectString
        });
      Object.assign(Q, G);
      let Z = new P70({
        $metadata: P2(A),
        ...Q
      });
      return j.decorateServiceException(Z, A.body)
    }, "de_ServiceQuotaExceededExceptionRes"),
    Ak4 = u(async (A, B) => {
      let Q = j.map({}),
        I = A.body,
        G = j.take(I, {
          message: j.expectString
        });
      Object.assign(Q, G);
      let Z = new j70({
        $metadata: P2(A),
        ...Q
      });
      return j.decorateServiceException(Z, A.body)
    }, "de_ServiceUnavailableExceptionRes"),
    Bk4 = u(async (A, B) => {
      let Q = j.map({}),
        I = A.body,
        G = j.take(I, {
          message: j.expectString
        });
      Object.assign(Q, G);
      let Z = new S70({
        $metadata: P2(A),
        ...Q
      });
      return j.decorateServiceException(Z, A.body)
    }, "de_ThrottlingExceptionRes"),
    Qk4 = u(async (A, B) => {
      let Q = j.map({}),
        I = A.body,
        G = j.take(I, {
          message: j.expectString,
          resourceName: j.expectString
        });
      Object.assign(Q, G);
      let Z = new y70({
        $metadata: P2(A),
        ...Q
      });
      return j.decorateServiceException(Z, A.body)
    }, "de_TooManyTagsExceptionRes"),
    Ik4 = u(async (A, B) => {
      let Q = j.map({}),
        I = A.body,
        G = j.take(I, {
          message: j.expectString
        });
      Object.assign(Q, G);
      let Z = new _70({
        $metadata: P2(A),
        ...Q
      });
      return j.decorateServiceException(Z, A.body)
    }, "de_ValidationExceptionRes"),
    pI0 = u((A, B) => {
      return Object.entries(A).reduce((Q, [I, G]) => {
        if (G === null) return Q;
        return Q[I] = Gk4(G, B), Q
      }, {})
    }, "se_AdditionalModelRequestFields"),
    Gk4 = u((A, B) => {
      return A
    }, "se_AdditionalModelRequestFieldsValue"),
    Zk4 = u((A, B) => {
      return j.take(A, {
        customMetricConfig: u((Q) => Dk4(Q, B), "customMetricConfig"),
        datasetMetricConfigs: j._json,
        evaluatorModelConfig: j._json
      })
    }, "se_AutomatedEvaluationConfig"),
    Dk4 = u((A, B) => {
      return j.take(A, {
        customMetrics: u((Q) => Yk4(Q, B), "customMetrics"),
        evaluatorModelConfig: j._json
      })
    }, "se_AutomatedEvaluationCustomMetricConfig"),
    Yk4 = u((A, B) => {
      return A.filter((Q) => Q != null).map((Q) => {
        return Wk4(Q, B)
      })
    }, "se_AutomatedEvaluationCustomMetrics"),
    Wk4 = u((A, B) => {
      return DG1.visit(A, {
        customMetricDefinition: u((Q) => ({
          customMetricDefinition: Fk4(Q, B)
        }), "customMetricDefinition"),
        _: u((Q, I) => ({
          [Q]: I
        }), "_")
      })
    }, "se_AutomatedEvaluationCustomMetricSource"),
    Jk4 = u((A, B) => {
      return j.take(A, {
        contentType: [],
        data: B.base64Encoder,
        identifier: []
      })
    }, "se_ByteContentDoc"),
    Fk4 = u((A, B) => {
      return j.take(A, {
        instructions: [],
        name: [],
        ratingScale: u((Q) => Ok4(Q, B), "ratingScale")
      })
    }, "se_CustomMetricDefinition"),
    Xk4 = u((A, B) => {
      return YG1.visit(A, {
        automated: u((Q) => ({
          automated: Zk4(Q, B)
        }), "automated"),
        human: u((Q) => ({
          human: j._json(Q)
        }), "human"),
        _: u((Q, I) => ({
          [Q]: I
        }), "_")
      })
    }, "se_EvaluationConfig"),
    Vk4 = u((A, B) => {
      return XG1.visit(A, {
        models: u((Q) => ({
          models: j._json(Q)
        }), "models"),
        ragConfigs: u((Q) => ({
          ragConfigs: Rk4(Q, B)
        }), "ragConfigs"),
        _: u((Q, I) => ({
          [Q]: I
        }), "_")
      })
    }, "se_EvaluationInferenceConfig"),
    Ck4 = u((A, B) => {
      return j.take(A, {
        byteContent: u((Q) => Jk4(Q, B), "byteContent"),
        s3Location: j._json,
        sourceType: []
      })
    }, "se_ExternalSource"),
    Kk4 = u((A, B) => {
      return A.filter((Q) => Q != null).map((Q) => {
        return Ck4(Q, B)
      })
    }, "se_ExternalSources"),
    Hk4 = u((A, B) => {
      return j.take(A, {
        additionalModelRequestFields: u((Q) => pI0(Q, B), "additionalModelRequestFields"),
        guardrailConfiguration: j._json,
        kbInferenceConfig: u((Q) => lI0(Q, B), "kbInferenceConfig"),
        promptTemplate: j._json
      })
    }, "se_ExternalSourcesGenerationConfiguration"),
    zk4 = u((A, B) => {
      return j.take(A, {
        generationConfiguration: u((Q) => Hk4(Q, B), "generationConfiguration"),
        modelArn: [],
        sources: u((Q) => Kk4(Q, B), "sources")
      })
    }, "se_ExternalSourcesRetrieveAndGenerateConfiguration"),
    SC = u((A, B) => {
      return j.take(A, {
        key: [],
        value: u((Q) => wk4(Q, B), "value")
      })
    }, "se_FilterAttribute"),
    wk4 = u((A, B) => {
      return A
    }, "se_FilterValue"),
    Ek4 = u((A, B) => {
      return j.take(A, {
        additionalModelRequestFields: u((Q) => pI0(Q, B), "additionalModelRequestFields"),
        guardrailConfiguration: j._json,
        kbInferenceConfig: u((Q) => lI0(Q, B), "kbInferenceConfig"),
        promptTemplate: j._json
      })
    }, "se_GenerationConfiguration"),
    Uk4 = u((A, B) => {
      return j.take(A, {
        action: [],
        enabled: [],
        threshold: j.serializeFloat,
        type: []
      })
    }, "se_GuardrailContextualGroundingFilterConfig"),
    Nk4 = u((A, B) => {
      return A.filter((Q) => Q != null).map((Q) => {
        return Uk4(Q, B)
      })
    }, "se_GuardrailContextualGroundingFiltersConfig"),
    cI0 = u((A, B) => {
      return j.take(A, {
        filtersConfig: u((Q) => Nk4(Q, B), "filtersConfig")
      })
    }, "se_GuardrailContextualGroundingPolicyConfig"),
    lI0 = u((A, B) => {
      return j.take(A, {
        textInferenceConfig: u((Q) => yk4(Q, B), "textInferenceConfig")
      })
    }, "se_KbInferenceConfig"),
    $k4 = u((A, B) => {
      return JG1.visit(A, {
        retrieveAndGenerateConfig: u((Q) => ({
          retrieveAndGenerateConfig: Sk4(Q, B)
        }), "retrieveAndGenerateConfig"),
        retrieveConfig: u((Q) => ({
          retrieveConfig: _k4(Q, B)
        }), "retrieveConfig"),
        _: u((Q, I) => ({
          [Q]: I
        }), "_")
      })
    }, "se_KnowledgeBaseConfig"),
    iI0 = u((A, B) => {
      return j.take(A, {
        vectorSearchConfiguration: u((Q) => Mk4(Q, B), "vectorSearchConfiguration")
      })
    }, "se_KnowledgeBaseRetrievalConfiguration"),
    qk4 = u((A, B) => {
      return j.take(A, {
        generationConfiguration: u((Q) => Ek4(Q, B), "generationConfiguration"),
        knowledgeBaseId: [],
        modelArn: [],
        orchestrationConfiguration: j._json,
        retrievalConfiguration: u((Q) => iI0(Q, B), "retrievalConfiguration")
      })
    }, "se_KnowledgeBaseRetrieveAndGenerateConfiguration"),
    Mk4 = u((A, B) => {
      return j.take(A, {
        filter: u((Q) => nI0(Q, B), "filter"),
        numberOfResults: [],
        overrideSearchType: []
      })
    }, "se_KnowledgeBaseVectorSearchConfiguration"),
    Lk4 = u((A, B) => {
      return FG1.visit(A, {
        knowledgeBaseConfig: u((Q) => ({
          knowledgeBaseConfig: $k4(Q, B)
        }), "knowledgeBaseConfig"),
        precomputedRagSourceConfig: u((Q) => ({
          precomputedRagSourceConfig: j._json(Q)
        }), "precomputedRagSourceConfig"),
        _: u((Q, I) => ({
          [Q]: I
        }), "_")
      })
    }, "se_RAGConfig"),
    Rk4 = u((A, B) => {
      return A.filter((Q) => Q != null).map((Q) => {
        return Lk4(Q, B)
      })
    }, "se_RagConfigs"),
    Ok4 = u((A, B) => {
      return A.filter((Q) => Q != null).map((Q) => {
        return Tk4(Q, B)
      })
    }, "se_RatingScale"),
    Tk4 = u((A, B) => {
      return j.take(A, {
        definition: [],
        value: u((Q) => Pk4(Q, B), "value")
      })
    }, "se_RatingScaleItem"),
    Pk4 = u((A, B) => {
      return ZG1.visit(A, {
        floatValue: u((Q) => ({
          floatValue: j.serializeFloat(Q)
        }), "floatValue"),
        stringValue: u((Q) => ({
          stringValue: Q
        }), "stringValue"),
        _: u((Q, I) => ({
          [Q]: I
        }), "_")
      })
    }, "se_RatingScaleItemValue"),
    nI0 = u((A, B) => {
      return WG1.visit(A, {
        andAll: u((Q) => ({
          andAll: Y70(Q, B)
        }), "andAll"),
        equals: u((Q) => ({
          equals: SC(Q, B)
        }), "equals"),
        greaterThan: u((Q) => ({
          greaterThan: SC(Q, B)
        }), "greaterThan"),
        greaterThanOrEquals: u((Q) => ({
          greaterThanOrEquals: SC(Q, B)
        }), "greaterThanOrEquals"),
        in: u((Q) => ({
          in: SC(Q, B)
        }), "in"),
        lessThan: u((Q) => ({
          lessThan: SC(Q, B)
        }), "lessThan"),
        lessThanOrEquals: u((Q) => ({
          lessThanOrEquals: SC(Q, B)
        }), "lessThanOrEquals"),
        listContains: u((Q) => ({
          listContains: SC(Q, B)
        }), "listContains"),
        notEquals: u((Q) => ({
          notEquals: SC(Q, B)
        }), "notEquals"),
        notIn: u((Q) => ({
          notIn: SC(Q, B)
        }), "notIn"),
        orAll: u((Q) => ({
          orAll: Y70(Q, B)
        }), "orAll"),
        startsWith: u((Q) => ({
          startsWith: SC(Q, B)
        }), "startsWith"),
        stringContains: u((Q) => ({
          stringContains: SC(Q, B)
        }), "stringContains"),
        _: u((Q, I) => ({
          [Q]: I
        }), "_")
      })
    }, "se_RetrievalFilter"),
    Y70 = u((A, B) => {
      return A.filter((Q) => Q != null).map((Q) => {
        return nI0(Q, B)
      })
    }, "se_RetrievalFilterList"),
    Sk4 = u((A, B) => {
      return j.take(A, {
        externalSourcesConfiguration: u((Q) => zk4(Q, B), "externalSourcesConfiguration"),
        knowledgeBaseConfiguration: u((Q) => qk4(Q, B), "knowledgeBaseConfiguration"),
        type: []
      })
    }, "se_RetrieveAndGenerateConfiguration"),
    _k4 = u((A, B) => {
      return j.take(A, {
        knowledgeBaseId: [],
        knowledgeBaseRetrievalConfiguration: u((Q) => iI0(Q, B), "knowledgeBaseRetrievalConfiguration")
      })
    }, "se_RetrieveConfig"),
    jk4 = u((A, B) => {
      return j.take(A, {
        responseQualityDifference: j.serializeFloat
      })
    }, "se_RoutingCriteria"),
    yk4 = u((A, B) => {
      return j.take(A, {
        maxTokens: [],
        stopSequences: j._json,
        temperature: j.serializeFloat,
        topP: j.serializeFloat
      })
    }, "se_TextInferenceConfig"),
    aI0 = u((A, B) => {
      return Object.entries(A).reduce((Q, [I, G]) => {
        if (G === null) return Q;
        return Q[I] = kk4(G, B), Q
      }, {})
    }, "de_AdditionalModelRequestFields"),
    kk4 = u((A, B) => {
      return A
    }, "de_AdditionalModelRequestFieldsValue"),
    xk4 = u((A, B) => {
      return j.take(A, {
        customMetricConfig: u((Q) => fk4(Q, B), "customMetricConfig"),
        datasetMetricConfigs: j._json,
        evaluatorModelConfig: u((Q) => j._json(u2.awsExpectUnion(Q)), "evaluatorModelConfig")
      })
    }, "de_AutomatedEvaluationConfig"),
    fk4 = u((A, B) => {
      return j.take(A, {
        customMetrics: u((Q) => vk4(Q, B), "customMetrics"),
        evaluatorModelConfig: j._json
      })
    }, "de_AutomatedEvaluationCustomMetricConfig"),
    vk4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return bk4(u2.awsExpectUnion(I), B)
      })
    }, "de_AutomatedEvaluationCustomMetrics"),
    bk4 = u((A, B) => {
      if (A.customMetricDefinition != null) return {
        customMetricDefinition: hk4(A.customMetricDefinition, B)
      };
      return {
        $unknown: Object.entries(A)[0]
      }
    }, "de_AutomatedEvaluationCustomMetricSource"),
    gk4 = u((A, B) => {
      return j.take(A, {
        contentType: j.expectString,
        data: B.base64Decoder,
        identifier: j.expectString
      })
    }, "de_ByteContentDoc"),
    hk4 = u((A, B) => {
      return j.take(A, {
        instructions: j.expectString,
        name: j.expectString,
        ratingScale: u((Q) => Ox4(Q, B), "ratingScale")
      })
    }, "de_CustomMetricDefinition"),
    mk4 = u((A, B) => {
      return j.take(A, {
        baseModelArn: j.expectString,
        baseModelName: j.expectString,
        creationTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "creationTime"),
        customizationType: j.expectString,
        modelArn: j.expectString,
        modelName: j.expectString,
        ownerAccountId: j.expectString
      })
    }, "de_CustomModelSummary"),
    dk4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return mk4(I, B)
      })
    }, "de_CustomModelSummaryList"),
    uk4 = u((A, B) => {
      if (A.automated != null) return {
        automated: xk4(A.automated, B)
      };
      if (A.human != null) return {
        human: j._json(A.human)
      };
      return {
        $unknown: Object.entries(A)[0]
      }
    }, "de_EvaluationConfig"),
    pk4 = u((A, B) => {
      if (A.models != null) return {
        models: j._json(A.models)
      };
      if (A.ragConfigs != null) return {
        ragConfigs: Rx4(A.ragConfigs, B)
      };
      return {
        $unknown: Object.entries(A)[0]
      }
    }, "de_EvaluationInferenceConfig"),
    ck4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return lk4(I, B)
      })
    }, "de_EvaluationSummaries"),
    lk4 = u((A, B) => {
      return j.take(A, {
        applicationType: j.expectString,
        creationTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "creationTime"),
        customMetricsEvaluatorModelIdentifiers: j._json,
        evaluationTaskTypes: j._json,
        evaluatorModelIdentifiers: j._json,
        inferenceConfigSummary: j._json,
        jobArn: j.expectString,
        jobName: j.expectString,
        jobType: j.expectString,
        modelIdentifiers: j._json,
        ragIdentifiers: j._json,
        status: j.expectString
      })
    }, "de_EvaluationSummary"),
    ik4 = u((A, B) => {
      return j.take(A, {
        byteContent: u((Q) => gk4(Q, B), "byteContent"),
        s3Location: j._json,
        sourceType: j.expectString
      })
    }, "de_ExternalSource"),
    nk4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return ik4(I, B)
      })
    }, "de_ExternalSources"),
    ak4 = u((A, B) => {
      return j.take(A, {
        additionalModelRequestFields: u((Q) => aI0(Q, B), "additionalModelRequestFields"),
        guardrailConfiguration: j._json,
        kbInferenceConfig: u((Q) => sI0(Q, B), "kbInferenceConfig"),
        promptTemplate: j._json
      })
    }, "de_ExternalSourcesGenerationConfiguration"),
    sk4 = u((A, B) => {
      return j.take(A, {
        generationConfiguration: u((Q) => ak4(Q, B), "generationConfiguration"),
        modelArn: j.expectString,
        sources: u((Q) => nk4(Q, B), "sources")
      })
    }, "de_ExternalSourcesRetrieveAndGenerateConfiguration"),
    _C = u((A, B) => {
      return j.take(A, {
        key: j.expectString,
        value: u((Q) => rk4(Q, B), "value")
      })
    }, "de_FilterAttribute"),
    rk4 = u((A, B) => {
      return A
    }, "de_FilterValue"),
    ok4 = u((A, B) => {
      return j.take(A, {
        additionalModelRequestFields: u((Q) => aI0(Q, B), "additionalModelRequestFields"),
        guardrailConfiguration: j._json,
        kbInferenceConfig: u((Q) => sI0(Q, B), "kbInferenceConfig"),
        promptTemplate: j._json
      })
    }, "de_GenerationConfiguration"),
    tk4 = u((A, B) => {
      return j.take(A, {
        action: j.expectString,
        enabled: j.expectBoolean,
        threshold: j.limitedParseDouble,
        type: j.expectString
      })
    }, "de_GuardrailContextualGroundingFilter"),
    ek4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return tk4(I, B)
      })
    }, "de_GuardrailContextualGroundingFilters"),
    Ax4 = u((A, B) => {
      return j.take(A, {
        filters: u((Q) => ek4(Q, B), "filters")
      })
    }, "de_GuardrailContextualGroundingPolicy"),
    Bx4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return Qx4(I, B)
      })
    }, "de_GuardrailSummaries"),
    Qx4 = u((A, B) => {
      return j.take(A, {
        arn: j.expectString,
        createdAt: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "createdAt"),
        description: j.expectString,
        id: j.expectString,
        name: j.expectString,
        status: j.expectString,
        updatedAt: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "updatedAt"),
        version: j.expectString
      })
    }, "de_GuardrailSummary"),
    Ix4 = u((A, B) => {
      return j.take(A, {
        creationTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "creationTime"),
        instructSupported: j.expectBoolean,
        modelArchitecture: j.expectString,
        modelArn: j.expectString,
        modelName: j.expectString
      })
    }, "de_ImportedModelSummary"),
    Gx4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return Ix4(I, B)
      })
    }, "de_ImportedModelSummaryList"),
    Zx4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return Dx4(I, B)
      })
    }, "de_InferenceProfileSummaries"),
    Dx4 = u((A, B) => {
      return j.take(A, {
        createdAt: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "createdAt"),
        description: j.expectString,
        inferenceProfileArn: j.expectString,
        inferenceProfileId: j.expectString,
        inferenceProfileName: j.expectString,
        models: j._json,
        status: j.expectString,
        type: j.expectString,
        updatedAt: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "updatedAt")
      })
    }, "de_InferenceProfileSummary"),
    sI0 = u((A, B) => {
      return j.take(A, {
        textInferenceConfig: u((Q) => jx4(Q, B), "textInferenceConfig")
      })
    }, "de_KbInferenceConfig"),
    Yx4 = u((A, B) => {
      if (A.retrieveAndGenerateConfig != null) return {
        retrieveAndGenerateConfig: Sx4(A.retrieveAndGenerateConfig, B)
      };
      if (A.retrieveConfig != null) return {
        retrieveConfig: _x4(A.retrieveConfig, B)
      };
      return {
        $unknown: Object.entries(A)[0]
      }
    }, "de_KnowledgeBaseConfig"),
    rI0 = u((A, B) => {
      return j.take(A, {
        vectorSearchConfiguration: u((Q) => Jx4(Q, B), "vectorSearchConfiguration")
      })
    }, "de_KnowledgeBaseRetrievalConfiguration"),
    Wx4 = u((A, B) => {
      return j.take(A, {
        generationConfiguration: u((Q) => ok4(Q, B), "generationConfiguration"),
        knowledgeBaseId: j.expectString,
        modelArn: j.expectString,
        orchestrationConfiguration: j._json,
        retrievalConfiguration: u((Q) => rI0(Q, B), "retrievalConfiguration")
      })
    }, "de_KnowledgeBaseRetrieveAndGenerateConfiguration"),
    Jx4 = u((A, B) => {
      return j.take(A, {
        filter: u((Q) => oI0(u2.awsExpectUnion(Q), B), "filter"),
        numberOfResults: j.expectInt32,
        overrideSearchType: j.expectString
      })
    }, "de_KnowledgeBaseVectorSearchConfiguration"),
    HG1 = u((A, B) => {
      return j.take(A, {
        createdAt: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "createdAt"),
        endpointArn: j.expectString,
        endpointConfig: u((Q) => j._json(u2.awsExpectUnion(Q)), "endpointConfig"),
        endpointStatus: j.expectString,
        endpointStatusMessage: j.expectString,
        modelSourceIdentifier: j.expectString,
        status: j.expectString,
        statusMessage: j.expectString,
        updatedAt: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "updatedAt")
      })
    }, "de_MarketplaceModelEndpoint"),
    Fx4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return Xx4(I, B)
      })
    }, "de_MarketplaceModelEndpointSummaries"),
    Xx4 = u((A, B) => {
      return j.take(A, {
        createdAt: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "createdAt"),
        endpointArn: j.expectString,
        modelSourceIdentifier: j.expectString,
        status: j.expectString,
        statusMessage: j.expectString,
        updatedAt: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "updatedAt")
      })
    }, "de_MarketplaceModelEndpointSummary"),
    Vx4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return Cx4(I, B)
      })
    }, "de_ModelCopyJobSummaries"),
    Cx4 = u((A, B) => {
      return j.take(A, {
        creationTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "creationTime"),
        failureMessage: j.expectString,
        jobArn: j.expectString,
        sourceAccountId: j.expectString,
        sourceModelArn: j.expectString,
        sourceModelName: j.expectString,
        status: j.expectString,
        targetModelArn: j.expectString,
        targetModelKmsKeyArn: j.expectString,
        targetModelName: j.expectString,
        targetModelTags: j._json
      })
    }, "de_ModelCopyJobSummary"),
    Kx4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return Hx4(I, B)
      })
    }, "de_ModelCustomizationJobSummaries"),
    Hx4 = u((A, B) => {
      return j.take(A, {
        baseModelArn: j.expectString,
        creationTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "creationTime"),
        customModelArn: j.expectString,
        customModelName: j.expectString,
        customizationType: j.expectString,
        endTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "endTime"),
        jobArn: j.expectString,
        jobName: j.expectString,
        lastModifiedTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "lastModifiedTime"),
        status: j.expectString
      })
    }, "de_ModelCustomizationJobSummary"),
    zx4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return wx4(I, B)
      })
    }, "de_ModelImportJobSummaries"),
    wx4 = u((A, B) => {
      return j.take(A, {
        creationTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "creationTime"),
        endTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "endTime"),
        importedModelArn: j.expectString,
        importedModelName: j.expectString,
        jobArn: j.expectString,
        jobName: j.expectString,
        lastModifiedTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "lastModifiedTime"),
        status: j.expectString
      })
    }, "de_ModelImportJobSummary"),
    Ex4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return Ux4(I, B)
      })
    }, "de_ModelInvocationJobSummaries"),
    Ux4 = u((A, B) => {
      return j.take(A, {
        clientRequestToken: j.expectString,
        endTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "endTime"),
        inputDataConfig: u((Q) => j._json(u2.awsExpectUnion(Q)), "inputDataConfig"),
        jobArn: j.expectString,
        jobExpirationTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "jobExpirationTime"),
        jobName: j.expectString,
        lastModifiedTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "lastModifiedTime"),
        message: j.expectString,
        modelId: j.expectString,
        outputDataConfig: u((Q) => j._json(u2.awsExpectUnion(Q)), "outputDataConfig"),
        roleArn: j.expectString,
        status: j.expectString,
        submitTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "submitTime"),
        timeoutDurationInHours: j.expectInt32,
        vpcConfig: j._json
      })
    }, "de_ModelInvocationJobSummary"),
    Nx4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return $x4(I, B)
      })
    }, "de_PromptRouterSummaries"),
    $x4 = u((A, B) => {
      return j.take(A, {
        createdAt: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "createdAt"),
        description: j.expectString,
        fallbackModel: j._json,
        models: j._json,
        promptRouterArn: j.expectString,
        promptRouterName: j.expectString,
        routingCriteria: u((Q) => tI0(Q, B), "routingCriteria"),
        status: j.expectString,
        type: j.expectString,
        updatedAt: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "updatedAt")
      })
    }, "de_PromptRouterSummary"),
    qx4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return Mx4(I, B)
      })
    }, "de_ProvisionedModelSummaries"),
    Mx4 = u((A, B) => {
      return j.take(A, {
        commitmentDuration: j.expectString,
        commitmentExpirationTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "commitmentExpirationTime"),
        creationTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "creationTime"),
        desiredModelArn: j.expectString,
        desiredModelUnits: j.expectInt32,
        foundationModelArn: j.expectString,
        lastModifiedTime: u((Q) => j.expectNonNull(j.parseRfc3339DateTimeWithOffset(Q)), "lastModifiedTime"),
        modelArn: j.expectString,
        modelUnits: j.expectInt32,
        provisionedModelArn: j.expectString,
        provisionedModelName: j.expectString,
        status: j.expectString
      })
    }, "de_ProvisionedModelSummary"),
    Lx4 = u((A, B) => {
      if (A.knowledgeBaseConfig != null) return {
        knowledgeBaseConfig: Yx4(u2.awsExpectUnion(A.knowledgeBaseConfig), B)
      };
      if (A.precomputedRagSourceConfig != null) return {
        precomputedRagSourceConfig: j._json(u2.awsExpectUnion(A.precomputedRagSourceConfig))
      };
      return {
        $unknown: Object.entries(A)[0]
      }
    }, "de_RAGConfig"),
    Rx4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return Lx4(u2.awsExpectUnion(I), B)
      })
    }, "de_RagConfigs"),
    Ox4 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return Tx4(I, B)
      })
    }, "de_RatingScale"),
    Tx4 = u((A, B) => {
      return j.take(A, {
        definition: j.expectString,
        value: u((Q) => Px4(u2.awsExpectUnion(Q), B), "value")
      })
    }, "de_RatingScaleItem"),
    Px4 = u((A, B) => {
      if (j.limitedParseFloat32(A.floatValue) !== void 0) return {
        floatValue: j.limitedParseFloat32(A.floatValue)
      };
      if (j.expectString(A.stringValue) !== void 0) return {
        stringValue: j.expectString(A.stringValue)
      };
      return {
        $unknown: Object.entries(A)[0]
      }
    }, "de_RatingScaleItemValue"),
    oI0 = u((A, B) => {
      if (A.andAll != null) return {
        andAll: W70(A.andAll, B)
      };
      if (A.equals != null) return {
        equals: _C(A.equals, B)
      };
      if (A.greaterThan != null) return {
        greaterThan: _C(A.greaterThan, B)
      };
      if (A.greaterThanOrEquals != null) return {
        greaterThanOrEquals: _C(A.greaterThanOrEquals, B)
      };
      if (A.in != null) return {
        in: _C(A.in, B)
      };
      if (A.lessThan != null) return {
        lessThan: _C(A.lessThan, B)
      };
      if (A.lessThanOrEquals != null) return {
        lessThanOrEquals: _C(A.lessThanOrEquals, B)
      };
      if (A.listContains != null) return {
        listContains: _C(A.listContains, B)
      };
      if (A.notEquals != null) return {
        notEquals: _C(A.notEquals, B)
      };
      if (A.notIn != null) return {
        notIn: _C(A.notIn, B)
      };
      if (A.orAll != null) return {
        orAll: W70(A.orAll, B)
      };
      if (A.startsWith != null) return {
        startsWith: _C(A.startsWith, B)
      };
      if (A.stringContains != null) return {
        stringContains: _C(A.stringContains, B)
      };
      return {
        $unknown: Object.entries(A)[0]
      }
    }, "de_RetrievalFilter"),
    W70 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return oI0(u2.awsExpectUnion(I), B)
      })
    }, "de_RetrievalFilterList"),
    Sx4 = u((A, B) => {
      return j.take(A, {
        externalSourcesConfiguration: u((Q) => sk4(Q, B), "externalSourcesConfiguration"),
        knowledgeBaseConfiguration: u((Q) => Wx4(Q, B), "knowledgeBaseConfiguration"),
        type: j.expectString
      })
    }, "de_RetrieveAndGenerateConfiguration"),
    _x4 = u((A, B) => {
      return j.take(A, {
        knowledgeBaseId: j.expectString,
        knowledgeBaseRetrievalConfiguration: u((Q) => rI0(Q, B), "knowledgeBaseRetrievalConfiguration")
      })
    }, "de_RetrieveConfig"),
    tI0 = u((A, B) => {
      return j.take(A, {
        responseQualityDifference: j.limitedParseDouble
      })
    }, "de_RoutingCriteria"),
    jx4 = u((A, B) => {
      return j.take(A, {
        maxTokens: j.expectInt32,
        stopSequences: j._json,
        temperature: j.limitedParseFloat32,
        topP: j.limitedParseFloat32
      })
    }, "de_TextInferenceConfig"),
    eI0 = u((A, B) => {
      return j.take(A, {
        trainingLoss: j.limitedParseFloat32
      })
    }, "de_TrainingMetrics"),
    AG0 = u((A, B) => {
      return (A || []).filter((I) => I != null).map((I) => {
        return yx4(I, B)
      })
    }, "de_ValidationMetrics"),
    yx4 = u((A, B) => {
      return j.take(A, {
        validationLoss: j.limitedParseFloat32
      })
    }, "de_ValidatorMetric"),
    P2 = u((A) => ({
      httpStatusCode: A.statusCode,
      requestId: A.headers["x-amzn-requestid"] ?? A.headers["x-amzn-request-id"] ?? A.headers["x-amz-request-id"],
      extendedRequestId: A.headers["x-amz-id-2"],
      cfId: A.headers["x-amz-cf-id"]
    }), "deserializeMetadata"),
    J70 = "applicationTypeEquals",
    F70 = "byCustomizationType",
    X70 = "byInferenceType",
    V70 = "baseModelArnEquals",
    C70 = "byOutputModality",
    K70 = "byProvider",
    vY = "creationTimeAfter",
    bY = "creationTimeBefore",
    H70 = "foundationModelArnEquals",
    z70 = "guardrailIdentifier",
    VG1 = "guardrailVersion",
    w70 = "isOwned",
    E70 = "modelArnEquals",
    tB = "maxResults",
    kx4 = "modelSourceEquals",
    xx4 = "modelSourceIdentifier",
    gY = "nameContains",
    eB = "nextToken",
    fx4 = "outputModelNameContains",
    U70 = "sourceAccountEquals",
    RZ = "sortBy",
    HX = "statusEquals",
    N70 = "sourceModelArnEquals",
    OZ = "sortOrder",
    $70 = "submitTimeAfter",
    q70 = "submitTimeBefore",
    Kf1 = "type",
    vx4 = "typeEquals",
    bx4 = "targetModelNameContains",
    BG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "BatchDeleteEvaluationJob", {}).n("BedrockClient", "BatchDeleteEvaluationJobCommand").f(k70, v70).ser(g_4).de(pj4).build() {
      static {
        u(this, "BatchDeleteEvaluationJobCommand")
      }
    },
    QG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "CreateEvaluationJob", {}).n("BedrockClient", "CreateEvaluationJobCommand").f(dI0, void 0).ser(h_4).de(cj4).build() {
      static {
        u(this, "CreateEvaluationJobCommand")
      }
    },
    IG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "CreateGuardrail", {}).n("BedrockClient", "CreateGuardrailCommand").f(GI0, void 0).ser(m_4).de(lj4).build() {
      static {
        u(this, "CreateGuardrailCommand")
      }
    },
    GG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "CreateGuardrailVersion", {}).n("BedrockClient", "CreateGuardrailVersionCommand").f(ZI0, void 0).ser(d_4).de(ij4).build() {
      static {
        u(this, "CreateGuardrailVersionCommand")
      }
    },
    ZG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "CreateInferenceProfile", {}).n("BedrockClient", "CreateInferenceProfileCommand").f(UI0, void 0).ser(u_4).de(nj4).build() {
      static {
        u(this, "CreateInferenceProfileCommand")
      }
    },
    DG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "CreateMarketplaceModelEndpoint", {}).n("BedrockClient", "CreateMarketplaceModelEndpointCommand").f(void 0, void 0).ser(p_4).de(aj4).build() {
      static {
        u(this, "CreateMarketplaceModelEndpointCommand")
      }
    },
    YG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "CreateModelCopyJob", {}).n("BedrockClient", "CreateModelCopyJobCommand").f(void 0, void 0).ser(c_4).de(sj4).build() {
      static {
        u(this, "CreateModelCopyJobCommand")
      }
    },
    WG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "CreateModelCustomizationJob", {}).n("BedrockClient", "CreateModelCustomizationJobCommand").f(kI0, void 0).ser(l_4).de(rj4).build() {
      static {
        u(this, "CreateModelCustomizationJobCommand")
      }
    },
    JG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "CreateModelImportJob", {}).n("BedrockClient", "CreateModelImportJobCommand").f(void 0, void 0).ser(i_4).de(oj4).build() {
      static {
        u(this, "CreateModelImportJobCommand")
      }
    },
    FG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "CreateModelInvocationJob", {}).n("BedrockClient", "CreateModelInvocationJobCommand").f(void 0, void 0).ser(n_4).de(tj4).build() {
      static {
        u(this, "CreateModelInvocationJobCommand")
      }
    },
    XG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "CreatePromptRouter", {}).n("BedrockClient", "CreatePromptRouterCommand").f(SI0, void 0).ser(a_4).de(ej4).build() {
      static {
        u(this, "CreatePromptRouterCommand")
      }
    },
    VG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "CreateProvisionedModelThroughput", {}).n("BedrockClient", "CreateProvisionedModelThroughputCommand").f(void 0, void 0).ser(s_4).de(Ay4).build() {
      static {
        u(this, "CreateProvisionedModelThroughputCommand")
      }
    },
    CG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "DeleteCustomModel", {}).n("BedrockClient", "DeleteCustomModelCommand").f(void 0, void 0).ser(r_4).de(By4).build() {
      static {
        u(this, "DeleteCustomModelCommand")
      }
    },
    KG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "DeleteGuardrail", {}).n("BedrockClient", "DeleteGuardrailCommand").f(void 0, void 0).ser(o_4).de(Qy4).build() {
      static {
        u(this, "DeleteGuardrailCommand")
      }
    },
    HG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "DeleteImportedModel", {}).n("BedrockClient", "DeleteImportedModelCommand").f(void 0, void 0).ser(t_4).de(Iy4).build() {
      static {
        u(this, "DeleteImportedModelCommand")
      }
    },
    zG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "DeleteInferenceProfile", {}).n("BedrockClient", "DeleteInferenceProfileCommand").f(void 0, void 0).ser(e_4).de(Gy4).build() {
      static {
        u(this, "DeleteInferenceProfileCommand")
      }
    },
    wG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "DeleteMarketplaceModelEndpoint", {}).n("BedrockClient", "DeleteMarketplaceModelEndpointCommand").f(void 0, void 0).ser(Aj4).de(Zy4).build() {
      static {
        u(this, "DeleteMarketplaceModelEndpointCommand")
      }
    },
    EG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "DeleteModelInvocationLoggingConfiguration", {}).n("BedrockClient", "DeleteModelInvocationLoggingConfigurationCommand").f(void 0, void 0).ser(Bj4).de(Dy4).build() {
      static {
        u(this, "DeleteModelInvocationLoggingConfigurationCommand")
      }
    },
    UG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "DeletePromptRouter", {}).n("BedrockClient", "DeletePromptRouterCommand").f(void 0, void 0).ser(Qj4).de(Yy4).build() {
      static {
        u(this, "DeletePromptRouterCommand")
      }
    },
    NG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "DeleteProvisionedModelThroughput", {}).n("BedrockClient", "DeleteProvisionedModelThroughputCommand").f(void 0, void 0).ser(Ij4).de(Wy4).build() {
      static {
        u(this, "DeleteProvisionedModelThroughputCommand")
      }
    },
    $G0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "DeregisterMarketplaceModelEndpoint", {}).n("BedrockClient", "DeregisterMarketplaceModelEndpointCommand").f(void 0, void 0).ser(Gj4).de(Jy4).build() {
      static {
        u(this, "DeregisterMarketplaceModelEndpointCommand")
      }
    },
    qG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetCustomModel", {}).n("BedrockClient", "GetCustomModelCommand").f(void 0, PI0).ser(Zj4).de(Fy4).build() {
      static {
        u(this, "GetCustomModelCommand")
      }
    },
    MG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetEvaluationJob", {}).n("BedrockClient", "GetEvaluationJobCommand").f(o70, uI0).ser(Dj4).de(Xy4).build() {
      static {
        u(this, "GetEvaluationJobCommand")
      }
    },
    LG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetFoundationModel", {}).n("BedrockClient", "GetFoundationModelCommand").f(void 0, void 0).ser(Yj4).de(Vy4).build() {
      static {
        u(this, "GetFoundationModelCommand")
      }
    },
    RG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetGuardrail", {}).n("BedrockClient", "GetGuardrailCommand").f(void 0, HI0).ser(Wj4).de(Cy4).build() {
      static {
        u(this, "GetGuardrailCommand")
      }
    },
    OG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetImportedModel", {}).n("BedrockClient", "GetImportedModelCommand").f(void 0, void 0).ser(Jj4).de(Ky4).build() {
      static {
        u(this, "GetImportedModelCommand")
      }
    },
    TG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetInferenceProfile", {}).n("BedrockClient", "GetInferenceProfileCommand").f(void 0, NI0).ser(Fj4).de(Hy4).build() {
      static {
        u(this, "GetInferenceProfileCommand")
      }
    },
    PG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetMarketplaceModelEndpoint", {}).n("BedrockClient", "GetMarketplaceModelEndpointCommand").f(void 0, void 0).ser(Xj4).de(zy4).build() {
      static {
        u(this, "GetMarketplaceModelEndpointCommand")
      }
    },
    SG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetModelCopyJob", {}).n("BedrockClient", "GetModelCopyJobCommand").f(void 0, void 0).ser(Vj4).de(wy4).build() {
      static {
        u(this, "GetModelCopyJobCommand")
      }
    },
    _G0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetModelCustomizationJob", {}).n("BedrockClient", "GetModelCustomizationJobCommand").f(void 0, xI0).ser(Cj4).de(Ey4).build() {
      static {
        u(this, "GetModelCustomizationJobCommand")
      }
    },
    jG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetModelImportJob", {}).n("BedrockClient", "GetModelImportJobCommand").f(void 0, void 0).ser(Kj4).de(Uy4).build() {
      static {
        u(this, "GetModelImportJobCommand")
      }
    },
    yG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetModelInvocationJob", {}).n("BedrockClient", "GetModelInvocationJobCommand").f(void 0, MI0).ser(Hj4).de(Ny4).build() {
      static {
        u(this, "GetModelInvocationJobCommand")
      }
    },
    kG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetModelInvocationLoggingConfiguration", {}).n("BedrockClient", "GetModelInvocationLoggingConfigurationCommand").f(void 0, void 0).ser(zj4).de($y4).build() {
      static {
        u(this, "GetModelInvocationLoggingConfigurationCommand")
      }
    },
    xG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetPromptRouter", {}).n("BedrockClient", "GetPromptRouterCommand").f(void 0, _I0).ser(wj4).de(qy4).build() {
      static {
        u(this, "GetPromptRouterCommand")
      }
    },
    fG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "GetProvisionedModelThroughput", {}).n("BedrockClient", "GetProvisionedModelThroughputCommand").f(void 0, void 0).ser(Ej4).de(My4).build() {
      static {
        u(this, "GetProvisionedModelThroughputCommand")
      }
    },
    Lf1 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListCustomModels", {}).n("BedrockClient", "ListCustomModelsCommand").f(void 0, void 0).ser(Uj4).de(Ly4).build() {
      static {
        u(this, "ListCustomModelsCommand")
      }
    },
    Rf1 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListEvaluationJobs", {}).n("BedrockClient", "ListEvaluationJobsCommand").f(void 0, void 0).ser(Nj4).de(Ry4).build() {
      static {
        u(this, "ListEvaluationJobsCommand")
      }
    },
    vG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListFoundationModels", {}).n("BedrockClient", "ListFoundationModelsCommand").f(void 0, void 0).ser($j4).de(Oy4).build() {
      static {
        u(this, "ListFoundationModelsCommand")
      }
    },
    Of1 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListGuardrails", {}).n("BedrockClient", "ListGuardrailsCommand").f(void 0, wI0).ser(qj4).de(Ty4).build() {
      static {
        u(this, "ListGuardrailsCommand")
      }
    },
    Tf1 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListImportedModels", {}).n("BedrockClient", "ListImportedModelsCommand").f(void 0, void 0).ser(Mj4).de(Py4).build() {
      static {
        u(this, "ListImportedModelsCommand")
      }
    },
    Pf1 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListInferenceProfiles", {}).n("BedrockClient", "ListInferenceProfilesCommand").f(void 0, qI0).ser(Lj4).de(Sy4).build() {
      static {
        u(this, "ListInferenceProfilesCommand")
      }
    },
    Sf1 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListMarketplaceModelEndpoints", {}).n("BedrockClient", "ListMarketplaceModelEndpointsCommand").f(void 0, void 0).ser(Rj4).de(_y4).build() {
      static {
        u(this, "ListMarketplaceModelEndpointsCommand")
      }
    },
    _f1 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListModelCopyJobs", {}).n("BedrockClient", "ListModelCopyJobsCommand").f(void 0, void 0).ser(Oj4).de(jy4).build() {
      static {
        u(this, "ListModelCopyJobsCommand")
      }
    },
    jf1 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListModelCustomizationJobs", {}).n("BedrockClient", "ListModelCustomizationJobsCommand").f(void 0, void 0).ser(Tj4).de(yy4).build() {
      static {
        u(this, "ListModelCustomizationJobsCommand")
      }
    },
    yf1 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListModelImportJobs", {}).n("BedrockClient", "ListModelImportJobsCommand").f(void 0, void 0).ser(Pj4).de(ky4).build() {
      static {
        u(this, "ListModelImportJobsCommand")
      }
    },
    kf1 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListModelInvocationJobs", {}).n("BedrockClient", "ListModelInvocationJobsCommand").f(void 0, RI0).ser(Sj4).de(xy4).build() {
      static {
        u(this, "ListModelInvocationJobsCommand")
      }
    },
    xf1 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListPromptRouters", {}).n("BedrockClient", "ListPromptRoutersCommand").f(void 0, yI0).ser(_j4).de(fy4).build() {
      static {
        u(this, "ListPromptRoutersCommand")
      }
    },
    ff1 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListProvisionedModelThroughputs", {}).n("BedrockClient", "ListProvisionedModelThroughputsCommand").f(void 0, void 0).ser(jj4).de(vy4).build() {
      static {
        u(this, "ListProvisionedModelThroughputsCommand")
      }
    },
    bG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "ListTagsForResource", {}).n("BedrockClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(yj4).de(by4).build() {
      static {
        u(this, "ListTagsForResourceCommand")
      }
    },
    gG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "PutModelInvocationLoggingConfiguration", {}).n("BedrockClient", "PutModelInvocationLoggingConfigurationCommand").f(void 0, void 0).ser(kj4).de(gy4).build() {
      static {
        u(this, "PutModelInvocationLoggingConfigurationCommand")
      }
    },
    hG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "RegisterMarketplaceModelEndpoint", {}).n("BedrockClient", "RegisterMarketplaceModelEndpointCommand").f(void 0, void 0).ser(xj4).de(hy4).build() {
      static {
        u(this, "RegisterMarketplaceModelEndpointCommand")
      }
    },
    mG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "StopEvaluationJob", {}).n("BedrockClient", "StopEvaluationJobCommand").f(t70, void 0).ser(fj4).de(my4).build() {
      static {
        u(this, "StopEvaluationJobCommand")
      }
    },
    dG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "StopModelCustomizationJob", {}).n("BedrockClient", "StopModelCustomizationJobCommand").f(void 0, void 0).ser(vj4).de(dy4).build() {
      static {
        u(this, "StopModelCustomizationJobCommand")
      }
    },
    uG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "StopModelInvocationJob", {}).n("BedrockClient", "StopModelInvocationJobCommand").f(void 0, void 0).ser(bj4).de(uy4).build() {
      static {
        u(this, "StopModelInvocationJobCommand")
      }
    },
    pG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "TagResource", {}).n("BedrockClient", "TagResourceCommand").f(void 0, void 0).ser(gj4).de(py4).build() {
      static {
        u(this, "TagResourceCommand")
      }
    },
    cG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "UntagResource", {}).n("BedrockClient", "UntagResourceCommand").f(void 0, void 0).ser(hj4).de(cy4).build() {
      static {
        u(this, "UntagResourceCommand")
      }
    },
    lG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "UpdateGuardrail", {}).n("BedrockClient", "UpdateGuardrailCommand").f(EI0, void 0).ser(mj4).de(ly4).build() {
      static {
        u(this, "UpdateGuardrailCommand")
      }
    },
    iG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "UpdateMarketplaceModelEndpoint", {}).n("BedrockClient", "UpdateMarketplaceModelEndpointCommand").f(void 0, void 0).ser(dj4).de(iy4).build() {
      static {
        u(this, "UpdateMarketplaceModelEndpointCommand")
      }
    },
    nG0 = class extends j.Command.classBuilder().ep(Y9).m(function(A, B, Q, I) {
      return [W9.getSerdePlugin(Q, this.serialize, this.deserialize), I9.getEndpointPlugin(Q, A.getEndpointParameterInstructions())]
    }).s("AmazonBedrockControlPlaneService", "UpdateProvisionedModelThroughput", {}).n("BedrockClient", "UpdateProvisionedModelThroughputCommand").f(void 0, void 0).ser(uj4).de(ny4).build() {
      static {
        u(this, "UpdateProvisionedModelThroughputCommand")
      }
    },
    gx4 = {
      BatchDeleteEvaluationJobCommand: BG0,
      CreateEvaluationJobCommand: QG0,
      CreateGuardrailCommand: IG0,
      CreateGuardrailVersionCommand: GG0,
      CreateInferenceProfileCommand: ZG0,
      CreateMarketplaceModelEndpointCommand: DG0,
      CreateModelCopyJobCommand: YG0,
      CreateModelCustomizationJobCommand: WG0,
      CreateModelImportJobCommand: JG0,
      CreateModelInvocationJobCommand: FG0,
      CreatePromptRouterCommand: XG0,
      CreateProvisionedModelThroughputCommand: VG0,
      DeleteCustomModelCommand: CG0,
      DeleteGuardrailCommand: KG0,
      DeleteImportedModelCommand: HG0,
      DeleteInferenceProfileCommand: zG0,
      DeleteMarketplaceModelEndpointCommand: wG0,
      DeleteModelInvocationLoggingConfigurationCommand: EG0,
      DeletePromptRouterCommand: UG0,
      DeleteProvisionedModelThroughputCommand: NG0,
      DeregisterMarketplaceModelEndpointCommand: $G0,
      GetCustomModelCommand: qG0,
      GetEvaluationJobCommand: MG0,
      GetFoundationModelCommand: LG0,
      GetGuardrailCommand: RG0,
      GetImportedModelCommand: OG0,
      GetInferenceProfileCommand: TG0,
      GetMarketplaceModelEndpointCommand: PG0,
      GetModelCopyJobCommand: SG0,
      GetModelCustomizationJobCommand: _G0,
      GetModelImportJobCommand: jG0,
      GetModelInvocationJobCommand: yG0,
      GetModelInvocationLoggingConfigurationCommand: kG0,
      GetPromptRouterCommand: xG0,
      GetProvisionedModelThroughputCommand: fG0,
      ListCustomModelsCommand: Lf1,
      ListEvaluationJobsCommand: Rf1,
      ListFoundationModelsCommand: vG0,
      ListGuardrailsCommand: Of1,
      ListImportedModelsCommand: Tf1,
      ListInferenceProfilesCommand: Pf1,
      ListMarketplaceModelEndpointsCommand: Sf1,
      ListModelCopyJobsCommand: _f1,
      ListModelCustomizationJobsCommand: jf1,
      ListModelImportJobsCommand: yf1,
      ListModelInvocationJobsCommand: kf1,
      ListPromptRoutersCommand: xf1,
      ListProvisionedModelThroughputsCommand: ff1,
      ListTagsForResourceCommand: bG0,
      PutModelInvocationLoggingConfigurationCommand: gG0,
      RegisterMarketplaceModelEndpointCommand: hG0,
      StopEvaluationJobCommand: mG0,
      StopModelCustomizationJobCommand: dG0,
      StopModelInvocationJobCommand: uG0,
      TagResourceCommand: pG0,
      UntagResourceCommand: cG0,
      UpdateGuardrailCommand: lG0,
      UpdateMarketplaceModelEndpointCommand: iG0,
      UpdateProvisionedModelThroughputCommand: nG0
    },
    aG0 = class extends hY {
      static {
        u(this, "Bedrock")
      }
    };
  j.createAggregatedClient(gx4, aG0);
  var hx4 = C2.createPaginator(hY, Lf1, "nextToken", "nextToken", "maxResults"),
    mx4 = C2.createPaginator(hY, Rf1, "nextToken", "nextToken", "maxResults"),
    dx4 = C2.createPaginator(hY, Of1, "nextToken", "nextToken", "maxResults"),
    ux4 = C2.createPaginator(hY, Tf1, "nextToken", "nextToken", "maxResults"),
    px4 = C2.createPaginator(hY, Pf1, "nextToken", "nextToken", "maxResults"),
    cx4 = C2.createPaginator(hY, Sf1, "nextToken", "nextToken", "maxResults"),
    lx4 = C2.createPaginator(hY, _f1, "nextToken", "nextToken", "maxResults"),
    ix4 = C2.createPaginator(hY, jf1, "nextToken", "nextToken", "maxResults"),
    nx4 = C2.createPaginator(hY, yf1, "nextToken", "nextToken", "maxResults"),
    ax4 = C2.createPaginator(hY, kf1, "nextToken", "nextToken", "maxResults"),
    sx4 = C2.createPaginator(hY, xf1, "nextToken", "nextToken", "maxResults"),
    rx4 = C2.createPaginator(hY, ff1, "nextToken", "nextToken", "maxResults")
})
// @from(Start 4024177, End 4025992)
SZ0 = z((OW8, PZ0) => {
  var TZ0 = Z1("child_process"),
    LZ0 = TZ0.spawn,
    Ef4 = TZ0.exec;
  PZ0.exports = function(A, B, Q) {
    if (typeof B === "function" && Q === void 0) Q = B, B = void 0;
    if (A = parseInt(A), Number.isNaN(A))
      if (Q) return Q(new Error("pid must be a number"));
      else throw new Error("pid must be a number");
    var I = {},
      G = {};
    switch (I[A] = [], G[A] = 1, process.platform) {
      case "win32":
        Ef4("taskkill /pid " + A + " /T /F", Q);
        break;
      case "darwin":
        if1(A, I, G, function(Z) {
          return LZ0("pgrep", ["-P", Z])
        }, function() {
          RZ0(I, B, Q)
        });
        break;
      default:
        if1(A, I, G, function(Z) {
          return LZ0("ps", ["-o", "pid", "--no-headers", "--ppid", Z])
        }, function() {
          RZ0(I, B, Q)
        });
        break
    }
  };

  function RZ0(A, B, Q) {
    var I = {};
    try {
      Object.keys(A).forEach(function(G) {
        if (A[G].forEach(function(Z) {
            if (!I[Z]) OZ0(Z, B), I[Z] = 1
          }), !I[G]) OZ0(G, B), I[G] = 1
      })
    } catch (G) {
      if (Q) return Q(G);
      else throw G
    }
    if (Q) return Q()
  }

  function OZ0(A, B) {
    try {
      process.kill(parseInt(A, 10), B)
    } catch (Q) {
      if (Q.code !== "ESRCH") throw Q
    }
  }

  function if1(A, B, Q, I, G) {
    var Z = I(A),
      D = "";
    Z.stdout.on("data", function(J) {
      var J = J.toString("ascii");
      D += J
    });
    var Y = function(W) {
      if (delete Q[A], W != 0) {
        if (Object.keys(Q).length == 0) G();
        return
      }
      D.match(/\d+/g).forEach(function(J) {
        J = parseInt(J, 10), B[A].push(J), B[J] = [], Q[J] = 1, if1(J, B, Q, I, G)
      })
    };
    Z.on("close", Y)
  }
})
// @from(Start 4025998, End 4028248)
UD0 = z((bJ8, ED0) => {
  var Wv4 = function A(B) {
    return Jv4(B) && !Fv4(B)
  };

  function Jv4(A) {
    return !!A && typeof A === "object"
  }

  function Fv4(A) {
    var B = Object.prototype.toString.call(A);
    return B === "[object RegExp]" || B === "[object Date]" || Cv4(A)
  }
  var Xv4 = typeof Symbol === "function" && Symbol.for,
    Vv4 = Xv4 ? Symbol.for("react.element") : 60103;

  function Cv4(A) {
    return A.$$typeof === Vv4
  }

  function Kv4(A) {
    return Array.isArray(A) ? [] : {}
  }

  function Is(A, B) {
    return B.clone !== !1 && B.isMergeableObject(A) ? $g(Kv4(A), A, B) : A
  }

  function Hv4(A, B, Q) {
    return A.concat(B).map(function(I) {
      return Is(I, Q)
    })
  }

  function zv4(A, B) {
    if (!B.customMerge) return $g;
    var Q = B.customMerge(A);
    return typeof Q === "function" ? Q : $g
  }

  function wv4(A) {
    return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(A).filter(function(B) {
      return Object.propertyIsEnumerable.call(A, B)
    }) : []
  }

  function zD0(A) {
    return Object.keys(A).concat(wv4(A))
  }

  function wD0(A, B) {
    try {
      return B in A
    } catch (Q) {
      return !1
    }
  }

  function Ev4(A, B) {
    return wD0(A, B) && !(Object.hasOwnProperty.call(A, B) && Object.propertyIsEnumerable.call(A, B))
  }

  function Uv4(A, B, Q) {
    var I = {};
    if (Q.isMergeableObject(A)) zD0(A).forEach(function(G) {
      I[G] = Is(A[G], Q)
    });
    return zD0(B).forEach(function(G) {
      if (Ev4(A, G)) return;
      if (wD0(A, G) && Q.isMergeableObject(B[G])) I[G] = zv4(G, Q)(A[G], B[G], Q);
      else I[G] = Is(B[G], Q)
    }), I
  }

  function $g(A, B, Q) {
    Q = Q || {}, Q.arrayMerge = Q.arrayMerge || Hv4, Q.isMergeableObject = Q.isMergeableObject || Wv4, Q.cloneUnlessOtherwiseSpecified = Is;
    var I = Array.isArray(B),
      G = Array.isArray(A),
      Z = I === G;
    if (!Z) return Is(B, Q);
    else if (I) return Q.arrayMerge(A, B, Q);
    else return Uv4(A, B, Q)
  }
  $g.all = function A(B, Q) {
    if (!Array.isArray(B)) throw new Error("first argument should be an array");
    return B.reduce(function(I, G) {
      return $g(I, G, Q)
    }, {})
  };
  var Nv4 = $g;
  ED0.exports = Nv4
})
// @from(Start 4028254, End 4028441)
GY0 = z((QY0) => {
  Object.defineProperty(QY0, "__esModule", {
    value: !0
  });
  QY0._globalThis = void 0;
  QY0._globalThis = typeof globalThis === "object" ? globalThis : global
})
// @from(Start 4028447, End 4029045)
ZY0 = z((M_) => {
  var Zb4 = M_ && M_.__createBinding || (Object.create ? function(A, B, Q, I) {
      if (I === void 0) I = Q;
      Object.defineProperty(A, I, {
        enumerable: !0,
        get: function() {
          return B[Q]
        }
      })
    } : function(A, B, Q, I) {
      if (I === void 0) I = Q;
      A[I] = B[Q]
    }),
    Db4 = M_ && M_.__exportStar || function(A, B) {
      for (var Q in A)
        if (Q !== "default" && !Object.prototype.hasOwnProperty.call(B, Q)) Zb4(B, A, Q)
    };
  Object.defineProperty(M_, "__esModule", {
    value: !0
  });
  Db4(GY0(), M_)
})
// @from(Start 4029051, End 4029649)
DY0 = z((L_) => {
  var Yb4 = L_ && L_.__createBinding || (Object.create ? function(A, B, Q, I) {
      if (I === void 0) I = Q;
      Object.defineProperty(A, I, {
        enumerable: !0,
        get: function() {
          return B[Q]
        }
      })
    } : function(A, B, Q, I) {
      if (I === void 0) I = Q;
      A[I] = B[Q]
    }),
    Wb4 = L_ && L_.__exportStar || function(A, B) {
      for (var Q in A)
        if (Q !== "default" && !Object.prototype.hasOwnProperty.call(B, Q)) Yb4(B, A, Q)
    };
  Object.defineProperty(L_, "__esModule", {
    value: !0
  });
  Wb4(ZY0(), L_)
})
// @from(Start 4029655, End 4029789)
Kv1 = z((YY0) => {
  Object.defineProperty(YY0, "__esModule", {
    value: !0
  });
  YY0.VERSION = void 0;
  YY0.VERSION = "1.9.0"
})
// @from(Start 4029795, End 4031030)
CY0 = z((XY0) => {
  Object.defineProperty(XY0, "__esModule", {
    value: !0
  });
  XY0.isCompatible = XY0._makeCompatibilityCheck = void 0;
  var Jb4 = Kv1(),
    JY0 = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;

  function FY0(A) {
    let B = new Set([A]),
      Q = new Set,
      I = A.match(JY0);
    if (!I) return () => !1;
    let G = {
      major: +I[1],
      minor: +I[2],
      patch: +I[3],
      prerelease: I[4]
    };
    if (G.prerelease != null) return function Y(W) {
      return W === A
    };

    function Z(Y) {
      return Q.add(Y), !1
    }

    function D(Y) {
      return B.add(Y), !0
    }
    return function Y(W) {
      if (B.has(W)) return !0;
      if (Q.has(W)) return !1;
      let J = W.match(JY0);
      if (!J) return Z(W);
      let F = {
        major: +J[1],
        minor: +J[2],
        patch: +J[3],
        prerelease: J[4]
      };
      if (F.prerelease != null) return Z(W);
      if (G.major !== F.major) return Z(W);
      if (G.major === 0) {
        if (G.minor === F.minor && G.patch <= F.patch) return D(W);
        return Z(W)
      }
      if (G.minor <= F.minor) return D(W);
      return Z(W)
    }
  }
  XY0._makeCompatibilityCheck = FY0;
  XY0.isCompatible = FY0(Jb4.VERSION)
})
// @from(Start 4031036, End 4032472)
R_ = z((KY0) => {
  Object.defineProperty(KY0, "__esModule", {
    value: !0
  });
  KY0.unregisterGlobal = KY0.getGlobal = KY0.registerGlobal = void 0;
  var Xb4 = DY0(),
    Rg = Kv1(),
    Vb4 = CY0(),
    Cb4 = Rg.VERSION.split(".")[0],
    Js = Symbol.for(`opentelemetry.js.api.${Cb4}`),
    Fs = Xb4._globalThis;

  function Kb4(A, B, Q, I = !1) {
    var G;
    let Z = Fs[Js] = (G = Fs[Js]) !== null && G !== void 0 ? G : {
      version: Rg.VERSION
    };
    if (!I && Z[A]) {
      let D = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${A}`);
      return Q.error(D.stack || D.message), !1
    }
    if (Z.version !== Rg.VERSION) {
      let D = new Error(`@opentelemetry/api: Registration of version v${Z.version} for ${A} does not match previously registered API v${Rg.VERSION}`);
      return Q.error(D.stack || D.message), !1
    }
    return Z[A] = B, Q.debug(`@opentelemetry/api: Registered a global for ${A} v${Rg.VERSION}.`), !0
  }
  KY0.registerGlobal = Kb4;

  function Hb4(A) {
    var B, Q;
    let I = (B = Fs[Js]) === null || B === void 0 ? void 0 : B.version;
    if (!I || !Vb4.isCompatible(I)) return;
    return (Q = Fs[Js]) === null || Q === void 0 ? void 0 : Q[A]
  }
  KY0.getGlobal = Hb4;

  function zb4(A, B) {
    B.debug(`@opentelemetry/api: Unregistering a global for ${A} v${Rg.VERSION}.`);
    let Q = Fs[Js];
    if (Q) delete Q[A]
  }
  KY0.unregisterGlobal = zb4
})
// @from(Start 4032478, End 4033223)
UY0 = z((wY0) => {
  Object.defineProperty(wY0, "__esModule", {
    value: !0
  });
  wY0.DiagComponentLogger = void 0;
  var Ub4 = R_();
  class zY0 {
    constructor(A) {
      this._namespace = A.namespace || "DiagComponentLogger"
    }
    debug(...A) {
      return Xs("debug", this._namespace, A)
    }
    error(...A) {
      return Xs("error", this._namespace, A)
    }
    info(...A) {
      return Xs("info", this._namespace, A)
    }
    warn(...A) {
      return Xs("warn", this._namespace, A)
    }
    verbose(...A) {
      return Xs("verbose", this._namespace, A)
    }
  }
  wY0.DiagComponentLogger = zY0;

  function Xs(A, B, Q) {
    let I = Ub4.getGlobal("diag");
    if (!I) return;
    return Q.unshift(B), I[A](...Q)
  }
})
// @from(Start 4033229, End 4033615)
uG1 = z((NY0) => {
  Object.defineProperty(NY0, "__esModule", {
    value: !0
  });
  NY0.DiagLogLevel = void 0;
  var Nb4;
  (function(A) {
    A[A.NONE = 0] = "NONE", A[A.ERROR = 30] = "ERROR", A[A.WARN = 50] = "WARN", A[A.INFO = 60] = "INFO", A[A.DEBUG = 70] = "DEBUG", A[A.VERBOSE = 80] = "VERBOSE", A[A.ALL = 9999] = "ALL"
  })(Nb4 = NY0.DiagLogLevel || (NY0.DiagLogLevel = {}))
})
// @from(Start 4033621, End 4034369)
MY0 = z(($Y0) => {
  Object.defineProperty($Y0, "__esModule", {
    value: !0
  });
  $Y0.createLogLevelDiagLogger = void 0;
  var qN = uG1();

  function $b4(A, B) {
    if (A < qN.DiagLogLevel.NONE) A = qN.DiagLogLevel.NONE;
    else if (A > qN.DiagLogLevel.ALL) A = qN.DiagLogLevel.ALL;
    B = B || {};

    function Q(I, G) {
      let Z = B[I];
      if (typeof Z === "function" && A >= G) return Z.bind(B);
      return function() {}
    }
    return {
      error: Q("error", qN.DiagLogLevel.ERROR),
      warn: Q("warn", qN.DiagLogLevel.WARN),
      info: Q("info", qN.DiagLogLevel.INFO),
      debug: Q("debug", qN.DiagLogLevel.DEBUG),
      verbose: Q("verbose", qN.DiagLogLevel.VERBOSE)
    }
  }
  $Y0.createLogLevelDiagLogger = $b4
})
// @from(Start 4034375, End 4036231)
O_ = z((RY0) => {
  Object.defineProperty(RY0, "__esModule", {
    value: !0
  });
  RY0.DiagAPI = void 0;
  var qb4 = UY0(),
    Mb4 = MY0(),
    LY0 = uG1(),
    pG1 = R_(),
    Lb4 = "diag";
  class zv1 {
    constructor() {
      function A(I) {
        return function(...G) {
          let Z = pG1.getGlobal("diag");
          if (!Z) return;
          return Z[I](...G)
        }
      }
      let B = this,
        Q = (I, G = {
          logLevel: LY0.DiagLogLevel.INFO
        }) => {
          var Z, D, Y;
          if (I === B) {
            let F = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
            return B.error((Z = F.stack) !== null && Z !== void 0 ? Z : F.message), !1
          }
          if (typeof G === "number") G = {
            logLevel: G
          };
          let W = pG1.getGlobal("diag"),
            J = Mb4.createLogLevelDiagLogger((D = G.logLevel) !== null && D !== void 0 ? D : LY0.DiagLogLevel.INFO, I);
          if (W && !G.suppressOverrideMessage) {
            let F = (Y = new Error().stack) !== null && Y !== void 0 ? Y : "<failed to generate stacktrace>";
            W.warn(`Current logger will be overwritten from ${F}`), J.warn(`Current logger will overwrite one already registered from ${F}`)
          }
          return pG1.registerGlobal("diag", J, B, !0)
        };
      B.setLogger = Q, B.disable = () => {
        pG1.unregisterGlobal(Lb4, B)
      }, B.createComponentLogger = (I) => {
        return new qb4.DiagComponentLogger(I)
      }, B.verbose = A("verbose"), B.debug = A("debug"), B.info = A("info"), B.warn = A("warn"), B.error = A("error")
    }
    static instance() {
      if (!this._instance) this._instance = new zv1;
      return this._instance
    }
  }
  RY0.DiagAPI = zv1
})
// @from(Start 4036237, End 4037053)
SY0 = z((TY0) => {
  Object.defineProperty(TY0, "__esModule", {
    value: !0
  });
  TY0.BaggageImpl = void 0;
  class Og {
    constructor(A) {
      this._entries = A ? new Map(A) : new Map
    }
    getEntry(A) {
      let B = this._entries.get(A);
      if (!B) return;
      return Object.assign({}, B)
    }
    getAllEntries() {
      return Array.from(this._entries.entries()).map(([A, B]) => [A, B])
    }
    setEntry(A, B) {
      let Q = new Og(this._entries);
      return Q._entries.set(A, B), Q
    }
    removeEntry(A) {
      let B = new Og(this._entries);
      return B._entries.delete(A), B
    }
    removeEntries(...A) {
      let B = new Og(this._entries);
      for (let Q of A) B._entries.delete(Q);
      return B
    }
    clear() {
      return new Og
    }
  }
  TY0.BaggageImpl = Og
})
// @from(Start 4037059, End 4037254)
yY0 = z((_Y0) => {
  Object.defineProperty(_Y0, "__esModule", {
    value: !0
  });
  _Y0.baggageEntryMetadataSymbol = void 0;
  _Y0.baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata")
})
// @from(Start 4037260, End 4037909)
wv1 = z((kY0) => {
  Object.defineProperty(kY0, "__esModule", {
    value: !0
  });
  kY0.baggageEntryMetadataFromString = kY0.createBaggage = void 0;
  var Rb4 = O_(),
    Ob4 = SY0(),
    Tb4 = yY0(),
    Pb4 = Rb4.DiagAPI.instance();

  function Sb4(A = {}) {
    return new Ob4.BaggageImpl(new Map(Object.entries(A)))
  }
  kY0.createBaggage = Sb4;

  function _b4(A) {
    if (typeof A !== "string") Pb4.error(`Cannot create baggage metadata from unknown type: ${typeof A}`), A = "";
    return {
      __TYPE__: Tb4.baggageEntryMetadataSymbol,
      toString() {
        return A
      }
    }
  }
  kY0.baggageEntryMetadataFromString = _b4
})
// @from(Start 4037915, End 4038571)
Vs = z((fY0) => {
  Object.defineProperty(fY0, "__esModule", {
    value: !0
  });
  fY0.ROOT_CONTEXT = fY0.createContextKey = void 0;

  function yb4(A) {
    return Symbol.for(A)
  }
  fY0.createContextKey = yb4;
  class cG1 {
    constructor(A) {
      let B = this;
      B._currentContext = A ? new Map(A) : new Map, B.getValue = (Q) => B._currentContext.get(Q), B.setValue = (Q, I) => {
        let G = new cG1(B._currentContext);
        return G._currentContext.set(Q, I), G
      }, B.deleteValue = (Q) => {
        let I = new cG1(B._currentContext);
        return I._currentContext.delete(Q), I
      }
    }
  }
  fY0.ROOT_CONTEXT = new cG1
})
// @from(Start 4038577, End 4039312)
mY0 = z((gY0) => {
  Object.defineProperty(gY0, "__esModule", {
    value: !0
  });
  gY0.DiagConsoleLogger = void 0;
  var Ev1 = [{
    n: "error",
    c: "error"
  }, {
    n: "warn",
    c: "warn"
  }, {
    n: "info",
    c: "info"
  }, {
    n: "debug",
    c: "debug"
  }, {
    n: "verbose",
    c: "trace"
  }];
  class bY0 {
    constructor() {
      function A(B) {
        return function(...Q) {
          if (console) {
            let I = console[B];
            if (typeof I !== "function") I = console.log;
            if (typeof I === "function") return I.apply(console, Q)
          }
        }
      }
      for (let B = 0; B < Ev1.length; B++) this[Ev1[B].n] = A(Ev1[B].c)
    }
  }
  gY0.DiagConsoleLogger = bY0
})
// @from(Start 4039318, End 4041733)
Tv1 = z((dY0) => {
  Object.defineProperty(dY0, "__esModule", {
    value: !0
  });
  dY0.createNoopMeter = dY0.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = dY0.NOOP_OBSERVABLE_GAUGE_METRIC = dY0.NOOP_OBSERVABLE_COUNTER_METRIC = dY0.NOOP_UP_DOWN_COUNTER_METRIC = dY0.NOOP_HISTOGRAM_METRIC = dY0.NOOP_GAUGE_METRIC = dY0.NOOP_COUNTER_METRIC = dY0.NOOP_METER = dY0.NoopObservableUpDownCounterMetric = dY0.NoopObservableGaugeMetric = dY0.NoopObservableCounterMetric = dY0.NoopObservableMetric = dY0.NoopHistogramMetric = dY0.NoopGaugeMetric = dY0.NoopUpDownCounterMetric = dY0.NoopCounterMetric = dY0.NoopMetric = dY0.NoopMeter = void 0;
  class Uv1 {
    constructor() {}
    createGauge(A, B) {
      return dY0.NOOP_GAUGE_METRIC
    }
    createHistogram(A, B) {
      return dY0.NOOP_HISTOGRAM_METRIC
    }
    createCounter(A, B) {
      return dY0.NOOP_COUNTER_METRIC
    }
    createUpDownCounter(A, B) {
      return dY0.NOOP_UP_DOWN_COUNTER_METRIC
    }
    createObservableGauge(A, B) {
      return dY0.NOOP_OBSERVABLE_GAUGE_METRIC
    }
    createObservableCounter(A, B) {
      return dY0.NOOP_OBSERVABLE_COUNTER_METRIC
    }
    createObservableUpDownCounter(A, B) {
      return dY0.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC
    }
    addBatchObservableCallback(A, B) {}
    removeBatchObservableCallback(A) {}
  }
  dY0.NoopMeter = Uv1;
  class Tg {}
  dY0.NoopMetric = Tg;
  class Nv1 extends Tg {
    add(A, B) {}
  }
  dY0.NoopCounterMetric = Nv1;
  class $v1 extends Tg {
    add(A, B) {}
  }
  dY0.NoopUpDownCounterMetric = $v1;
  class qv1 extends Tg {
    record(A, B) {}
  }
  dY0.NoopGaugeMetric = qv1;
  class Mv1 extends Tg {
    record(A, B) {}
  }
  dY0.NoopHistogramMetric = Mv1;
  class Cs {
    addCallback(A) {}
    removeCallback(A) {}
  }
  dY0.NoopObservableMetric = Cs;
  class Lv1 extends Cs {}
  dY0.NoopObservableCounterMetric = Lv1;
  class Rv1 extends Cs {}
  dY0.NoopObservableGaugeMetric = Rv1;
  class Ov1 extends Cs {}
  dY0.NoopObservableUpDownCounterMetric = Ov1;
  dY0.NOOP_METER = new Uv1;
  dY0.NOOP_COUNTER_METRIC = new Nv1;
  dY0.NOOP_GAUGE_METRIC = new qv1;
  dY0.NOOP_HISTOGRAM_METRIC = new Mv1;
  dY0.NOOP_UP_DOWN_COUNTER_METRIC = new $v1;
  dY0.NOOP_OBSERVABLE_COUNTER_METRIC = new Lv1;
  dY0.NOOP_OBSERVABLE_GAUGE_METRIC = new Rv1;
  dY0.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new Ov1;

  function xb4() {
    return dY0.NOOP_METER
  }
  dY0.createNoopMeter = xb4
})
// @from(Start 4041739, End 4041982)
tY0 = z((oY0) => {
  Object.defineProperty(oY0, "__esModule", {
    value: !0
  });
  oY0.ValueType = void 0;
  var lb4;
  (function(A) {
    A[A.INT = 0] = "INT", A[A.DOUBLE = 1] = "DOUBLE"
  })(lb4 = oY0.ValueType || (oY0.ValueType = {}))
})
// @from(Start 4041988, End 4042428)
Sv1 = z((eY0) => {
  Object.defineProperty(eY0, "__esModule", {
    value: !0
  });
  eY0.defaultTextMapSetter = eY0.defaultTextMapGetter = void 0;
  eY0.defaultTextMapGetter = {
    get(A, B) {
      if (A == null) return;
      return A[B]
    },
    keys(A) {
      if (A == null) return [];
      return Object.keys(A)
    }
  };
  eY0.defaultTextMapSetter = {
    set(A, B, Q) {
      if (A == null) return;
      A[B] = Q
    }
  }
})
// @from(Start 4042434, End 4042851)
GW0 = z((QW0) => {
  Object.defineProperty(QW0, "__esModule", {
    value: !0
  });
  QW0.NoopContextManager = void 0;
  var nb4 = Vs();
  class BW0 {
    active() {
      return nb4.ROOT_CONTEXT
    }
    with(A, B, Q, ...I) {
      return B.call(Q, ...I)
    }
    bind(A, B) {
      return B
    }
    enable() {
      return this
    }
    disable() {
      return this
    }
  }
  QW0.NoopContextManager = BW0
})
// @from(Start 4042857, End 4043778)
Ks = z((DW0) => {
  Object.defineProperty(DW0, "__esModule", {
    value: !0
  });
  DW0.ContextAPI = void 0;
  var ab4 = GW0(),
    _v1 = R_(),
    ZW0 = O_(),
    jv1 = "context",
    sb4 = new ab4.NoopContextManager;
  class yv1 {
    constructor() {}
    static getInstance() {
      if (!this._instance) this._instance = new yv1;
      return this._instance
    }
    setGlobalContextManager(A) {
      return _v1.registerGlobal(jv1, A, ZW0.DiagAPI.instance())
    }
    active() {
      return this._getContextManager().active()
    }
    with(A, B, Q, ...I) {
      return this._getContextManager().with(A, B, Q, ...I)
    }
    bind(A, B) {
      return this._getContextManager().bind(A, B)
    }
    _getContextManager() {
      return _v1.getGlobal(jv1) || sb4
    }
    disable() {
      this._getContextManager().disable(), _v1.unregisterGlobal(jv1, ZW0.DiagAPI.instance())
    }
  }
  DW0.ContextAPI = yv1
})
// @from(Start 4043784, End 4044034)
xv1 = z((WW0) => {
  Object.defineProperty(WW0, "__esModule", {
    value: !0
  });
  WW0.TraceFlags = void 0;
  var rb4;
  (function(A) {
    A[A.NONE = 0] = "NONE", A[A.SAMPLED = 1] = "SAMPLED"
  })(rb4 = WW0.TraceFlags || (WW0.TraceFlags = {}))
})
// @from(Start 4044040, End 4044465)
lG1 = z((JW0) => {
  Object.defineProperty(JW0, "__esModule", {
    value: !0
  });
  JW0.INVALID_SPAN_CONTEXT = JW0.INVALID_TRACEID = JW0.INVALID_SPANID = void 0;
  var ob4 = xv1();
  JW0.INVALID_SPANID = "0000000000000000";
  JW0.INVALID_TRACEID = "00000000000000000000000000000000";
  JW0.INVALID_SPAN_CONTEXT = {
    traceId: JW0.INVALID_TRACEID,
    spanId: JW0.INVALID_SPANID,
    traceFlags: ob4.TraceFlags.NONE
  }
})
// @from(Start 4044471, End 4045191)
iG1 = z((KW0) => {
  Object.defineProperty(KW0, "__esModule", {
    value: !0
  });
  KW0.NonRecordingSpan = void 0;
  var tb4 = lG1();
  class CW0 {
    constructor(A = tb4.INVALID_SPAN_CONTEXT) {
      this._spanContext = A
    }
    spanContext() {
      return this._spanContext
    }
    setAttribute(A, B) {
      return this
    }
    setAttributes(A) {
      return this
    }
    addEvent(A, B) {
      return this
    }
    addLink(A) {
      return this
    }
    addLinks(A) {
      return this
    }
    setStatus(A) {
      return this
    }
    updateName(A) {
      return this
    }
    end(A) {}
    isRecording() {
      return !1
    }
    recordException(A, B) {}
  }
  KW0.NonRecordingSpan = CW0
})
// @from(Start 4045197, End 4046105)
bv1 = z((wW0) => {
  Object.defineProperty(wW0, "__esModule", {
    value: !0
  });
  wW0.getSpanContext = wW0.setSpanContext = wW0.deleteSpan = wW0.setSpan = wW0.getActiveSpan = wW0.getSpan = void 0;
  var eb4 = Vs(),
    Ag4 = iG1(),
    Bg4 = Ks(),
    fv1 = eb4.createContextKey("OpenTelemetry Context Key SPAN");

  function vv1(A) {
    return A.getValue(fv1) || void 0
  }
  wW0.getSpan = vv1;

  function Qg4() {
    return vv1(Bg4.ContextAPI.getInstance().active())
  }
  wW0.getActiveSpan = Qg4;

  function zW0(A, B) {
    return A.setValue(fv1, B)
  }
  wW0.setSpan = zW0;

  function Ig4(A) {
    return A.deleteValue(fv1)
  }
  wW0.deleteSpan = Ig4;

  function Gg4(A, B) {
    return zW0(A, new Ag4.NonRecordingSpan(B))
  }
  wW0.setSpanContext = Gg4;

  function Zg4(A) {
    var B;
    return (B = vv1(A)) === null || B === void 0 ? void 0 : B.spanContext()
  }
  wW0.getSpanContext = Zg4
})
// @from(Start 4046111, End 4046791)
nG1 = z((qW0) => {
  Object.defineProperty(qW0, "__esModule", {
    value: !0
  });
  qW0.wrapSpanContext = qW0.isSpanContextValid = qW0.isValidSpanId = qW0.isValidTraceId = void 0;
  var UW0 = lG1(),
    Xg4 = iG1(),
    Vg4 = /^([0-9a-f]{32})$/i,
    Cg4 = /^[0-9a-f]{16}$/i;

  function NW0(A) {
    return Vg4.test(A) && A !== UW0.INVALID_TRACEID
  }
  qW0.isValidTraceId = NW0;

  function $W0(A) {
    return Cg4.test(A) && A !== UW0.INVALID_SPANID
  }
  qW0.isValidSpanId = $W0;

  function Kg4(A) {
    return NW0(A.traceId) && $W0(A.spanId)
  }
  qW0.isSpanContextValid = Kg4;

  function Hg4(A) {
    return new Xg4.NonRecordingSpan(A)
  }
  qW0.wrapSpanContext = Hg4
})
// @from(Start 4046797, End 4047930)
mv1 = z((OW0) => {
  Object.defineProperty(OW0, "__esModule", {
    value: !0
  });
  OW0.NoopTracer = void 0;
  var Ug4 = Ks(),
    LW0 = bv1(),
    gv1 = iG1(),
    Ng4 = nG1(),
    hv1 = Ug4.ContextAPI.getInstance();
  class RW0 {
    startSpan(A, B, Q = hv1.active()) {
      if (Boolean(B === null || B === void 0 ? void 0 : B.root)) return new gv1.NonRecordingSpan;
      let G = Q && LW0.getSpanContext(Q);
      if ($g4(G) && Ng4.isSpanContextValid(G)) return new gv1.NonRecordingSpan(G);
      else return new gv1.NonRecordingSpan
    }
    startActiveSpan(A, B, Q, I) {
      let G, Z, D;
      if (arguments.length < 2) return;
      else if (arguments.length === 2) D = B;
      else if (arguments.length === 3) G = B, D = Q;
      else G = B, Z = Q, D = I;
      let Y = Z !== null && Z !== void 0 ? Z : hv1.active(),
        W = this.startSpan(A, G, Y),
        J = LW0.setSpan(Y, W);
      return hv1.with(J, D, void 0, W)
    }
  }
  OW0.NoopTracer = RW0;

  function $g4(A) {
    return typeof A === "object" && typeof A.spanId === "string" && typeof A.traceId === "string" && typeof A.traceFlags === "number"
  }
})
// @from(Start 4047936, End 4048702)
dv1 = z((SW0) => {
  Object.defineProperty(SW0, "__esModule", {
    value: !0
  });
  SW0.ProxyTracer = void 0;
  var qg4 = mv1(),
    Mg4 = new qg4.NoopTracer;
  class PW0 {
    constructor(A, B, Q, I) {
      this._provider = A, this.name = B, this.version = Q, this.options = I
    }
    startSpan(A, B, Q) {
      return this._getTracer().startSpan(A, B, Q)
    }
    startActiveSpan(A, B, Q, I) {
      let G = this._getTracer();
      return Reflect.apply(G.startActiveSpan, G, arguments)
    }
    _getTracer() {
      if (this._delegate) return this._delegate;
      let A = this._provider.getDelegateTracer(this.name, this.version, this.options);
      if (!A) return Mg4;
      return this._delegate = A, this._delegate
    }
  }
  SW0.ProxyTracer = PW0
})
// @from(Start 4048708, End 4048960)
xW0 = z((yW0) => {
  Object.defineProperty(yW0, "__esModule", {
    value: !0
  });
  yW0.NoopTracerProvider = void 0;
  var Lg4 = mv1();
  class jW0 {
    getTracer(A, B, Q) {
      return new Lg4.NoopTracer
    }
  }
  yW0.NoopTracerProvider = jW0
})
// @from(Start 4048966, End 4049676)
uv1 = z((vW0) => {
  Object.defineProperty(vW0, "__esModule", {
    value: !0
  });
  vW0.ProxyTracerProvider = void 0;
  var Rg4 = dv1(),
    Og4 = xW0(),
    Tg4 = new Og4.NoopTracerProvider;
  class fW0 {
    getTracer(A, B, Q) {
      var I;
      return (I = this.getDelegateTracer(A, B, Q)) !== null && I !== void 0 ? I : new Rg4.ProxyTracer(this, A, B, Q)
    }
    getDelegate() {
      var A;
      return (A = this._delegate) !== null && A !== void 0 ? A : Tg4
    }
    setDelegate(A) {
      this._delegate = A
    }
    getDelegateTracer(A, B, Q) {
      var I;
      return (I = this._delegate) === null || I === void 0 ? void 0 : I.getTracer(A, B, Q)
    }
  }
  vW0.ProxyTracerProvider = fW0
})
// @from(Start 4049682, End 4050012)
hW0 = z((gW0) => {
  Object.defineProperty(gW0, "__esModule", {
    value: !0
  });
  gW0.SamplingDecision = void 0;
  var Pg4;
  (function(A) {
    A[A.NOT_RECORD = 0] = "NOT_RECORD", A[A.RECORD = 1] = "RECORD", A[A.RECORD_AND_SAMPLED = 2] = "RECORD_AND_SAMPLED"
  })(Pg4 = gW0.SamplingDecision || (gW0.SamplingDecision = {}))
})
// @from(Start 4050018, End 4050360)
dW0 = z((mW0) => {
  Object.defineProperty(mW0, "__esModule", {
    value: !0
  });
  mW0.SpanKind = void 0;
  var Sg4;
  (function(A) {
    A[A.INTERNAL = 0] = "INTERNAL", A[A.SERVER = 1] = "SERVER", A[A.CLIENT = 2] = "CLIENT", A[A.PRODUCER = 3] = "PRODUCER", A[A.CONSUMER = 4] = "CONSUMER"
  })(Sg4 = mW0.SpanKind || (mW0.SpanKind = {}))
})
// @from(Start 4050366, End 4050646)
pW0 = z((uW0) => {
  Object.defineProperty(uW0, "__esModule", {
    value: !0
  });
  uW0.SpanStatusCode = void 0;
  var _g4;
  (function(A) {
    A[A.UNSET = 0] = "UNSET", A[A.OK = 1] = "OK", A[A.ERROR = 2] = "ERROR"
  })(_g4 = uW0.SpanStatusCode || (uW0.SpanStatusCode = {}))
})
// @from(Start 4050652, End 4051157)
iW0 = z((cW0) => {
  Object.defineProperty(cW0, "__esModule", {
    value: !0
  });
  cW0.validateValue = cW0.validateKey = void 0;
  var iv1 = "[_0-9a-z-*/]",
    jg4 = `[a-z]${iv1}{0,255}`,
    yg4 = `[a-z0-9]${iv1}{0,240}@[a-z]${iv1}{0,13}`,
    kg4 = new RegExp(`^(?:${jg4}|${yg4})$`),
    xg4 = /^[ -~]{0,255}[!-~]$/,
    fg4 = /,|=/;

  function vg4(A) {
    return kg4.test(A)
  }
  cW0.validateKey = vg4;

  function bg4(A) {
    return xg4.test(A) && !fg4.test(A)
  }
  cW0.validateValue = bg4
})
// @from(Start 4051163, End 4052676)
eW0 = z((oW0) => {
  Object.defineProperty(oW0, "__esModule", {
    value: !0
  });
  oW0.TraceStateImpl = void 0;
  var nW0 = iW0(),
    aW0 = 32,
    hg4 = 512,
    sW0 = ",",
    rW0 = "=";
  class nv1 {
    constructor(A) {
      if (this._internalState = new Map, A) this._parse(A)
    }
    set(A, B) {
      let Q = this._clone();
      if (Q._internalState.has(A)) Q._internalState.delete(A);
      return Q._internalState.set(A, B), Q
    }
    unset(A) {
      let B = this._clone();
      return B._internalState.delete(A), B
    }
    get(A) {
      return this._internalState.get(A)
    }
    serialize() {
      return this._keys().reduce((A, B) => {
        return A.push(B + rW0 + this.get(B)), A
      }, []).join(sW0)
    }
    _parse(A) {
      if (A.length > hg4) return;
      if (this._internalState = A.split(sW0).reverse().reduce((B, Q) => {
          let I = Q.trim(),
            G = I.indexOf(rW0);
          if (G !== -1) {
            let Z = I.slice(0, G),
              D = I.slice(G + 1, Q.length);
            if (nW0.validateKey(Z) && nW0.validateValue(D)) B.set(Z, D)
          }
          return B
        }, new Map), this._internalState.size > aW0) this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, aW0))
    }
    _keys() {
      return Array.from(this._internalState.keys()).reverse()
    }
    _clone() {
      let A = new nv1;
      return A._internalState = new Map(this._internalState), A
    }
  }
  oW0.TraceStateImpl = nv1
})
// @from(Start 4052682, End 4052911)
QJ0 = z((AJ0) => {
  Object.defineProperty(AJ0, "__esModule", {
    value: !0
  });
  AJ0.createTraceState = void 0;
  var mg4 = eW0();

  function dg4(A) {
    return new mg4.TraceStateImpl(A)
  }
  AJ0.createTraceState = dg4
})
// @from(Start 4052917, End 4053090)
ZJ0 = z((IJ0) => {
  Object.defineProperty(IJ0, "__esModule", {
    value: !0
  });
  IJ0.context = void 0;
  var ug4 = Ks();
  IJ0.context = ug4.ContextAPI.getInstance()
})
// @from(Start 4053096, End 4053257)
WJ0 = z((DJ0) => {
  Object.defineProperty(DJ0, "__esModule", {
    value: !0
  });
  DJ0.diag = void 0;
  var pg4 = O_();
  DJ0.diag = pg4.DiagAPI.instance()
})
// @from(Start 4053263, End 4053571)
XJ0 = z((JJ0) => {
  Object.defineProperty(JJ0, "__esModule", {
    value: !0
  });
  JJ0.NOOP_METER_PROVIDER = JJ0.NoopMeterProvider = void 0;
  var cg4 = Tv1();
  class av1 {
    getMeter(A, B, Q) {
      return cg4.NOOP_METER
    }
  }
  JJ0.NoopMeterProvider = av1;
  JJ0.NOOP_METER_PROVIDER = new av1
})
// @from(Start 4053577, End 4054293)
HJ0 = z((CJ0) => {
  Object.defineProperty(CJ0, "__esModule", {
    value: !0
  });
  CJ0.MetricsAPI = void 0;
  var ig4 = XJ0(),
    sv1 = R_(),
    VJ0 = O_(),
    rv1 = "metrics";
  class ov1 {
    constructor() {}
    static getInstance() {
      if (!this._instance) this._instance = new ov1;
      return this._instance
    }
    setGlobalMeterProvider(A) {
      return sv1.registerGlobal(rv1, A, VJ0.DiagAPI.instance())
    }
    getMeterProvider() {
      return sv1.getGlobal(rv1) || ig4.NOOP_METER_PROVIDER
    }
    getMeter(A, B, Q) {
      return this.getMeterProvider().getMeter(A, B, Q)
    }
    disable() {
      sv1.unregisterGlobal(rv1, VJ0.DiagAPI.instance())
    }
  }
  CJ0.MetricsAPI = ov1
})
// @from(Start 4054299, End 4054473)
EJ0 = z((zJ0) => {
  Object.defineProperty(zJ0, "__esModule", {
    value: !0
  });
  zJ0.metrics = void 0;
  var ng4 = HJ0();
  zJ0.metrics = ng4.MetricsAPI.getInstance()
})
// @from(Start 4054479, End 4054753)
qJ0 = z((NJ0) => {
  Object.defineProperty(NJ0, "__esModule", {
    value: !0
  });
  NJ0.NoopTextMapPropagator = void 0;
  class UJ0 {
    inject(A, B) {}
    extract(A, B) {
      return A
    }
    fields() {
      return []
    }
  }
  NJ0.NoopTextMapPropagator = UJ0
})
// @from(Start 4054759, End 4055384)
OJ0 = z((LJ0) => {
  Object.defineProperty(LJ0, "__esModule", {
    value: !0
  });
  LJ0.deleteBaggage = LJ0.setBaggage = LJ0.getActiveBaggage = LJ0.getBaggage = void 0;
  var ag4 = Ks(),
    sg4 = Vs(),
    tv1 = sg4.createContextKey("OpenTelemetry Baggage Key");

  function MJ0(A) {
    return A.getValue(tv1) || void 0
  }
  LJ0.getBaggage = MJ0;

  function rg4() {
    return MJ0(ag4.ContextAPI.getInstance().active())
  }
  LJ0.getActiveBaggage = rg4;

  function og4(A, B) {
    return A.setValue(tv1, B)
  }
  LJ0.setBaggage = og4;

  function tg4(A) {
    return A.deleteValue(tv1)
  }
  LJ0.deleteBaggage = tg4
})
// @from(Start 4055390, End 4056607)
jJ0 = z((SJ0) => {
  Object.defineProperty(SJ0, "__esModule", {
    value: !0
  });
  SJ0.PropagationAPI = void 0;
  var ev1 = R_(),
    Qh4 = qJ0(),
    TJ0 = Sv1(),
    aG1 = OJ0(),
    Ih4 = wv1(),
    PJ0 = O_(),
    Ab1 = "propagation",
    Gh4 = new Qh4.NoopTextMapPropagator;
  class Bb1 {
    constructor() {
      this.createBaggage = Ih4.createBaggage, this.getBaggage = aG1.getBaggage, this.getActiveBaggage = aG1.getActiveBaggage, this.setBaggage = aG1.setBaggage, this.deleteBaggage = aG1.deleteBaggage
    }
    static getInstance() {
      if (!this._instance) this._instance = new Bb1;
      return this._instance
    }
    setGlobalPropagator(A) {
      return ev1.registerGlobal(Ab1, A, PJ0.DiagAPI.instance())
    }
    inject(A, B, Q = TJ0.defaultTextMapSetter) {
      return this._getGlobalPropagator().inject(A, B, Q)
    }
    extract(A, B, Q = TJ0.defaultTextMapGetter) {
      return this._getGlobalPropagator().extract(A, B, Q)
    }
    fields() {
      return this._getGlobalPropagator().fields()
    }
    disable() {
      ev1.unregisterGlobal(Ab1, PJ0.DiagAPI.instance())
    }
    _getGlobalPropagator() {
      return ev1.getGlobal(Ab1) || Gh4
    }
  }
  SJ0.PropagationAPI = Bb1
})
// @from(Start 4056613, End 4056799)
xJ0 = z((yJ0) => {
  Object.defineProperty(yJ0, "__esModule", {
    value: !0
  });
  yJ0.propagation = void 0;
  var Zh4 = jJ0();
  yJ0.propagation = Zh4.PropagationAPI.getInstance()
})
// @from(Start 4056805, End 4058071)
mJ0 = z((gJ0) => {
  Object.defineProperty(gJ0, "__esModule", {
    value: !0
  });
  gJ0.TraceAPI = void 0;
  var Qb1 = R_(),
    fJ0 = uv1(),
    vJ0 = nG1(),
    Pg = bv1(),
    bJ0 = O_(),
    Ib1 = "trace";
  class Gb1 {
    constructor() {
      this._proxyTracerProvider = new fJ0.ProxyTracerProvider, this.wrapSpanContext = vJ0.wrapSpanContext, this.isSpanContextValid = vJ0.isSpanContextValid, this.deleteSpan = Pg.deleteSpan, this.getSpan = Pg.getSpan, this.getActiveSpan = Pg.getActiveSpan, this.getSpanContext = Pg.getSpanContext, this.setSpan = Pg.setSpan, this.setSpanContext = Pg.setSpanContext
    }
    static getInstance() {
      if (!this._instance) this._instance = new Gb1;
      return this._instance
    }
    setGlobalTracerProvider(A) {
      let B = Qb1.registerGlobal(Ib1, this._proxyTracerProvider, bJ0.DiagAPI.instance());
      if (B) this._proxyTracerProvider.setDelegate(A);
      return B
    }
    getTracerProvider() {
      return Qb1.getGlobal(Ib1) || this._proxyTracerProvider
    }
    getTracer(A, B) {
      return this.getTracerProvider().getTracer(A, B)
    }
    disable() {
      Qb1.unregisterGlobal(Ib1, bJ0.DiagAPI.instance()), this._proxyTracerProvider = new fJ0.ProxyTracerProvider
    }
  }
  gJ0.TraceAPI = Gb1
})
// @from(Start 4058077, End 4058245)
pJ0 = z((dJ0) => {
  Object.defineProperty(dJ0, "__esModule", {
    value: !0
  });
  dJ0.trace = void 0;
  var Dh4 = mJ0();
  dJ0.trace = Dh4.TraceAPI.getInstance()
})
// @from(Start 4058251, End 4063033)
s9 = z((Y8) => {
  Object.defineProperty(Y8, "__esModule", {
    value: !0
  });
  Y8.trace = Y8.propagation = Y8.metrics = Y8.diag = Y8.context = Y8.INVALID_SPAN_CONTEXT = Y8.INVALID_TRACEID = Y8.INVALID_SPANID = Y8.isValidSpanId = Y8.isValidTraceId = Y8.isSpanContextValid = Y8.createTraceState = Y8.TraceFlags = Y8.SpanStatusCode = Y8.SpanKind = Y8.SamplingDecision = Y8.ProxyTracerProvider = Y8.ProxyTracer = Y8.defaultTextMapSetter = Y8.defaultTextMapGetter = Y8.ValueType = Y8.createNoopMeter = Y8.DiagLogLevel = Y8.DiagConsoleLogger = Y8.ROOT_CONTEXT = Y8.createContextKey = Y8.baggageEntryMetadataFromString = void 0;
  var Yh4 = wv1();
  Object.defineProperty(Y8, "baggageEntryMetadataFromString", {
    enumerable: !0,
    get: function() {
      return Yh4.baggageEntryMetadataFromString
    }
  });
  var cJ0 = Vs();
  Object.defineProperty(Y8, "createContextKey", {
    enumerable: !0,
    get: function() {
      return cJ0.createContextKey
    }
  });
  Object.defineProperty(Y8, "ROOT_CONTEXT", {
    enumerable: !0,
    get: function() {
      return cJ0.ROOT_CONTEXT
    }
  });
  var Wh4 = mY0();
  Object.defineProperty(Y8, "DiagConsoleLogger", {
    enumerable: !0,
    get: function() {
      return Wh4.DiagConsoleLogger
    }
  });
  var Jh4 = uG1();
  Object.defineProperty(Y8, "DiagLogLevel", {
    enumerable: !0,
    get: function() {
      return Jh4.DiagLogLevel
    }
  });
  var Fh4 = Tv1();
  Object.defineProperty(Y8, "createNoopMeter", {
    enumerable: !0,
    get: function() {
      return Fh4.createNoopMeter
    }
  });
  var Xh4 = tY0();
  Object.defineProperty(Y8, "ValueType", {
    enumerable: !0,
    get: function() {
      return Xh4.ValueType
    }
  });
  var lJ0 = Sv1();
  Object.defineProperty(Y8, "defaultTextMapGetter", {
    enumerable: !0,
    get: function() {
      return lJ0.defaultTextMapGetter
    }
  });
  Object.defineProperty(Y8, "defaultTextMapSetter", {
    enumerable: !0,
    get: function() {
      return lJ0.defaultTextMapSetter
    }
  });
  var Vh4 = dv1();
  Object.defineProperty(Y8, "ProxyTracer", {
    enumerable: !0,
    get: function() {
      return Vh4.ProxyTracer
    }
  });
  var Ch4 = uv1();
  Object.defineProperty(Y8, "ProxyTracerProvider", {
    enumerable: !0,
    get: function() {
      return Ch4.ProxyTracerProvider
    }
  });
  var Kh4 = hW0();
  Object.defineProperty(Y8, "SamplingDecision", {
    enumerable: !0,
    get: function() {
      return Kh4.SamplingDecision
    }
  });
  var Hh4 = dW0();
  Object.defineProperty(Y8, "SpanKind", {
    enumerable: !0,
    get: function() {
      return Hh4.SpanKind
    }
  });
  var zh4 = pW0();
  Object.defineProperty(Y8, "SpanStatusCode", {
    enumerable: !0,
    get: function() {
      return zh4.SpanStatusCode
    }
  });
  var wh4 = xv1();
  Object.defineProperty(Y8, "TraceFlags", {
    enumerable: !0,
    get: function() {
      return wh4.TraceFlags
    }
  });
  var Eh4 = QJ0();
  Object.defineProperty(Y8, "createTraceState", {
    enumerable: !0,
    get: function() {
      return Eh4.createTraceState
    }
  });
  var Zb1 = nG1();
  Object.defineProperty(Y8, "isSpanContextValid", {
    enumerable: !0,
    get: function() {
      return Zb1.isSpanContextValid
    }
  });
  Object.defineProperty(Y8, "isValidTraceId", {
    enumerable: !0,
    get: function() {
      return Zb1.isValidTraceId
    }
  });
  Object.defineProperty(Y8, "isValidSpanId", {
    enumerable: !0,
    get: function() {
      return Zb1.isValidSpanId
    }
  });
  var Db1 = lG1();
  Object.defineProperty(Y8, "INVALID_SPANID", {
    enumerable: !0,
    get: function() {
      return Db1.INVALID_SPANID
    }
  });
  Object.defineProperty(Y8, "INVALID_TRACEID", {
    enumerable: !0,
    get: function() {
      return Db1.INVALID_TRACEID
    }
  });
  Object.defineProperty(Y8, "INVALID_SPAN_CONTEXT", {
    enumerable: !0,
    get: function() {
      return Db1.INVALID_SPAN_CONTEXT
    }
  });
  var iJ0 = ZJ0();
  Object.defineProperty(Y8, "context", {
    enumerable: !0,
    get: function() {
      return iJ0.context
    }
  });
  var nJ0 = WJ0();
  Object.defineProperty(Y8, "diag", {
    enumerable: !0,
    get: function() {
      return nJ0.diag
    }
  });
  var aJ0 = EJ0();
  Object.defineProperty(Y8, "metrics", {
    enumerable: !0,
    get: function() {
      return aJ0.metrics
    }
  });
  var sJ0 = xJ0();
  Object.defineProperty(Y8, "propagation", {
    enumerable: !0,
    get: function() {
      return sJ0.propagation
    }
  });
  var rJ0 = pJ0();
  Object.defineProperty(Y8, "trace", {
    enumerable: !0,
    get: function() {
      return rJ0.trace
    }
  });
  Y8.default = {
    context: iJ0.context,
    diag: nJ0.diag,
    metrics: aJ0.metrics,
    propagation: sJ0.propagation,
    trace: rJ0.trace
  }
})
// @from(Start 4063039, End 4063944)
tJ0 = z((oJ0) => {
  Object.defineProperty(oJ0, "__esModule", {
    value: !0
  });
  oJ0.SeverityNumber = void 0;
  var $h4;
  (function(A) {
    A[A.UNSPECIFIED = 0] = "UNSPECIFIED", A[A.TRACE = 1] = "TRACE", A[A.TRACE2 = 2] = "TRACE2", A[A.TRACE3 = 3] = "TRACE3", A[A.TRACE4 = 4] = "TRACE4", A[A.DEBUG = 5] = "DEBUG", A[A.DEBUG2 = 6] = "DEBUG2", A[A.DEBUG3 = 7] = "DEBUG3", A[A.DEBUG4 = 8] = "DEBUG4", A[A.INFO = 9] = "INFO", A[A.INFO2 = 10] = "INFO2", A[A.INFO3 = 11] = "INFO3", A[A.INFO4 = 12] = "INFO4", A[A.WARN = 13] = "WARN", A[A.WARN2 = 14] = "WARN2", A[A.WARN3 = 15] = "WARN3", A[A.WARN4 = 16] = "WARN4", A[A.ERROR = 17] = "ERROR", A[A.ERROR2 = 18] = "ERROR2", A[A.ERROR3 = 19] = "ERROR3", A[A.ERROR4 = 20] = "ERROR4", A[A.FATAL = 21] = "FATAL", A[A.FATAL2 = 22] = "FATAL2", A[A.FATAL3 = 23] = "FATAL3", A[A.FATAL4 = 24] = "FATAL4"
  })($h4 = oJ0.SeverityNumber || (oJ0.SeverityNumber = {}))
})
// @from(Start 4063950, End 4064166)
sG1 = z((eJ0) => {
  Object.defineProperty(eJ0, "__esModule", {
    value: !0
  });
  eJ0.NOOP_LOGGER = eJ0.NoopLogger = void 0;
  class Wb1 {
    emit(A) {}
  }
  eJ0.NoopLogger = Wb1;
  eJ0.NOOP_LOGGER = new Wb1
})
// @from(Start 4064172, End 4064489)
rG1 = z((BF0) => {
  Object.defineProperty(BF0, "__esModule", {
    value: !0
  });
  BF0.NOOP_LOGGER_PROVIDER = BF0.NoopLoggerProvider = void 0;
  var Mh4 = sG1();
  class Jb1 {
    getLogger(A, B, Q) {
      return new Mh4.NoopLogger
    }
  }
  BF0.NoopLoggerProvider = Jb1;
  BF0.NOOP_LOGGER_PROVIDER = new Jb1
})
// @from(Start 4064495, End 4065081)
Fb1 = z((GF0) => {
  Object.defineProperty(GF0, "__esModule", {
    value: !0
  });
  GF0.ProxyLogger = void 0;
  var Rh4 = sG1();
  class IF0 {
    constructor(A, B, Q, I) {
      this._provider = A, this.name = B, this.version = Q, this.options = I
    }
    emit(A) {
      this._getLogger().emit(A)
    }
    _getLogger() {
      if (this._delegate) return this._delegate;
      let A = this._provider.getDelegateLogger(this.name, this.version, this.options);
      if (!A) return Rh4.NOOP_LOGGER;
      return this._delegate = A, this._delegate
    }
  }
  GF0.ProxyLogger = IF0
})
// @from(Start 4065087, End 4065780)
Xb1 = z((YF0) => {
  Object.defineProperty(YF0, "__esModule", {
    value: !0
  });
  YF0.ProxyLoggerProvider = void 0;
  var Oh4 = rG1(),
    Th4 = Fb1();
  class DF0 {
    getLogger(A, B, Q) {
      var I;
      return (I = this.getDelegateLogger(A, B, Q)) !== null && I !== void 0 ? I : new Th4.ProxyLogger(this, A, B, Q)
    }
    getDelegate() {
      var A;
      return (A = this._delegate) !== null && A !== void 0 ? A : Oh4.NOOP_LOGGER_PROVIDER
    }
    setDelegate(A) {
      this._delegate = A
    }
    getDelegateLogger(A, B, Q) {
      var I;
      return (I = this._delegate) === null || I === void 0 ? void 0 : I.getLogger(A, B, Q)
    }
  }
  YF0.ProxyLoggerProvider = DF0
})
// @from(Start 4065786, End 4065973)
XF0 = z((JF0) => {
  Object.defineProperty(JF0, "__esModule", {
    value: !0
  });
  JF0._globalThis = void 0;
  JF0._globalThis = typeof globalThis === "object" ? globalThis : global
})
// @from(Start 4065979, End 4066240)
VF0 = z((Vb1) => {
  Object.defineProperty(Vb1, "__esModule", {
    value: !0
  });
  Vb1._globalThis = void 0;
  var Ph4 = XF0();
  Object.defineProperty(Vb1, "_globalThis", {
    enumerable: !0,
    get: function() {
      return Ph4._globalThis
    }
  })
})
// @from(Start 4066246, End 4066507)
CF0 = z((Cb1) => {
  Object.defineProperty(Cb1, "__esModule", {
    value: !0
  });
  Cb1._globalThis = void 0;
  var _h4 = VF0();
  Object.defineProperty(Cb1, "_globalThis", {
    enumerable: !0,
    get: function() {
      return _h4._globalThis
    }
  })
})
// @from(Start 4066513, End 4066967)
zF0 = z((KF0) => {
  Object.defineProperty(KF0, "__esModule", {
    value: !0
  });
  KF0.API_BACKWARDS_COMPATIBILITY_VERSION = KF0.makeGetter = KF0._global = KF0.GLOBAL_LOGS_API_KEY = void 0;
  var yh4 = CF0();
  KF0.GLOBAL_LOGS_API_KEY = Symbol.for("io.opentelemetry.js.api.logs");
  KF0._global = yh4._globalThis;

  function kh4(A, B, Q) {
    return (I) => I === A ? B : Q
  }
  KF0.makeGetter = kh4;
  KF0.API_BACKWARDS_COMPATIBILITY_VERSION = 1
})
// @from(Start 4066973, End 4068146)
NF0 = z((EF0) => {
  Object.defineProperty(EF0, "__esModule", {
    value: !0
  });
  EF0.LogsAPI = void 0;
  var $X = zF0(),
    bh4 = rG1(),
    wF0 = Xb1();
  class Kb1 {
    constructor() {
      this._proxyLoggerProvider = new wF0.ProxyLoggerProvider
    }
    static getInstance() {
      if (!this._instance) this._instance = new Kb1;
      return this._instance
    }
    setGlobalLoggerProvider(A) {
      if ($X._global[$X.GLOBAL_LOGS_API_KEY]) return this.getLoggerProvider();
      return $X._global[$X.GLOBAL_LOGS_API_KEY] = $X.makeGetter($X.API_BACKWARDS_COMPATIBILITY_VERSION, A, bh4.NOOP_LOGGER_PROVIDER), this._proxyLoggerProvider.setDelegate(A), A
    }
    getLoggerProvider() {
      var A, B;
      return (B = (A = $X._global[$X.GLOBAL_LOGS_API_KEY]) === null || A === void 0 ? void 0 : A.call($X._global, $X.API_BACKWARDS_COMPATIBILITY_VERSION)) !== null && B !== void 0 ? B : this._proxyLoggerProvider
    }
    getLogger(A, B, Q) {
      return this.getLoggerProvider().getLogger(A, B, Q)
    }
    disable() {
      delete $X._global[$X.GLOBAL_LOGS_API_KEY], this._proxyLoggerProvider = new wF0.ProxyLoggerProvider
    }
  }
  EF0.LogsAPI = Kb1
})
// @from(Start 4068152, End 4069501)
Hb1 = z((MN) => {
  Object.defineProperty(MN, "__esModule", {
    value: !0
  });
  MN.logs = MN.ProxyLoggerProvider = MN.ProxyLogger = MN.NoopLoggerProvider = MN.NOOP_LOGGER_PROVIDER = MN.NoopLogger = MN.NOOP_LOGGER = MN.SeverityNumber = void 0;
  var gh4 = tJ0();
  Object.defineProperty(MN, "SeverityNumber", {
    enumerable: !0,
    get: function() {
      return gh4.SeverityNumber
    }
  });
  var $F0 = sG1();
  Object.defineProperty(MN, "NOOP_LOGGER", {
    enumerable: !0,
    get: function() {
      return $F0.NOOP_LOGGER
    }
  });
  Object.defineProperty(MN, "NoopLogger", {
    enumerable: !0,
    get: function() {
      return $F0.NoopLogger
    }
  });
  var qF0 = rG1();
  Object.defineProperty(MN, "NOOP_LOGGER_PROVIDER", {
    enumerable: !0,
    get: function() {
      return qF0.NOOP_LOGGER_PROVIDER
    }
  });
  Object.defineProperty(MN, "NoopLoggerProvider", {
    enumerable: !0,
    get: function() {
      return qF0.NoopLoggerProvider
    }
  });
  var hh4 = Fb1();
  Object.defineProperty(MN, "ProxyLogger", {
    enumerable: !0,
    get: function() {
      return hh4.ProxyLogger
    }
  });
  var mh4 = Xb1();
  Object.defineProperty(MN, "ProxyLoggerProvider", {
    enumerable: !0,
    get: function() {
      return mh4.ProxyLoggerProvider
    }
  });
  var dh4 = NF0();
  MN.logs = dh4.LogsAPI.getInstance()
})
// @from(Start 4069507, End 4069801)
oG1 = z((LF0) => {
  Object.defineProperty(LF0, "__esModule", {
    value: !0
  });
  LF0.AggregationTemporality = void 0;
  var uh4;
  (function(A) {
    A[A.DELTA = 0] = "DELTA", A[A.CUMULATIVE = 1] = "CUMULATIVE"
  })(uh4 = LF0.AggregationTemporality || (LF0.AggregationTemporality = {}))
})
// @from(Start 4069807, End 4070519)
tL = z((OF0) => {
  Object.defineProperty(OF0, "__esModule", {
    value: !0
  });
  OF0.DataPointType = OF0.InstrumentType = void 0;
  var ph4;
  (function(A) {
    A.COUNTER = "COUNTER", A.GAUGE = "GAUGE", A.HISTOGRAM = "HISTOGRAM", A.UP_DOWN_COUNTER = "UP_DOWN_COUNTER", A.OBSERVABLE_COUNTER = "OBSERVABLE_COUNTER", A.OBSERVABLE_GAUGE = "OBSERVABLE_GAUGE", A.OBSERVABLE_UP_DOWN_COUNTER = "OBSERVABLE_UP_DOWN_COUNTER"
  })(ph4 = OF0.InstrumentType || (OF0.InstrumentType = {}));
  var ch4;
  (function(A) {
    A[A.HISTOGRAM = 0] = "HISTOGRAM", A[A.EXPONENTIAL_HISTOGRAM = 1] = "EXPONENTIAL_HISTOGRAM", A[A.GAUGE = 2] = "GAUGE", A[A.SUM = 3] = "SUM"
  })(ch4 = OF0.DataPointType || (OF0.DataPointType = {}))
})
// @from(Start 4070525, End 4072818)
gC = z((TF0) => {
  Object.defineProperty(TF0, "__esModule", {
    value: !0
  });
  TF0.equalsCaseInsensitive = TF0.binarySearchUB = TF0.setEquals = TF0.FlatMap = TF0.isPromiseAllSettledRejectionResult = TF0.PromiseAllSettled = TF0.callWithTimeout = TF0.TimeoutError = TF0.instrumentationScopeId = TF0.hashAttributes = TF0.isNotNullish = void 0;

  function lh4(A) {
    return A !== void 0 && A !== null
  }
  TF0.isNotNullish = lh4;

  function ih4(A) {
    let B = Object.keys(A);
    if (B.length === 0) return "";
    return B = B.sort(), JSON.stringify(B.map((Q) => [Q, A[Q]]))
  }
  TF0.hashAttributes = ih4;

  function nh4(A) {
    return `${A.name}:${A.version??""}:${A.schemaUrl??""}`
  }
  TF0.instrumentationScopeId = nh4;
  class tG1 extends Error {
    constructor(A) {
      super(A);
      Object.setPrototypeOf(this, tG1.prototype)
    }
  }
  TF0.TimeoutError = tG1;

  function ah4(A, B) {
    let Q, I = new Promise(function G(Z, D) {
      Q = setTimeout(function Y() {
        D(new tG1("Operation timed out."))
      }, B)
    });
    return Promise.race([A, I]).then((G) => {
      return clearTimeout(Q), G
    }, (G) => {
      throw clearTimeout(Q), G
    })
  }
  TF0.callWithTimeout = ah4;
  async function sh4(A) {
    return Promise.all(A.map(async (B) => {
      try {
        return {
          status: "fulfilled",
          value: await B
        }
      } catch (Q) {
        return {
          status: "rejected",
          reason: Q
        }
      }
    }))
  }
  TF0.PromiseAllSettled = sh4;

  function rh4(A) {
    return A.status === "rejected"
  }
  TF0.isPromiseAllSettledRejectionResult = rh4;

  function oh4(A, B) {
    let Q = [];
    return A.forEach((I) => {
      Q.push(...B(I))
    }), Q
  }
  TF0.FlatMap = oh4;

  function th4(A, B) {
    if (A.size !== B.size) return !1;
    for (let Q of A)
      if (!B.has(Q)) return !1;
    return !0
  }
  TF0.setEquals = th4;

  function eh4(A, B) {
    let Q = 0,
      I = A.length - 1,
      G = A.length;
    while (I >= Q) {
      let Z = Q + Math.trunc((I - Q) / 2);
      if (A[Z] < B) Q = Z + 1;
      else G = Z, I = Z - 1
    }
    return G
  }
  TF0.binarySearchUB = eh4;

  function Am4(A, B) {
    return A.toLowerCase() === B.toLowerCase()
  }
  TF0.equalsCaseInsensitive = Am4
})
// @from(Start 4072824, End 4073205)
Sg = z((SF0) => {
  Object.defineProperty(SF0, "__esModule", {
    value: !0
  });
  SF0.AggregatorKind = void 0;
  var Xm4;
  (function(A) {
    A[A.DROP = 0] = "DROP", A[A.SUM = 1] = "SUM", A[A.LAST_VALUE = 2] = "LAST_VALUE", A[A.HISTOGRAM = 3] = "HISTOGRAM", A[A.EXPONENTIAL_HISTOGRAM = 4] = "EXPONENTIAL_HISTOGRAM"
  })(Xm4 = SF0.AggregatorKind || (SF0.AggregatorKind = {}))
})
// @from(Start 4073211, End 4073596)
kF0 = z((jF0) => {
  Object.defineProperty(jF0, "__esModule", {
    value: !0
  });
  jF0.DropAggregator = void 0;
  var Vm4 = Sg();
  class _F0 {
    kind = Vm4.AggregatorKind.DROP;
    createAccumulation() {
      return
    }
    merge(A, B) {
      return
    }
    diff(A, B) {
      return
    }
    toMetricData(A, B, Q, I) {
      return
    }
  }
  jF0.DropAggregator = _F0
})
// @from(Start 4073602, End 4077299)
bF0 = z((fF0) => {
  Object.defineProperty(fF0, "__esModule", {
    value: !0
  });
  fF0.HistogramAggregator = fF0.HistogramAccumulation = void 0;
  var Cm4 = Sg(),
    Hs = tL(),
    Km4 = gC();

  function Hm4(A) {
    let B = A.map(() => 0);
    return B.push(0), {
      buckets: {
        boundaries: A,
        counts: B
      },
      sum: 0,
      count: 0,
      hasMinMax: !1,
      min: 1 / 0,
      max: -1 / 0
    }
  }
  class zs {
    startTime;
    _boundaries;
    _recordMinMax;
    _current;
    constructor(A, B, Q = !0, I = Hm4(B)) {
      this.startTime = A, this._boundaries = B, this._recordMinMax = Q, this._current = I
    }
    record(A) {
      if (Number.isNaN(A)) return;
      if (this._current.count += 1, this._current.sum += A, this._recordMinMax) this._current.min = Math.min(A, this._current.min), this._current.max = Math.max(A, this._current.max), this._current.hasMinMax = !0;
      let B = Km4.binarySearchUB(this._boundaries, A);
      this._current.buckets.counts[B] += 1
    }
    setStartTime(A) {
      this.startTime = A
    }
    toPointValue() {
      return this._current
    }
  }
  fF0.HistogramAccumulation = zs;
  class xF0 {
    _boundaries;
    _recordMinMax;
    kind = Cm4.AggregatorKind.HISTOGRAM;
    constructor(A, B) {
      this._boundaries = A, this._recordMinMax = B
    }
    createAccumulation(A) {
      return new zs(A, this._boundaries, this._recordMinMax)
    }
    merge(A, B) {
      let Q = A.toPointValue(),
        I = B.toPointValue(),
        G = Q.buckets.counts,
        Z = I.buckets.counts,
        D = new Array(G.length);
      for (let J = 0; J < G.length; J++) D[J] = G[J] + Z[J];
      let Y = 1 / 0,
        W = -1 / 0;
      if (this._recordMinMax) {
        if (Q.hasMinMax && I.hasMinMax) Y = Math.min(Q.min, I.min), W = Math.max(Q.max, I.max);
        else if (Q.hasMinMax) Y = Q.min, W = Q.max;
        else if (I.hasMinMax) Y = I.min, W = I.max
      }
      return new zs(A.startTime, Q.buckets.boundaries, this._recordMinMax, {
        buckets: {
          boundaries: Q.buckets.boundaries,
          counts: D
        },
        count: Q.count + I.count,
        sum: Q.sum + I.sum,
        hasMinMax: this._recordMinMax && (Q.hasMinMax || I.hasMinMax),
        min: Y,
        max: W
      })
    }
    diff(A, B) {
      let Q = A.toPointValue(),
        I = B.toPointValue(),
        G = Q.buckets.counts,
        Z = I.buckets.counts,
        D = new Array(G.length);
      for (let Y = 0; Y < G.length; Y++) D[Y] = Z[Y] - G[Y];
      return new zs(B.startTime, Q.buckets.boundaries, this._recordMinMax, {
        buckets: {
          boundaries: Q.buckets.boundaries,
          counts: D
        },
        count: I.count - Q.count,
        sum: I.sum - Q.sum,
        hasMinMax: !1,
        min: 1 / 0,
        max: -1 / 0
      })
    }
    toMetricData(A, B, Q, I) {
      return {
        descriptor: A,
        aggregationTemporality: B,
        dataPointType: Hs.DataPointType.HISTOGRAM,
        dataPoints: Q.map(([G, Z]) => {
          let D = Z.toPointValue(),
            Y = A.type === Hs.InstrumentType.GAUGE || A.type === Hs.InstrumentType.UP_DOWN_COUNTER || A.type === Hs.InstrumentType.OBSERVABLE_GAUGE || A.type === Hs.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER;
          return {
            attributes: G,
            startTime: Z.startTime,
            endTime: I,
            value: {
              min: D.hasMinMax ? D.min : void 0,
              max: D.hasMinMax ? D.max : void 0,
              sum: !Y ? D.sum : void 0,
              buckets: D.buckets,
              count: D.count
            }
          }
        })
      }
    }
  }
  fF0.HistogramAggregator = xF0
})
// @from(Start 4077305, End 4080750)
mF0 = z((gF0) => {
  Object.defineProperty(gF0, "__esModule", {
    value: !0
  });
  gF0.Buckets = void 0;
  class Ub1 {
    backing;
    indexBase;
    indexStart;
    indexEnd;
    constructor(A = new Nb1, B = 0, Q = 0, I = 0) {
      this.backing = A, this.indexBase = B, this.indexStart = Q, this.indexEnd = I
    }
    get offset() {
      return this.indexStart
    }
    get length() {
      if (this.backing.length === 0) return 0;
      if (this.indexEnd === this.indexStart && this.at(0) === 0) return 0;
      return this.indexEnd - this.indexStart + 1
    }
    counts() {
      return Array.from({
        length: this.length
      }, (A, B) => this.at(B))
    }
    at(A) {
      let B = this.indexBase - this.indexStart;
      if (A < B) A += this.backing.length;
      return A -= B, this.backing.countAt(A)
    }
    incrementBucket(A, B) {
      this.backing.increment(A, B)
    }
    decrementBucket(A, B) {
      this.backing.decrement(A, B)
    }
    trim() {
      for (let A = 0; A < this.length; A++)
        if (this.at(A) !== 0) {
          this.indexStart += A;
          break
        } else if (A === this.length - 1) {
        this.indexStart = this.indexEnd = this.indexBase = 0;
        return
      }
      for (let A = this.length - 1; A >= 0; A--)
        if (this.at(A) !== 0) {
          this.indexEnd -= this.length - A - 1;
          break
        } this._rotate()
    }
    downscale(A) {
      this._rotate();
      let B = 1 + this.indexEnd - this.indexStart,
        Q = 1 << A,
        I = 0,
        G = 0;
      for (let Z = this.indexStart; Z <= this.indexEnd;) {
        let D = Z % Q;
        if (D < 0) D += Q;
        for (let Y = D; Y < Q && I < B; Y++) this._relocateBucket(G, I), I++, Z++;
        G++
      }
      this.indexStart >>= A, this.indexEnd >>= A, this.indexBase = this.indexStart
    }
    clone() {
      return new Ub1(this.backing.clone(), this.indexBase, this.indexStart, this.indexEnd)
    }
    _rotate() {
      let A = this.indexBase - this.indexStart;
      if (A === 0) return;
      else if (A > 0) this.backing.reverse(0, this.backing.length), this.backing.reverse(0, A), this.backing.reverse(A, this.backing.length);
      else this.backing.reverse(0, this.backing.length), this.backing.reverse(0, this.backing.length + A);
      this.indexBase = this.indexStart
    }
    _relocateBucket(A, B) {
      if (A === B) return;
      this.incrementBucket(A, this.backing.emptyBucket(B))
    }
  }
  gF0.Buckets = Ub1;
  class Nb1 {
    _counts;
    constructor(A = [0]) {
      this._counts = A
    }
    get length() {
      return this._counts.length
    }
    countAt(A) {
      return this._counts[A]
    }
    growTo(A, B, Q) {
      let I = new Array(A).fill(0);
      I.splice(Q, this._counts.length - B, ...this._counts.slice(B)), I.splice(0, B, ...this._counts.slice(0, B)), this._counts = I
    }
    reverse(A, B) {
      let Q = Math.floor((A + B) / 2) - A;
      for (let I = 0; I < Q; I++) {
        let G = this._counts[A + I];
        this._counts[A + I] = this._counts[B - I - 1], this._counts[B - I - 1] = G
      }
    }
    emptyBucket(A) {
      let B = this._counts[A];
      return this._counts[A] = 0, B
    }
    increment(A, B) {
      this._counts[A] += B
    }
    decrement(A, B) {
      if (this._counts[A] >= B) this._counts[A] -= B;
      else this._counts[A] = 0
    }
    clone() {
      return new Nb1([...this._counts])
    }
  }
})
// @from(Start 4080756, End 4081570)
qb1 = z((dF0) => {
  Object.defineProperty(dF0, "__esModule", {
    value: !0
  });
  dF0.getSignificand = dF0.getNormalBase2 = dF0.MIN_VALUE = dF0.MAX_NORMAL_EXPONENT = dF0.MIN_NORMAL_EXPONENT = dF0.SIGNIFICAND_WIDTH = void 0;
  dF0.SIGNIFICAND_WIDTH = 52;
  var wm4 = 2146435072,
    Em4 = 1048575,
    $b1 = 1023;
  dF0.MIN_NORMAL_EXPONENT = -$b1 + 1;
  dF0.MAX_NORMAL_EXPONENT = $b1;
  dF0.MIN_VALUE = Math.pow(2, -1022);

  function Um4(A) {
    let B = new DataView(new ArrayBuffer(8));
    return B.setFloat64(0, A), ((B.getUint32(0) & wm4) >> 20) - $b1
  }
  dF0.getNormalBase2 = Um4;

  function Nm4(A) {
    let B = new DataView(new ArrayBuffer(8));
    B.setFloat64(0, A);
    let Q = B.getUint32(0),
      I = B.getUint32(4);
    return (Q & Em4) * Math.pow(2, 32) + I
  }
  dF0.getSignificand = Nm4
})
// @from(Start 4081576, End 4082043)
eG1 = z((pF0) => {
  Object.defineProperty(pF0, "__esModule", {
    value: !0
  });
  pF0.nextGreaterSquare = pF0.ldexp = void 0;

  function Om4(A, B) {
    if (A === 0 || A === Number.POSITIVE_INFINITY || A === Number.NEGATIVE_INFINITY || Number.isNaN(A)) return A;
    return A * Math.pow(2, B)
  }
  pF0.ldexp = Om4;

  function Tm4(A) {
    return A--, A |= A >> 1, A |= A >> 2, A |= A >> 4, A |= A >> 8, A |= A >> 16, A++, A
  }
  pF0.nextGreaterSquare = Tm4
})
// @from(Start 4082049, End 4082218)
AZ1 = z((iF0) => {
  Object.defineProperty(iF0, "__esModule", {
    value: !0
  });
  iF0.MappingError = void 0;
  class lF0 extends Error {}
  iF0.MappingError = lF0
})
// @from(Start 4082224, End 4083519)
tF0 = z((rF0) => {
  Object.defineProperty(rF0, "__esModule", {
    value: !0
  });
  rF0.ExponentMapping = void 0;
  var _g = qb1(),
    Sm4 = eG1(),
    aF0 = AZ1();
  class sF0 {
    _shift;
    constructor(A) {
      this._shift = -A
    }
    mapToIndex(A) {
      if (A < _g.MIN_VALUE) return this._minNormalLowerBoundaryIndex();
      let B = _g.getNormalBase2(A),
        Q = this._rightShift(_g.getSignificand(A) - 1, _g.SIGNIFICAND_WIDTH);
      return B + Q >> this._shift
    }
    lowerBoundary(A) {
      let B = this._minNormalLowerBoundaryIndex();
      if (A < B) throw new aF0.MappingError(`underflow: ${A} is < minimum lower boundary: ${B}`);
      let Q = this._maxNormalLowerBoundaryIndex();
      if (A > Q) throw new aF0.MappingError(`overflow: ${A} is > maximum lower boundary: ${Q}`);
      return Sm4.ldexp(1, A << this._shift)
    }
    get scale() {
      if (this._shift === 0) return 0;
      return -this._shift
    }
    _minNormalLowerBoundaryIndex() {
      let A = _g.MIN_NORMAL_EXPONENT >> this._shift;
      if (this._shift < 2) A--;
      return A
    }
    _maxNormalLowerBoundaryIndex() {
      return _g.MAX_NORMAL_EXPONENT >> this._shift
    }
    _rightShift(A, B) {
      return Math.floor(A * Math.pow(2, -B))
    }
  }
  rF0.ExponentMapping = sF0
})
// @from(Start 4083525, End 4085159)
GX0 = z((QX0) => {
  Object.defineProperty(QX0, "__esModule", {
    value: !0
  });
  QX0.LogarithmMapping = void 0;
  var jg = qb1(),
    eF0 = eG1(),
    AX0 = AZ1();
  class BX0 {
    _scale;
    _scaleFactor;
    _inverseFactor;
    constructor(A) {
      this._scale = A, this._scaleFactor = eF0.ldexp(Math.LOG2E, A), this._inverseFactor = eF0.ldexp(Math.LN2, -A)
    }
    mapToIndex(A) {
      if (A <= jg.MIN_VALUE) return this._minNormalLowerBoundaryIndex() - 1;
      if (jg.getSignificand(A) === 0) return (jg.getNormalBase2(A) << this._scale) - 1;
      let B = Math.floor(Math.log(A) * this._scaleFactor),
        Q = this._maxNormalLowerBoundaryIndex();
      if (B >= Q) return Q;
      return B
    }
    lowerBoundary(A) {
      let B = this._maxNormalLowerBoundaryIndex();
      if (A >= B) {
        if (A === B) return 2 * Math.exp((A - (1 << this._scale)) / this._scaleFactor);
        throw new AX0.MappingError(`overflow: ${A} is > maximum lower boundary: ${B}`)
      }
      let Q = this._minNormalLowerBoundaryIndex();
      if (A <= Q) {
        if (A === Q) return jg.MIN_VALUE;
        else if (A === Q - 1) return Math.exp((A + (1 << this._scale)) / this._scaleFactor) / 2;
        throw new AX0.MappingError(`overflow: ${A} is < minimum lower boundary: ${Q}`)
      }
      return Math.exp(A * this._inverseFactor)
    }
    get scale() {
      return this._scale
    }
    _minNormalLowerBoundaryIndex() {
      return jg.MIN_NORMAL_EXPONENT << this._scale
    }
    _maxNormalLowerBoundaryIndex() {
      return (jg.MAX_NORMAL_EXPONENT + 1 << this._scale) - 1
    }
  }
  QX0.LogarithmMapping = BX0
})
// @from(Start 4085165, End 4085710)
JX0 = z((YX0) => {
  Object.defineProperty(YX0, "__esModule", {
    value: !0
  });
  YX0.getMapping = void 0;
  var _m4 = tF0(),
    jm4 = GX0(),
    ym4 = AZ1(),
    ZX0 = -10,
    DX0 = 20,
    km4 = Array.from({
      length: 31
    }, (A, B) => {
      if (B > 10) return new jm4.LogarithmMapping(B - 10);
      return new _m4.ExponentMapping(B - 10)
    });

  function xm4(A) {
    if (A > DX0 || A < ZX0) throw new ym4.MappingError(`expected scale >= ${ZX0} && <= ${DX0}, got: ${A}`);
    return km4[A + 10]
  }
  YX0.getMapping = xm4
})
// @from(Start 4085716, End 4093915)
HX0 = z((CX0) => {
  Object.defineProperty(CX0, "__esModule", {
    value: !0
  });
  CX0.ExponentialHistogramAggregator = CX0.ExponentialHistogramAccumulation = void 0;
  var fm4 = Sg(),
    ws = tL(),
    vm4 = s9(),
    FX0 = mF0(),
    XX0 = JX0(),
    bm4 = eG1();
  class yg {
    low;
    high;
    static combine(A, B) {
      return new yg(Math.min(A.low, B.low), Math.max(A.high, B.high))
    }
    constructor(A, B) {
      this.low = A, this.high = B
    }
  }
  var gm4 = 20,
    hm4 = 160,
    Mb1 = 2;
  class BZ1 {
    startTime;
    _maxSize;
    _recordMinMax;
    _sum;
    _count;
    _zeroCount;
    _min;
    _max;
    _positive;
    _negative;
    _mapping;
    constructor(A = A, B = hm4, Q = !0, I = 0, G = 0, Z = 0, D = Number.POSITIVE_INFINITY, Y = Number.NEGATIVE_INFINITY, W = new FX0.Buckets, J = new FX0.Buckets, F = XX0.getMapping(gm4)) {
      if (this.startTime = A, this._maxSize = B, this._recordMinMax = Q, this._sum = I, this._count = G, this._zeroCount = Z, this._min = D, this._max = Y, this._positive = W, this._negative = J, this._mapping = F, this._maxSize < Mb1) vm4.diag.warn(`Exponential Histogram Max Size set to ${this._maxSize},                 changing to the minimum size of: ${Mb1}`), this._maxSize = Mb1
    }
    record(A) {
      this.updateByIncrement(A, 1)
    }
    setStartTime(A) {
      this.startTime = A
    }
    toPointValue() {
      return {
        hasMinMax: this._recordMinMax,
        min: this.min,
        max: this.max,
        sum: this.sum,
        positive: {
          offset: this.positive.offset,
          bucketCounts: this.positive.counts()
        },
        negative: {
          offset: this.negative.offset,
          bucketCounts: this.negative.counts()
        },
        count: this.count,
        scale: this.scale,
        zeroCount: this.zeroCount
      }
    }
    get sum() {
      return this._sum
    }
    get min() {
      return this._min
    }
    get max() {
      return this._max
    }
    get count() {
      return this._count
    }
    get zeroCount() {
      return this._zeroCount
    }
    get scale() {
      if (this._count === this._zeroCount) return 0;
      return this._mapping.scale
    }
    get positive() {
      return this._positive
    }
    get negative() {
      return this._negative
    }
    updateByIncrement(A, B) {
      if (Number.isNaN(A)) return;
      if (A > this._max) this._max = A;
      if (A < this._min) this._min = A;
      if (this._count += B, A === 0) {
        this._zeroCount += B;
        return
      }
      if (this._sum += A * B, A > 0) this._updateBuckets(this._positive, A, B);
      else this._updateBuckets(this._negative, -A, B)
    }
    merge(A) {
      if (this._count === 0) this._min = A.min, this._max = A.max;
      else if (A.count !== 0) {
        if (A.min < this.min) this._min = A.min;
        if (A.max > this.max) this._max = A.max
      }
      this.startTime = A.startTime, this._sum += A.sum, this._count += A.count, this._zeroCount += A.zeroCount;
      let B = this._minScale(A);
      this._downscale(this.scale - B), this._mergeBuckets(this.positive, A, A.positive, B), this._mergeBuckets(this.negative, A, A.negative, B)
    }
    diff(A) {
      this._min = 1 / 0, this._max = -1 / 0, this._sum -= A.sum, this._count -= A.count, this._zeroCount -= A.zeroCount;
      let B = this._minScale(A);
      this._downscale(this.scale - B), this._diffBuckets(this.positive, A, A.positive, B), this._diffBuckets(this.negative, A, A.negative, B)
    }
    clone() {
      return new BZ1(this.startTime, this._maxSize, this._recordMinMax, this._sum, this._count, this._zeroCount, this._min, this._max, this.positive.clone(), this.negative.clone(), this._mapping)
    }
    _updateBuckets(A, B, Q) {
      let I = this._mapping.mapToIndex(B),
        G = !1,
        Z = 0,
        D = 0;
      if (A.length === 0) A.indexStart = I, A.indexEnd = A.indexStart, A.indexBase = A.indexStart;
      else if (I < A.indexStart && A.indexEnd - I >= this._maxSize) G = !0, D = I, Z = A.indexEnd;
      else if (I > A.indexEnd && I - A.indexStart >= this._maxSize) G = !0, D = A.indexStart, Z = I;
      if (G) {
        let Y = this._changeScale(Z, D);
        this._downscale(Y), I = this._mapping.mapToIndex(B)
      }
      this._incrementIndexBy(A, I, Q)
    }
    _incrementIndexBy(A, B, Q) {
      if (Q === 0) return;
      if (A.length === 0) A.indexStart = A.indexEnd = A.indexBase = B;
      if (B < A.indexStart) {
        let G = A.indexEnd - B;
        if (G >= A.backing.length) this._grow(A, G + 1);
        A.indexStart = B
      } else if (B > A.indexEnd) {
        let G = B - A.indexStart;
        if (G >= A.backing.length) this._grow(A, G + 1);
        A.indexEnd = B
      }
      let I = B - A.indexBase;
      if (I < 0) I += A.backing.length;
      A.incrementBucket(I, Q)
    }
    _grow(A, B) {
      let Q = A.backing.length,
        I = A.indexBase - A.indexStart,
        G = Q - I,
        Z = bm4.nextGreaterSquare(B);
      if (Z > this._maxSize) Z = this._maxSize;
      let D = Z - I;
      A.backing.growTo(Z, G, D)
    }
    _changeScale(A, B) {
      let Q = 0;
      while (A - B >= this._maxSize) A >>= 1, B >>= 1, Q++;
      return Q
    }
    _downscale(A) {
      if (A === 0) return;
      if (A < 0) throw new Error(`impossible change of scale: ${this.scale}`);
      let B = this._mapping.scale - A;
      this._positive.downscale(A), this._negative.downscale(A), this._mapping = XX0.getMapping(B)
    }
    _minScale(A) {
      let B = Math.min(this.scale, A.scale),
        Q = yg.combine(this._highLowAtScale(this.positive, this.scale, B), this._highLowAtScale(A.positive, A.scale, B)),
        I = yg.combine(this._highLowAtScale(this.negative, this.scale, B), this._highLowAtScale(A.negative, A.scale, B));
      return Math.min(B - this._changeScale(Q.high, Q.low), B - this._changeScale(I.high, I.low))
    }
    _highLowAtScale(A, B, Q) {
      if (A.length === 0) return new yg(0, -1);
      let I = B - Q;
      return new yg(A.indexStart >> I, A.indexEnd >> I)
    }
    _mergeBuckets(A, B, Q, I) {
      let G = Q.offset,
        Z = B.scale - I;
      for (let D = 0; D < Q.length; D++) this._incrementIndexBy(A, G + D >> Z, Q.at(D))
    }
    _diffBuckets(A, B, Q, I) {
      let G = Q.offset,
        Z = B.scale - I;
      for (let D = 0; D < Q.length; D++) {
        let W = (G + D >> Z) - A.indexBase;
        if (W < 0) W += A.backing.length;
        A.decrementBucket(W, Q.at(D))
      }
      A.trim()
    }
  }
  CX0.ExponentialHistogramAccumulation = BZ1;
  class VX0 {
    _maxSize;
    _recordMinMax;
    kind = fm4.AggregatorKind.EXPONENTIAL_HISTOGRAM;
    constructor(A, B) {
      this._maxSize = A, this._recordMinMax = B
    }
    createAccumulation(A) {
      return new BZ1(A, this._maxSize, this._recordMinMax)
    }
    merge(A, B) {
      let Q = B.clone();
      return Q.merge(A), Q
    }
    diff(A, B) {
      let Q = B.clone();
      return Q.diff(A), Q
    }
    toMetricData(A, B, Q, I) {
      return {
        descriptor: A,
        aggregationTemporality: B,
        dataPointType: ws.DataPointType.EXPONENTIAL_HISTOGRAM,
        dataPoints: Q.map(([G, Z]) => {
          let D = Z.toPointValue(),
            Y = A.type === ws.InstrumentType.GAUGE || A.type === ws.InstrumentType.UP_DOWN_COUNTER || A.type === ws.InstrumentType.OBSERVABLE_GAUGE || A.type === ws.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER;
          return {
            attributes: G,
            startTime: Z.startTime,
            endTime: I,
            value: {
              min: D.hasMinMax ? D.min : void 0,
              max: D.hasMinMax ? D.max : void 0,
              sum: !Y ? D.sum : void 0,
              positive: {
                offset: D.positive.offset,
                bucketCounts: D.positive.bucketCounts
              },
              negative: {
                offset: D.negative.offset,
                bucketCounts: D.negative.bucketCounts
              },
              count: D.count,
              scale: D.scale,
              zeroCount: D.zeroCount
            }
          }
        })
      }
    }
  }
  CX0.ExponentialHistogramAggregator = VX0
})
// @from(Start 4093921, End 4094450)
Es = z((zX0) => {
  Object.defineProperty(zX0, "__esModule", {
    value: !0
  });
  zX0.isTracingSuppressed = zX0.unsuppressTracing = zX0.suppressTracing = void 0;
  var dm4 = s9(),
    Lb1 = dm4.createContextKey("OpenTelemetry SDK Context Key SUPPRESS_TRACING");

  function um4(A) {
    return A.setValue(Lb1, !0)
  }
  zX0.suppressTracing = um4;

  function pm4(A) {
    return A.deleteValue(Lb1)
  }
  zX0.unsuppressTracing = pm4;

  function cm4(A) {
    return A.getValue(Lb1) === !0
  }
  zX0.isTracingSuppressed = cm4
})
// @from(Start 4094456, End 4095056)
Rb1 = z((EX0) => {
  Object.defineProperty(EX0, "__esModule", {
    value: !0
  });
  EX0.BAGGAGE_MAX_TOTAL_LENGTH = EX0.BAGGAGE_MAX_PER_NAME_VALUE_PAIRS = EX0.BAGGAGE_MAX_NAME_VALUE_PAIRS = EX0.BAGGAGE_HEADER = EX0.BAGGAGE_ITEMS_SEPARATOR = EX0.BAGGAGE_PROPERTIES_SEPARATOR = EX0.BAGGAGE_KEY_PAIR_SEPARATOR = void 0;
  EX0.BAGGAGE_KEY_PAIR_SEPARATOR = "=";
  EX0.BAGGAGE_PROPERTIES_SEPARATOR = ";";
  EX0.BAGGAGE_ITEMS_SEPARATOR = ",";
  EX0.BAGGAGE_HEADER = "baggage";
  EX0.BAGGAGE_MAX_NAME_VALUE_PAIRS = 180;
  EX0.BAGGAGE_MAX_PER_NAME_VALUE_PAIRS = 4096;
  EX0.BAGGAGE_MAX_TOTAL_LENGTH = 8192
})
// @from(Start 4095062, End 4096678)
Ob1 = z(($X0) => {
  Object.defineProperty($X0, "__esModule", {
    value: !0
  });
  $X0.parseKeyPairsIntoRecord = $X0.parsePairKeyValue = $X0.getKeyPairs = $X0.serializeKeyPairs = void 0;
  var em4 = s9(),
    T_ = Rb1();

  function Ad4(A) {
    return A.reduce((B, Q) => {
      let I = `${B}${B!==""?T_.BAGGAGE_ITEMS_SEPARATOR:""}${Q}`;
      return I.length > T_.BAGGAGE_MAX_TOTAL_LENGTH ? B : I
    }, "")
  }
  $X0.serializeKeyPairs = Ad4;

  function Bd4(A) {
    return A.getAllEntries().map(([B, Q]) => {
      let I = `${encodeURIComponent(B)}=${encodeURIComponent(Q.value)}`;
      if (Q.metadata !== void 0) I += T_.BAGGAGE_PROPERTIES_SEPARATOR + Q.metadata.toString();
      return I
    })
  }
  $X0.getKeyPairs = Bd4;

  function NX0(A) {
    let B = A.split(T_.BAGGAGE_PROPERTIES_SEPARATOR);
    if (B.length <= 0) return;
    let Q = B.shift();
    if (!Q) return;
    let I = Q.indexOf(T_.BAGGAGE_KEY_PAIR_SEPARATOR);
    if (I <= 0) return;
    let G = decodeURIComponent(Q.substring(0, I).trim()),
      Z = decodeURIComponent(Q.substring(I + 1).trim()),
      D;
    if (B.length > 0) D = em4.baggageEntryMetadataFromString(B.join(T_.BAGGAGE_PROPERTIES_SEPARATOR));
    return {
      key: G,
      value: Z,
      metadata: D
    }
  }
  $X0.parsePairKeyValue = NX0;

  function Qd4(A) {
    if (typeof A !== "string" || A.length === 0) return {};
    return A.split(T_.BAGGAGE_ITEMS_SEPARATOR).map((B) => {
      return NX0(B)
    }).filter((B) => B !== void 0 && B.value.length > 0).reduce((B, Q) => {
      return B[Q.key] = Q.value, B
    }, {})
  }
  $X0.parseKeyPairsIntoRecord = Qd4
})
// @from(Start 4096684, End 4097999)
OX0 = z((LX0) => {
  Object.defineProperty(LX0, "__esModule", {
    value: !0
  });
  LX0.W3CBaggagePropagator = void 0;
  var Tb1 = s9(),
    Dd4 = Es(),
    P_ = Rb1(),
    Pb1 = Ob1();
  class MX0 {
    inject(A, B, Q) {
      let I = Tb1.propagation.getBaggage(A);
      if (!I || Dd4.isTracingSuppressed(A)) return;
      let G = Pb1.getKeyPairs(I).filter((D) => {
          return D.length <= P_.BAGGAGE_MAX_PER_NAME_VALUE_PAIRS
        }).slice(0, P_.BAGGAGE_MAX_NAME_VALUE_PAIRS),
        Z = Pb1.serializeKeyPairs(G);
      if (Z.length > 0) Q.set(B, P_.BAGGAGE_HEADER, Z)
    }
    extract(A, B, Q) {
      let I = Q.get(B, P_.BAGGAGE_HEADER),
        G = Array.isArray(I) ? I.join(P_.BAGGAGE_ITEMS_SEPARATOR) : I;
      if (!G) return A;
      let Z = {};
      if (G.length === 0) return A;
      if (G.split(P_.BAGGAGE_ITEMS_SEPARATOR).forEach((Y) => {
          let W = Pb1.parsePairKeyValue(Y);
          if (W) {
            let J = {
              value: W.value
            };
            if (W.metadata) J.metadata = W.metadata;
            Z[W.key] = J
          }
        }), Object.entries(Z).length === 0) return A;
      return Tb1.propagation.setBaggage(A, Tb1.propagation.createBaggage(Z))
    }
    fields() {
      return [P_.BAGGAGE_HEADER]
    }
  }
  LX0.W3CBaggagePropagator = MX0
})
// @from(Start 4098005, End 4098474)
_X0 = z((PX0) => {
  Object.defineProperty(PX0, "__esModule", {
    value: !0
  });
  PX0.AnchoredClock = void 0;
  class TX0 {
    _monotonicClock;
    _epochMillis;
    _performanceMillis;
    constructor(A, B) {
      this._monotonicClock = B, this._epochMillis = A.now(), this._performanceMillis = B.now()
    }
    now() {
      let A = this._monotonicClock.now() - this._performanceMillis;
      return this._epochMillis + A
    }
  }
  PX0.AnchoredClock = TX0
})
// @from(Start 4098480, End 4099809)
bX0 = z((fX0) => {
  Object.defineProperty(fX0, "__esModule", {
    value: !0
  });
  fX0.isAttributeValue = fX0.isAttributeKey = fX0.sanitizeAttributes = void 0;
  var jX0 = s9();

  function Yd4(A) {
    let B = {};
    if (typeof A !== "object" || A == null) return B;
    for (let [Q, I] of Object.entries(A)) {
      if (!yX0(Q)) {
        jX0.diag.warn(`Invalid attribute key: ${Q}`);
        continue
      }
      if (!kX0(I)) {
        jX0.diag.warn(`Invalid attribute value set for key: ${Q}`);
        continue
      }
      if (Array.isArray(I)) B[Q] = I.slice();
      else B[Q] = I
    }
    return B
  }
  fX0.sanitizeAttributes = Yd4;

  function yX0(A) {
    return typeof A === "string" && A.length > 0
  }
  fX0.isAttributeKey = yX0;

  function kX0(A) {
    if (A == null) return !0;
    if (Array.isArray(A)) return Wd4(A);
    return xX0(A)
  }
  fX0.isAttributeValue = kX0;

  function Wd4(A) {
    let B;
    for (let Q of A) {
      if (Q == null) continue;
      if (!B) {
        if (xX0(Q)) {
          B = typeof Q;
          continue
        }
        return !1
      }
      if (typeof Q === B) continue;
      return !1
    }
    return !0
  }

  function xX0(A) {
    switch (typeof A) {
      case "number":
      case "boolean":
      case "string":
        return !0
    }
    return !1
  }
})
// @from(Start 4099815, End 4100421)
Sb1 = z((gX0) => {
  Object.defineProperty(gX0, "__esModule", {
    value: !0
  });
  gX0.loggingErrorHandler = void 0;
  var Xd4 = s9();

  function Vd4() {
    return (A) => {
      Xd4.diag.error(Cd4(A))
    }
  }
  gX0.loggingErrorHandler = Vd4;

  function Cd4(A) {
    if (typeof A === "string") return A;
    else return JSON.stringify(Kd4(A))
  }

  function Kd4(A) {
    let B = {},
      Q = A;
    while (Q !== null) Object.getOwnPropertyNames(Q).forEach((I) => {
      if (B[I]) return;
      let G = Q[I];
      if (G) B[I] = String(G)
    }), Q = Object.getPrototypeOf(Q);
    return B
  }
})
// @from(Start 4100427, End 4100798)
pX0 = z((dX0) => {
  Object.defineProperty(dX0, "__esModule", {
    value: !0
  });
  dX0.globalErrorHandler = dX0.setGlobalErrorHandler = void 0;
  var Hd4 = Sb1(),
    mX0 = Hd4.loggingErrorHandler();

  function zd4(A) {
    mX0 = A
  }
  dX0.setGlobalErrorHandler = zd4;

  function wd4(A) {
    try {
      mX0(A)
    } catch {}
  }
  dX0.globalErrorHandler = wd4
})
// @from(Start 4100804, End 4101977)
sX0 = z((nX0) => {
  Object.defineProperty(nX0, "__esModule", {
    value: !0
  });
  nX0.getStringListFromEnv = nX0.getBooleanFromEnv = nX0.getStringFromEnv = nX0.getNumberFromEnv = void 0;
  var cX0 = s9(),
    lX0 = Z1("util");

  function Ud4(A) {
    let B = process.env[A];
    if (B == null || B.trim() === "") return;
    let Q = Number(B);
    if (isNaN(Q)) {
      cX0.diag.warn(`Unknown value ${lX0.inspect(B)} for ${A}, expected a number, using defaults`);
      return
    }
    return Q
  }
  nX0.getNumberFromEnv = Ud4;

  function iX0(A) {
    let B = process.env[A];
    if (B == null || B.trim() === "") return;
    return B
  }
  nX0.getStringFromEnv = iX0;

  function Nd4(A) {
    let B = process.env[A]?.trim().toLowerCase();
    if (B == null || B === "") return !1;
    if (B === "true") return !0;
    else if (B === "false") return !1;
    else return cX0.diag.warn(`Unknown value ${lX0.inspect(B)} for ${A}, expected 'true' or 'false', falling back to 'false' (default)`), !1
  }
  nX0.getBooleanFromEnv = Nd4;

  function $d4(A) {
    return iX0(A)?.split(",").map((B) => B.trim()).filter((B) => B !== "")
  }
  nX0.getStringListFromEnv = $d4
})
// @from(Start 4101983, End 4102170)
tX0 = z((rX0) => {
  Object.defineProperty(rX0, "__esModule", {
    value: !0
  });
  rX0._globalThis = void 0;
  rX0._globalThis = typeof globalThis === "object" ? globalThis : global
})
// @from(Start 4102176, End 4102360)
BV0 = z((eX0) => {
  Object.defineProperty(eX0, "__esModule", {
    value: !0
  });
  eX0.otperformance = void 0;
  var Rd4 = Z1("perf_hooks");
  eX0.otperformance = Rd4.performance
})
// @from(Start 4102366, End 4102500)
GV0 = z((QV0) => {
  Object.defineProperty(QV0, "__esModule", {
    value: !0
  });
  QV0.VERSION = void 0;
  QV0.VERSION = "2.0.0"
})
// @from(Start 4102506, End 4102850)
_b1 = z((ZV0) => {
  Object.defineProperty(ZV0, "__esModule", {
    value: !0
  });
  ZV0.createConstMap = void 0;

  function Od4(A) {
    let B = {},
      Q = A.length;
    for (let I = 0; I < Q; I++) {
      let G = A[I];
      if (G) B[String(G).toUpperCase().replace(/[-.]/g, "_")] = G
    }
    return B
  }
  ZV0.createConstMap = Od4
})