@mitre/hdf-mappings 3.4.0 → 3.4.2

package/dist/index.d.ts

@@ -466,6 +466,13 @@ declare function getAwsConfigNistMappingByName(ruleName: string, rev?: number):
 declare function getAwsConfigNistControlByIdentifier(identifier: string, rev?: number): string | undefined;
 /** Get the NIST control ID for an AWS Config rule by rule name. */
 declare function getAwsConfigNistControlByName(ruleName: string, rev?: number): string | undefined;
+/**
+ * Resolve NIST controls for a decorated rule name such as Security Hub's
+ * "securityhub-<canonical>-<hash>", where an exact lookup fails. Returns the
+ * split controls of the canonical rule whose name is contained in the given
+ * name; the longest such match wins. Returns [] if none match.
+ */
+declare function getAwsConfigNistControlsBySubstring(name: string, rev?: number): string[];
 /** Get all AWS Config rule source identifiers present at the given revision. */
 declare function getAllAwsConfigIdentifiers(rev?: number): string[];
 /** Get all AWS Config rule names present at the given revision. */
@@ -485,5 +492,5 @@ declare function awsConfigMappedRevisions(identifier: string, ruleName: string):
 /** Get all AWS Config to NIST mappings (all revisions). */
 declare function getAllAwsConfigMappings(): AwsConfigNistMappings;
 //#endregion
-export { type AwsConfigNistMapping, type AwsConfigNistMappings, type CCIItem, type CCIMappings, type CweNistMapping, type CweNistMappings, DEFAULT_COMPONENT_MANAGEMENT_NIST_TAGS, DEFAULT_NIST_REVISION, DEFAULT_REMEDIATION_NIST_TAGS, DEFAULT_STATIC_ANALYSIS_NIST_TAGS, type NISTDescriptions, type NessusNistMapping, type NessusNistMappings, type NiktoNistMappings, type NistCCIMappings, type OwaspNistMapping, type OwaspNistMappings, SUPPORTED_NIST_REVISIONS, type ScoutsuiteNistMapping, type ScoutsuiteNistMappings, awsConfigIdentifierExists, awsConfigMappedRevisions, awsConfigRuleNameExists, cciExists, cweExists, getAllAwsConfigIdentifiers, getAllAwsConfigMappings, getAllAwsConfigRuleNames, getAllCCIIds, getAllCweIds, getAllCweMappings, getAllNISTIds, getAllNessusMappings, getAllNessusPluginFamilies, getAllNiktoIds, getAllNiktoMappings, getAllOwaspIds, getAllOwaspMappings, getAllScoutsuiteMappings, getAllScoutsuiteRules, getAwsConfigNistControlByIdentifier, getAwsConfigNistControlByName, getAwsConfigNistMappingByIdentifier, getAwsConfigNistMappingByName, getCCIDescription, getCCINistMappings, getCurrentNistRevision, getCweName, getCweNistControl, getCweNistMapping, getNISTDescription, getNISTFamily, getNessusNistControl, getNessusPluginFamilyMappings, getNiktoNistControl, getNistCCIMappings, getOwaspName, getOwaspNistControl, getOwaspNistMapping, getScoutsuiteNistControl, getScoutsuiteNistMapping, isNistStrict, nessusPluginFamilyExists, niktoExists, nistExists, nistToCci, owaspExists, resetNistRevision, scoutsuiteRuleExists, setCurrentNistRevision, setNistStrict };
+export { type AwsConfigNistMapping, type AwsConfigNistMappings, type CCIItem, type CCIMappings, type CweNistMapping, type CweNistMappings, DEFAULT_COMPONENT_MANAGEMENT_NIST_TAGS, DEFAULT_NIST_REVISION, DEFAULT_REMEDIATION_NIST_TAGS, DEFAULT_STATIC_ANALYSIS_NIST_TAGS, type NISTDescriptions, type NessusNistMapping, type NessusNistMappings, type NiktoNistMappings, type NistCCIMappings, type OwaspNistMapping, type OwaspNistMappings, SUPPORTED_NIST_REVISIONS, type ScoutsuiteNistMapping, type ScoutsuiteNistMappings, awsConfigIdentifierExists, awsConfigMappedRevisions, awsConfigRuleNameExists, cciExists, cweExists, getAllAwsConfigIdentifiers, getAllAwsConfigMappings, getAllAwsConfigRuleNames, getAllCCIIds, getAllCweIds, getAllCweMappings, getAllNISTIds, getAllNessusMappings, getAllNessusPluginFamilies, getAllNiktoIds, getAllNiktoMappings, getAllOwaspIds, getAllOwaspMappings, getAllScoutsuiteMappings, getAllScoutsuiteRules, getAwsConfigNistControlByIdentifier, getAwsConfigNistControlByName, getAwsConfigNistControlsBySubstring, getAwsConfigNistMappingByIdentifier, getAwsConfigNistMappingByName, getCCIDescription, getCCINistMappings, getCurrentNistRevision, getCweName, getCweNistControl, getCweNistMapping, getNISTDescription, getNISTFamily, getNessusNistControl, getNessusPluginFamilyMappings, getNiktoNistControl, getNistCCIMappings, getOwaspName, getOwaspNistControl, getOwaspNistMapping, getScoutsuiteNistControl, getScoutsuiteNistMapping, isNistStrict, nessusPluginFamilyExists, niktoExists, nistExists, nistToCci, owaspExists, resetNistRevision, scoutsuiteRuleExists, setCurrentNistRevision, setNistStrict };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/cci/types.ts","../src/cci/index.ts","../src/nist/types.ts","../src/nist/index.ts","../src/owasp/types.ts","../src/owasp/index.ts","../src/cwe/types.ts","../src/cwe/index.ts","../src/nessus/types.ts","../src/nessus/index.ts","../src/nikto/types.ts","../src/nikto/index.ts","../src/scoutsuite/types.ts","../src/scoutsuite/index.ts","../src/awsconfig/types.ts","../src/awsconfig/index.ts"],"mappings":";;;;UAGiB;;EAEf;;EAEA;;;;;KAMU,cAAc,eAAe;;;;;KAM7B,kBAAkB;;;;;;;;;;;;;;;;;;iBCId,kBAAkB;;;;;;;;;;;;;iBAqBlB,mBAAmB;;;;;;;;;;;;iBAoBnB;;;;;;;;;;;;;;iBAiBA,UAAU;;;;;;;;;;;;;;iBA8BV,mBAAmB;;;;;;;;;;;;;;iBAqBnB,UAAU;;;;;;KCjId,mBAAmB;;;;;;;;;;;;;;;;cCiBlB;;cAGA;;iBAKG;;;;;iBAQA,uBAAuB;;iBAUvB;;iBAOA;;;;;;iBASA,cAAc;;;;;;;;;;;;;iBAgBd,mBAAmB;;;;;;;;;;;;iBAmBnB;;;;;;;;;;;;;;iBAiBA,WAAW;;;;;;;;;;;;;;;;iBAuBX,cAAc;;;;;;;;;;;cAgCjB;;cAGA;;cAGA;;;;;;UC3KI;EACf;EACA;EACA;EACA;EACA;;KAGU,oBAAoB;;;;;;;;;;;;;;;iBCYhB,oBAAoB,kBAAkB;;;;;;;;;;;;;iBAoBtC,oBAAoB;;;;;;;;;;;;;iBAiBpB,aAAa;;;;;;;;;;;;iBAgBb;;;;;;;;;;;;;;iBAiBA,YAAY;;;;;;;;;;;;iBAmBZ,uBAAuB;;;;;;UC7GtB;EACf;EACA;EACA;EACA;EACA;;KAGU,kBAAkB;;;;iBCiBd,kBACd,eACA,eACC;;iBAKa,kBAAkB,eAAe;;iBAKjC,WAAW,eAAe;;iBAK1B,aAAa;;iBAKb,UAAU,eAAe;;iBAKzB,qBAAqB;;;;;;UCrDpB;EACf;EACA;EACA;;KAGU,qBAAqB;;;;;;;;;iBCKjB,qBACd,sBACA;;;;;;iBAwBc,8BACd,uBACC;;;;;iBAQa;;;;;;iBAUA,yBAAyB;;;;;iBAQzB,wBAAwB;;;;;;KCjE5B,oBAAoB;;;;;;;;iBCUhB,oBAAoB;;;;;iBASpB;;;;;;iBASA,YAAY;;;;;iBASZ,uBAAuB;;;;;;UCrCtB;EACf;EACA;;KAGU,yBAAyB;;;;;;;;iBCQrB,yBAAyB,eAAe;;;;;;iBASxC,yBAAyB;;;;;iBASzB;;;;;;iBASA,qBAAqB;;;;;iBAQrB,4BAA4B;;;;;;UChD3B;EACf;EACA;EACA;EACA;;KAGU,wBAAwB;;;;iBCsBpB,oCACd,oBACA,eACC;;iBAKa,8BACd,kBACA,eACC;;iBAKa,oCACd,oBACA;;iBAMc,8BACd,kBACA;;iBAMc,2BAA2B;;iBAK3B,yBAAyB;;iBAKzB,0BAA0B,oBAAoB;;iBAK9C,wBAAwB,kBAAkB;;;;;;;;iBAW1C,yBAAyB,oBAAoB;;iBAa7C,2BAA2B"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/cci/types.ts","../src/cci/index.ts","../src/nist/types.ts","../src/nist/index.ts","../src/owasp/types.ts","../src/owasp/index.ts","../src/cwe/types.ts","../src/cwe/index.ts","../src/nessus/types.ts","../src/nessus/index.ts","../src/nikto/types.ts","../src/nikto/index.ts","../src/scoutsuite/types.ts","../src/scoutsuite/index.ts","../src/awsconfig/types.ts","../src/awsconfig/index.ts"],"mappings":";;;;UAGiB;;EAEf;;EAEA;;;;;KAMU,cAAc,eAAe;;;;;KAM7B,kBAAkB;;;;;;;;;;;;;;;;;;iBCId,kBAAkB;;;;;;;;;;;;;iBAqBlB,mBAAmB;;;;;;;;;;;;iBAoBnB;;;;;;;;;;;;;;iBAiBA,UAAU;;;;;;;;;;;;;;iBA8BV,mBAAmB;;;;;;;;;;;;;;iBAqBnB,UAAU;;;;;;KCjId,mBAAmB;;;;;;;;;;;;;;;;cCiBlB;;cAGA;;iBAKG;;;;;iBAQA,uBAAuB;;iBAUvB;;iBAOA;;;;;;iBASA,cAAc;;;;;;;;;;;;;iBAgBd,mBAAmB;;;;;;;;;;;;iBAmBnB;;;;;;;;;;;;;;iBAiBA,WAAW;;;;;;;;;;;;;;;;iBAuBX,cAAc;;;;;;;;;;;cAgCjB;;cAGA;;cAGA;;;;;;UC3KI;EACf;EACA;EACA;EACA;EACA;;KAGU,oBAAoB;;;;;;;;;;;;;;;iBCYhB,oBAAoB,kBAAkB;;;;;;;;;;;;;iBAoBtC,oBAAoB;;;;;;;;;;;;;iBAiBpB,aAAa;;;;;;;;;;;;iBAgBb;;;;;;;;;;;;;;iBAiBA,YAAY;;;;;;;;;;;;iBAmBZ,uBAAuB;;;;;;UC7GtB;EACf;EACA;EACA;EACA;EACA;;KAGU,kBAAkB;;;;iBCiBd,kBACd,eACA,eACC;;iBAKa,kBAAkB,eAAe;;iBAKjC,WAAW,eAAe;;iBAK1B,aAAa;;iBAKb,UAAU,eAAe;;iBAKzB,qBAAqB;;;;;;UCrDpB;EACf;EACA;EACA;;KAGU,qBAAqB;;;;;;;;;iBCKjB,qBACd,sBACA;;;;;;iBAwBc,8BACd,uBACC;;;;;iBAQa;;;;;;iBAUA,yBAAyB;;;;;iBAQzB,wBAAwB;;;;;;KCjE5B,oBAAoB;;;;;;;;iBCUhB,oBAAoB;;;;;iBASpB;;;;;;iBASA,YAAY;;;;;iBASZ,uBAAuB;;;;;;UCrCtB;EACf;EACA;;KAGU,yBAAyB;;;;;;;;iBCQrB,yBAAyB,eAAe;;;;;;iBASxC,yBAAyB;;;;;iBASzB;;;;;;iBASA,qBAAqB;;;;;iBAQrB,4BAA4B;;;;;;UChD3B;EACf;EACA;EACA;EACA;;KAGU,wBAAwB;;;;iBCsBpB,oCACd,oBACA,eACC;;iBAKa,8BACd,kBACA,eACC;;iBAKa,oCACd,oBACA;;iBAMc,8BACd,kBACA;;;;;;;iBAWc,oCACd,cACA;;iBAoBc,2BAA2B;;iBAK3B,yBAAyB;;iBAKzB,0BAA0B,oBAAoB;;iBAK9C,wBAAwB,kBAAkB;;;;;;;;iBAW1C,yBAAyB,oBAAoB;;iBAa7C,2BAA2B"}

package/dist/index.js

@@ -33800,7 +33800,7 @@ const mappings = [
 	{
 		"AwsConfigRuleSourceIdentifier": "IAM_PASSWORD_POLICY",
 		"AwsConfigRuleName": "iam-password-policy",
-		"NIST-ID": "AC-2(1)|AC-2(f)|AC-2(j)|IA-2|IA-5(1)(a)(d)(e)|IA-5(4)",
+		"NIST-ID": "AC-2(1)|AC-2(f)|AC-2(j)|IA-2|IA-5(1)|IA-5(a)|IA-5(d)|IA-5(e)|IA-5(4)",
 		"Rev": 4
 	},
 	{
@@ -33818,49 +33818,49 @@ const mappings = [
 	{
 		"AwsConfigRuleSourceIdentifier": "SECURITYHUB_ENABLED",
 		"AwsConfigRuleName": "securityhub-enabled",
-		"NIST-ID": "AC-2(1)|AC-2(4)|AC-2(12)(a)|AC-2(g)|AC-17(1)|AU-6(1)(3)|CA-7(a)(b)|SA-10|SI-4(2)|SI-4(4)|SI-4(5)|SI-4(16)|SI-4(a)(b)(c)",
+		"NIST-ID": "AC-2(1)|AC-2(4)|AC-2(12)|AC-2(a)|AC-2(g)|AC-17(1)|AU-6(1)|AU-6(3)|CA-7(a)|CA-7(b)|SA-10|SI-4(2)|SI-4(4)|SI-4(5)|SI-4(16)|SI-4(a)|SI-4(b)|SI-4(c)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "GUARDDUTY_ENABLED_CENTRALIZED",
 		"AwsConfigRuleName": "guardduty-enabled-centralized",
-		"NIST-ID": "AC-2(1)|AC-2(4)|AC-2(12)(a)|AC-2(g)|AC-17(1)|AU-6(1)(3)|CA-7(a)(b)|RA-5|SA-10|SI-4(1)|SI-4(2)|SI-4(4)|SI-4(5)|SI-4(16)|SI-4(a)(b)(c)",
+		"NIST-ID": "AC-2(1)|AC-2(4)|AC-2(12)|AC-2(a)|AC-2(g)|AC-17(1)|AU-6(1)|AU-6(3)|CA-7(a)|CA-7(b)|RA-5|SA-10|SI-4(1)|SI-4(2)|SI-4(4)|SI-4(5)|SI-4(16)|SI-4(a)|SI-4(b)|SI-4(c)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "CLOUD_TRAIL_CLOUD_WATCH_LOGS_ENABLED",
 		"AwsConfigRuleName": "cloud-trail-cloud-watch-logs-enabled",
-		"NIST-ID": "AC-2(4)|AC-2(g)|AU-2(a)(d)|AU-3|AU-6(1)(3)|AU-7(1)|AU-12(a)(c)|CA-7(a)(b)|SI-4(2)|SI-4(4)|SI-4(5)|SI-4(a)(b)(c)",
+		"NIST-ID": "AC-2(4)|AC-2(g)|AU-2(a)|AU-2(d)|AU-3|AU-6(1)|AU-6(3)|AU-7(1)|AU-12(a)|AU-12(c)|CA-7(a)|CA-7(b)|SI-4(2)|SI-4(4)|SI-4(5)|SI-4(a)|SI-4(b)|SI-4(c)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "CLOUD_TRAIL_ENABLED",
 		"AwsConfigRuleName": "cloudtrail-enabled",
-		"NIST-ID": "AC-2(4)|AC-2(g)|AU-2(a)(d)|AU-3|AU-12(a)(c)",
+		"NIST-ID": "AC-2(4)|AC-2(g)|AU-2(a)|AU-2(d)|AU-3|AU-12(a)|AU-12(c)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "MULTI_REGION_CLOUD_TRAIL_ENABLED",
 		"AwsConfigRuleName": "multi-region-cloudtrail-enabled",
-		"NIST-ID": "AC-2(4)|AU-2(a)(d)|AU-3|AU-12(a)(c)",
+		"NIST-ID": "AC-2(4)|AU-2(a)|AU-2(d)|AU-3|AU-12(a)|AU-12(c)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "RDS_LOGGING_ENABLED",
 		"AwsConfigRuleName": "rds-logging-enabled",
-		"NIST-ID": "AC-2(4)|AC-2(g)|AU-2(a)(d)|AU-3|AU-12(a)(c)",
+		"NIST-ID": "AC-2(4)|AC-2(g)|AU-2(a)|AU-2(d)|AU-3|AU-12(a)|AU-12(c)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "CLOUDWATCH_ALARM_ACTION_CHECK",
 		"AwsConfigRuleName": "cloudwatch-alarm-action-check",
-		"NIST-ID": "AC-2(4)|AU-6(1)(3)|AU-7(1)|CA-7(a)(b)|IR-4(1)|SI-4(2)|SI-4(4)|SI-4(5)|SI-4(a)(b)(c)",
+		"NIST-ID": "AC-2(4)|AU-6(1)|AU-6(3)|AU-7(1)|CA-7(a)|CA-7(b)|IR-4(1)|SI-4(2)|SI-4(4)|SI-4(5)|SI-4(a)|SI-4(b)|SI-4(c)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "REDSHIFT_CLUSTER_CONFIGURATION_CHECK",
 		"AwsConfigRuleName": "redshift-cluster-configuration-check",
-		"NIST-ID": "AC-2(4)|AC-2(g)|AU-2(a)(d)|AU-3|AU-12(a)(c)|SC-13|SC-28",
+		"NIST-ID": "AC-2(4)|AC-2(g)|AU-2(a)|AU-2(d)|AU-3|AU-12(a)|AU-12(c)|SC-13|SC-28",
 		"Rev": 4
 	},
 	{
@@ -33872,19 +33872,19 @@ const mappings = [
 	{
 		"AwsConfigRuleSourceIdentifier": "S3_BUCKET_LOGGING_ENABLED",
 		"AwsConfigRuleName": "s3-bucket-logging-enabled",
-		"NIST-ID": "AC-2(g)|AU-2(a)(d)|AU-3|AU-12(a)(c)",
+		"NIST-ID": "AC-2(g)|AU-2(a)|AU-2(d)|AU-3|AU-12(a)|AU-12(c)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "CLOUDTRAIL_S3_DATAEVENTS_ENABLED",
 		"AwsConfigRuleName": "cloudtrail-s3-dataevents-enabled",
-		"NIST-ID": "AC-2(g)|AU-2(a)(d)|AU-3|AU-12(a)(c)",
+		"NIST-ID": "AC-2(g)|AU-2(a)|AU-2(d)|AU-3|AU-12(a)|AU-12(c)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "ROOT_ACCOUNT_MFA_ENABLED",
 		"AwsConfigRuleName": "root-account-mfa-enabled",
-		"NIST-ID": "AC-2(j)|IA-2(1)(11)",
+		"NIST-ID": "AC-2(j)|IA-2(1)|IA-2(11)",
 		"Rev": 4
 	},
 	{
@@ -34100,25 +34100,25 @@ const mappings = [
 	{
 		"AwsConfigRuleSourceIdentifier": "API_GW_EXECUTION_LOGGING_ENABLED",
 		"AwsConfigRuleName": "api-gw-execution-logging-enabled",
-		"NIST-ID": "AU-2(a)(d)|AU-3|AU-12(a)(c)",
+		"NIST-ID": "AU-2(a)|AU-2(d)|AU-3|AU-12(a)|AU-12(c)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "ELB_LOGGING_ENABLED",
 		"AwsConfigRuleName": "elb-logging-enabled",
-		"NIST-ID": "AU-2(a)(d)|AU-3|AU-12(a)(c)",
+		"NIST-ID": "AU-2(a)|AU-2(d)|AU-3|AU-12(a)|AU-12(c)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "VPC_FLOW_LOGS_ENABLED",
 		"AwsConfigRuleName": "vpc-flow-logs-enabled",
-		"NIST-ID": "AU-2(a)(d)|AU-3|AU-12(a)(c)",
+		"NIST-ID": "AU-2(a)|AU-2(d)|AU-3|AU-12(a)|AU-12(c)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "WAFV2_LOGGING_ENABLED",
 		"AwsConfigRuleName": "wafv2-logging-enabled",
-		"NIST-ID": "AU-2(a)(d)|AU-3|AU-12(a)(c)|SC-7|SI-4(a)(b)(c)",
+		"NIST-ID": "AU-2(a)|AU-2(d)|AU-3|AU-12(a)|AU-12(c)|SC-7|SI-4(a)|SI-4(b)|SI-4(c)",
 		"Rev": 4
 	},
 	{
@@ -34148,25 +34148,25 @@ const mappings = [
 	{
 		"AwsConfigRuleSourceIdentifier": "EC2_INSTANCE_DETAILED_MONITORING_ENABLED",
 		"AwsConfigRuleName": "ec2-instance-detailed-monitoring-enabled",
-		"NIST-ID": "CA-7(a)(b)|SI-4(2)|SI-4(a)(b)(c)",
+		"NIST-ID": "CA-7(a)|CA-7(b)|SI-4(2)|SI-4(a)|SI-4(b)|SI-4(c)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "RDS_ENHANCED_MONITORING_ENABLED",
 		"AwsConfigRuleName": "rds-enhanced-monitoring-enabled",
-		"NIST-ID": "CA-7(a)(b)",
+		"NIST-ID": "CA-7(a)|CA-7(b)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "EC2_INSTANCE_MANAGED_BY_SSM",
 		"AwsConfigRuleName": "ec2-instance-managed-by-systems-manager",
-		"NIST-ID": "CM-2|CM-7(a)|CM-8(1)|CM-8(3)(a)|SA-3(a)|SA-10|SI-2(2)|SI-7(1)",
+		"NIST-ID": "CM-2|CM-7(a)|CM-8(1)|CM-8(3)|CM-8(a)|SA-3(a)|SA-10|SI-2(2)|SI-7(1)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "EC2_MANAGEDINSTANCE_ASSOCIATION_COMPLIANCE_STATUS_CHECK",
 		"AwsConfigRuleName": "ec2-managedinstance-association-compliance-status-check",
-		"NIST-ID": "CM-2|CM-7(a)|CM-8(3)(a)|SI-2(2)",
+		"NIST-ID": "CM-2|CM-7(a)|CM-8(3)|CM-8(a)|SI-2(2)",
 		"Rev": 4
 	},
 	{
@@ -34196,7 +34196,7 @@ const mappings = [
 	{
 		"AwsConfigRuleSourceIdentifier": "EC2_MANAGEDINSTANCE_PATCH_COMPLIANCE_STATUS_CHECK",
 		"AwsConfigRuleName": "ec2-managedinstance-patch-compliance-status-check",
-		"NIST-ID": "CM-8(3)(a)|SI-2(2)|SI-7(1)",
+		"NIST-ID": "CM-8(3)|CM-8(a)|SI-2(2)|SI-7(1)",
 		"Rev": 4
 	},
 	{
@@ -34274,25 +34274,25 @@ const mappings = [
 	{
 		"AwsConfigRuleSourceIdentifier": "ROOT_ACCOUNT_HARDWARE_MFA_ENABLED",
 		"AwsConfigRuleName": "root-account-hardware-mfa-enabled",
-		"NIST-ID": "IA-2(1)(11)",
+		"NIST-ID": "IA-2(1)|IA-2(11)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "MFA_ENABLED_FOR_IAM_CONSOLE_ACCESS",
 		"AwsConfigRuleName": "mfa-enabled-for-iam-console-access",
-		"NIST-ID": "IA-2(1)(2)(11)",
+		"NIST-ID": "IA-2(1)|IA-2(2)|IA-2(11)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "IAM_USER_MFA_ENABLED",
 		"AwsConfigRuleName": "iam-user-mfa-enabled",
-		"NIST-ID": "IA-2(1)(2)(11)",
+		"NIST-ID": "IA-2(1)|IA-2(2)|IA-2(11)",
 		"Rev": 4
 	},
 	{
 		"AwsConfigRuleSourceIdentifier": "GUARDDUTY_NON_ARCHIVED_FINDINGS",
 		"AwsConfigRuleName": "guardduty-non-archived-findings",
-		"NIST-ID": "IR-4(1)|IR-6(1)|IR-7(1)|RA-5|SA-10|SI-4(a)(b)(c)",
+		"NIST-ID": "IR-4(1)|IR-6(1)|IR-7(1)|RA-5|SA-10|SI-4(a)|SI-4(b)|SI-4(c)",
 		"Rev": 4
 	},
 	{
@@ -34316,7 +34316,7 @@ const mappings = [
 	{
 		"AwsConfigRuleSourceIdentifier": "ALB_WAF_ENABLED",
 		"AwsConfigRuleName": "alb-waf-enabled",
-		"NIST-ID": "SC-7|SI-4(a)(b)(c)",
+		"NIST-ID": "SC-7|SI-4(a)|SI-4(b)|SI-4(c)",
 		"Rev": 4
 	},
 	{
@@ -35216,6 +35216,24 @@ function getAwsConfigNistControlByIdentifier(identifier, rev = getCurrentNistRev
 function getAwsConfigNistControlByName(ruleName, rev = getCurrentNistRevision()) {
 	return getAwsConfigNistMappingByName(ruleName, rev)?.["NIST-ID"];
 }
+/**
+* Resolve NIST controls for a decorated rule name such as Security Hub's
+* "securityhub-<canonical>-<hash>", where an exact lookup fails. Returns the
+* split controls of the canonical rule whose name is contained in the given
+* name; the longest such match wins. Returns [] if none match.
+*/
+function getAwsConfigNistControlsBySubstring(name, rev = getCurrentNistRevision()) {
+	if (!name) return [];
+	const lower = name.toLowerCase();
+	let best;
+	let bestLen = 0;
+	for (const [key, m] of nameIndex(rev)) if (key && key.length > bestLen && lower.includes(key.toLowerCase())) {
+		best = m;
+		bestLen = key.length;
+	}
+	if (!best) return [];
+	return best["NIST-ID"].split("|").map((s) => s.trim()).filter(Boolean);
+}
 /** Get all AWS Config rule source identifiers present at the given revision. */
 function getAllAwsConfigIdentifiers(rev = getCurrentNistRevision()) {
 	return Array.from(idIndex(rev).keys());
@@ -35253,6 +35271,6 @@ function getAllAwsConfigMappings() {
 	return [...mappings];
 }
 //#endregion
-export { DEFAULT_COMPONENT_MANAGEMENT_NIST_TAGS, DEFAULT_NIST_REVISION, DEFAULT_REMEDIATION_NIST_TAGS, DEFAULT_STATIC_ANALYSIS_NIST_TAGS, SUPPORTED_NIST_REVISIONS, awsConfigIdentifierExists, awsConfigMappedRevisions, awsConfigRuleNameExists, cciExists, cweExists, getAllAwsConfigIdentifiers, getAllAwsConfigMappings, getAllAwsConfigRuleNames, getAllCCIIds, getAllCweIds, getAllCweMappings, getAllNISTIds, getAllNessusMappings, getAllNessusPluginFamilies, getAllNiktoIds, getAllNiktoMappings, getAllOwaspIds, getAllOwaspMappings, getAllScoutsuiteMappings, getAllScoutsuiteRules, getAwsConfigNistControlByIdentifier, getAwsConfigNistControlByName, getAwsConfigNistMappingByIdentifier, getAwsConfigNistMappingByName, getCCIDescription, getCCINistMappings, getCurrentNistRevision, getCweName, getCweNistControl, getCweNistMapping, getNISTDescription, getNISTFamily, getNessusNistControl, getNessusPluginFamilyMappings, getNiktoNistControl, getNistCCIMappings, getOwaspName, getOwaspNistControl, getOwaspNistMapping, getScoutsuiteNistControl, getScoutsuiteNistMapping, isNistStrict, nessusPluginFamilyExists, niktoExists, nistExists, nistToCci, owaspExists, resetNistRevision, scoutsuiteRuleExists, setCurrentNistRevision, setNistStrict };
+export { DEFAULT_COMPONENT_MANAGEMENT_NIST_TAGS, DEFAULT_NIST_REVISION, DEFAULT_REMEDIATION_NIST_TAGS, DEFAULT_STATIC_ANALYSIS_NIST_TAGS, SUPPORTED_NIST_REVISIONS, awsConfigIdentifierExists, awsConfigMappedRevisions, awsConfigRuleNameExists, cciExists, cweExists, getAllAwsConfigIdentifiers, getAllAwsConfigMappings, getAllAwsConfigRuleNames, getAllCCIIds, getAllCweIds, getAllCweMappings, getAllNISTIds, getAllNessusMappings, getAllNessusPluginFamilies, getAllNiktoIds, getAllNiktoMappings, getAllOwaspIds, getAllOwaspMappings, getAllScoutsuiteMappings, getAllScoutsuiteRules, getAwsConfigNistControlByIdentifier, getAwsConfigNistControlByName, getAwsConfigNistControlsBySubstring, getAwsConfigNistMappingByIdentifier, getAwsConfigNistMappingByName, getCCIDescription, getCCINistMappings, getCurrentNistRevision, getCweName, getCweNistControl, getCweNistMapping, getNISTDescription, getNISTFamily, getNessusNistControl, getNessusPluginFamilyMappings, getNiktoNistControl, getNistCCIMappings, getOwaspName, getOwaspNistControl, getOwaspNistMapping, getScoutsuiteNistControl, getScoutsuiteNistMapping, isNistStrict, nessusPluginFamilyExists, niktoExists, nistExists, nistToCci, owaspExists, resetNistRevision, scoutsuiteRuleExists, setCurrentNistRevision, setNistStrict };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["rawCCIData","rawNistCCIData","rawNistData","rawOwaspData","mappings","rawMappings","mappings","rawMappings","mappings","rawMappings","mappings","rawMappings","rawMappings"],"sources":["../src/data/cci-mappings.json","../src/data/nist-cci-mappings.json","../src/cci/index.ts","../src/data/nist-descriptions.json","../src/nist/index.ts","../src/data/owasp-nist-mappings.json","../src/owasp/index.ts","../src/data/cwe-nist-mappings.json","../src/cwe/index.ts","../src/data/nessus-nist-mappings.json","../src/nessus/index.ts","../src/data/nikto-nist-mappings.json","../src/nikto/index.ts","../src/data/scoutsuite-nist-mappings.json","../src/scoutsuite/index.ts","../src/data/awsconfig-mappings.json","../src/awsconfig/index.ts"],"sourcesContent":["","","/**\n * CCI (Control Correlation Identifier) mapping functions\n */\n\nimport type { CCIMappings, NistCCIMappings } from './types.js';\nimport rawCCIData from '../data/cci-mappings.json';\nimport rawNistCCIData from '../data/nist-cci-mappings.json';\n\nconst cciData = rawCCIData as CCIMappings;\nconst nistCCIData = rawNistCCIData as NistCCIMappings;\n\n/**\n * Get the definition/description for a CCI ID.\n *\n * @param cciId - The CCI ID (e.g., 'CCI-000001')\n * @returns The CCI definition, or undefined if not found\n *\n * @example\n * ```typescript\n * const def = getCCIDescription('CCI-000001');\n * // Returns: \"The organization develops an access control policy...\"\n * ```\n */\nexport function getCCIDescription(cciId: string): string | undefined {\n  if (!cciId || typeof cciId !== 'string') {\n    return undefined;\n  }\n\n  const item = cciData[cciId];\n  return item?.def;\n}\n\n/**\n * Get the NIST control mappings for a CCI ID.\n *\n * @param cciId - The CCI ID (e.g., 'CCI-000001')\n * @returns Array of NIST control references, or undefined if not found\n *\n * @example\n * ```typescript\n * const mappings = getCCINistMappings('CCI-000001');\n * // Returns: ['AC-1 a', 'AC-1.1 (i and ii)', 'AC-1 a 1']\n * ```\n */\nexport function getCCINistMappings(cciId: string): string[] | undefined {\n  if (!cciId || typeof cciId !== 'string') {\n    return undefined;\n  }\n\n  const item = cciData[cciId];\n  return item?.nist;\n}\n\n/**\n * Get all CCI IDs available in the database.\n *\n * @returns Array of all CCI IDs\n *\n * @example\n * ```typescript\n * const ids = getAllCCIIds();\n * // Returns: ['CCI-000001', 'CCI-000002', ...]\n * ```\n */\nexport function getAllCCIIds(): string[] {\n  return Object.keys(cciData);\n}\n\n/**\n * Check if a CCI ID exists in the database.\n *\n * @param cciId - The CCI ID to check\n * @returns true if the CCI exists, false otherwise\n *\n * @example\n * ```typescript\n * if (cciExists('CCI-000001')) {\n *   console.log('CCI found');\n * }\n * ```\n */\nexport function cciExists(cciId: string): boolean {\n  if (!cciId || typeof cciId !== 'string') {\n    return false;\n  }\n\n  return cciId in cciData;\n}\n\n/**\n * Extract the base NIST control identifier from a potentially qualified string.\n * For example, \"SI-10 a 1\" → \"SI-10\", \"AC-3 (2)\" → \"AC-3\".\n */\nfunction baseNistControl(control: string): string {\n  const idx = control.search(/[ (.]/);\n  return idx === -1 ? control : control.slice(0, idx);\n}\n\n/**\n * Get CCI IDs for a NIST control using the curated mapping table.\n * The input is normalized to its base control before lookup.\n *\n * @param nistControl - NIST control string (e.g., 'SI-10', 'AC-3 (2)')\n * @returns Array of CCI IDs, or undefined if not found\n *\n * @example\n * ```typescript\n * const ccis = getNistCCIMappings('SI-10');\n * // Returns: ['CCI-001310']\n * ```\n */\nexport function getNistCCIMappings(nistControl: string): string[] | undefined {\n  if (!nistControl || typeof nistControl !== 'string') {\n    return undefined;\n  }\n  const base = baseNistControl(nistControl);\n  return nistCCIData[base];\n}\n\n/**\n * Map NIST 800-53 controls to their CCI IDs using the curated mapping table.\n * Results are deduplicated and sorted.\n *\n * @param nistControls - Array of NIST control strings\n * @returns Deduplicated, sorted array of CCI IDs (empty array if no mappings found)\n *\n * @example\n * ```typescript\n * const ccis = nistToCci(['AC-3', 'SI-10']);\n * // Returns: ['CCI-000213', 'CCI-001310']\n * ```\n */\nexport function nistToCci(nistControls: string[]): string[] {\n  const seen = new Set<string>();\n  for (const control of nistControls) {\n    const ccis = getNistCCIMappings(control);\n    if (ccis) {\n      for (const cciId of ccis) {\n        seen.add(cciId);\n      }\n    }\n  }\n  return Array.from(seen).sort();\n}\n\n// Re-export types\nexport type { CCIItem, CCIMappings, NistCCIMappings } from './types.js';\n","","/**\n * NIST SP 800-53 control description functions\n */\n\nimport type { NISTDescriptions } from './types.js';\nimport rawNistData from '../data/nist-descriptions.json';\n\nconst nistData = rawNistData as NISTDescriptions;\n\n/**\n * NIST SP 800-53 revision selection.\n *\n * The revision is a module-global default that every NIST-emitting mapping\n * consults through its default lookups. Set it once at startup (the CLI's\n * `--nist-rev` flag does this) to switch the catalog all converters target.\n * For explicit, side-effect-free per-call selection, pass an explicit `rev` to\n * the mapping lookups instead of mutating this.\n */\n\n/** The revision mappings emit when nothing overrides it. */\nexport const DEFAULT_NIST_REVISION = 5;\n\n/** Revisions every NIST-emitting mapping table has rows for. */\nexport const SUPPORTED_NIST_REVISIONS: readonly number[] = [4, 5];\n\nlet currentNistRevision = DEFAULT_NIST_REVISION;\n\n/** Get the module-global default NIST revision. */\nexport function getCurrentNistRevision(): number {\n  return currentNistRevision;\n}\n\n/**\n * Set the module-global default NIST revision. Throws (without mutating state)\n * if the revision has no mapping data.\n */\nexport function setCurrentNistRevision(rev: number): void {\n  if (!SUPPORTED_NIST_REVISIONS.includes(rev)) {\n    throw new Error(\n      `unsupported NIST revision ${rev} (supported: ${SUPPORTED_NIST_REVISIONS.join(', ')})`\n    );\n  }\n  currentNistRevision = rev;\n}\n\n/** Restore the default revision. Intended for cleanup and tests. */\nexport function resetNistRevision(): void {\n  currentNistRevision = DEFAULT_NIST_REVISION;\n}\n\nlet nistStrict = false;\n\n/** Report whether strict NIST revision alignment is enabled. */\nexport function isNistStrict(): boolean {\n  return nistStrict;\n}\n\n/**\n * Toggle strict NIST revision alignment. When enabled, revision-divergent\n * mappings treat a rule mapped only at another revision as a hard error rather\n * than a silent omission.\n */\nexport function setNistStrict(strict: boolean): void {\n  nistStrict = strict;\n}\n\n/**\n * Get the description for a NIST control ID.\n *\n * @param nistId - The NIST control ID (e.g., 'AC-01', 'AC-01 a', 'AC-01 a 01')\n * @returns The NIST control description, or undefined if not found\n *\n * @example\n * ```typescript\n * const desc = getNISTDescription('AC-01');\n * // Returns: \"ACCESS CONTROL POLICY AND PROCEDURES\"\n * ```\n */\nexport function getNISTDescription(nistId: string): string | undefined {\n  if (!nistId || typeof nistId !== 'string') {\n    return undefined;\n  }\n\n  return nistData[nistId];\n}\n\n/**\n * Get all NIST control IDs available in the database.\n *\n * @returns Array of all NIST control IDs\n *\n * @example\n * ```typescript\n * const ids = getAllNISTIds();\n * // Returns: ['AC-01', 'AC-01 a', 'AC-02', ...]\n * ```\n */\nexport function getAllNISTIds(): string[] {\n  return Object.keys(nistData);\n}\n\n/**\n * Check if a NIST control ID exists in the database.\n *\n * @param nistId - The NIST control ID to check\n * @returns true if the NIST control exists, false otherwise\n *\n * @example\n * ```typescript\n * if (nistExists('AC-01')) {\n *   console.log('NIST control found');\n * }\n * ```\n */\nexport function nistExists(nistId: string): boolean {\n  if (!nistId || typeof nistId !== 'string') {\n    return false;\n  }\n\n  return nistId in nistData;\n}\n\n/**\n * Extract the NIST family from a NIST control ID.\n *\n * @param nistId - The NIST control ID (e.g., 'AC-01', 'AC-01 a')\n * @returns The NIST family code (e.g., 'AC'), or undefined if invalid\n *\n * @example\n * ```typescript\n * const family = getNISTFamily('AC-01');\n * // Returns: 'AC'\n *\n * const family2 = getNISTFamily('AC-01 a 01');\n * // Returns: 'AC'\n * ```\n */\nexport function getNISTFamily(nistId: string): string | undefined {\n  if (!nistId || typeof nistId !== 'string') {\n    return undefined;\n  }\n\n  // Extract family from format like \"AC-01\" or \"AC-01 a\"\n  const match = nistId.match(/^([A-Z]{2})-/);\n  if (!match) {\n    return undefined;\n  }\n\n  const family = match[1];\n\n  // Validate that this family exists in our database by checking\n  // if any controls start with this family\n  const familyPrefix = `${family}-`;\n  const hasFamily = Object.keys(nistData).some((key) => key.startsWith(familyPrefix));\n\n  return hasFamily ? family : undefined;\n}\n\n/**\n * Canonical NIST 800-53 fallback tags for converters when a finding has no\n * CWE or the CWE has no NIST mapping. Categories match heimdall2's global.ts.\n *\n * - SA-11: Developer Security Testing and Evaluation\n * - RA-5: Vulnerability Monitoring and Scanning\n * - SI-2: Flaw Remediation\n * - CM-8: System Component Inventory\n */\n\n/** Static analysis and vulnerability scanning tools (SA-11 + RA-5). */\nexport const DEFAULT_STATIC_ANALYSIS_NIST_TAGS: string[] = ['SA-11', 'RA-5'];\n\n/** Tools that identify outdated packages or flaws requiring patching (SI-2 + RA-5). */\nexport const DEFAULT_REMEDIATION_NIST_TAGS: string[] = ['SI-2', 'RA-5'];\n\n/** Dependency/inventory management tools (CM-8). */\nexport const DEFAULT_COMPONENT_MANAGEMENT_NIST_TAGS: string[] = ['CM-8'];\n\n// Re-export types\nexport type { NISTDescriptions } from './types.js';\n","","/**\n * OWASP Top 10 to NIST mapping functions\n */\n\nimport type { OwaspNistMappings, OwaspNistMapping } from './types.js';\nimport rawOwaspData from '../data/owasp-nist-mappings.json';\n\nconst owaspData = rawOwaspData as OwaspNistMappings;\nconst owaspIndex = new Map<string, OwaspNistMapping>(\n  owaspData.map(item => [item['OWASP-ID'], item])\n);\n\n/**\n * Get the NIST mapping for an OWASP Top 10 ID.\n *\n * @param owaspId - The OWASP ID (e.g., 'A1', 'A2')\n * @returns The mapping object, or undefined if not found\n *\n * @example\n * ```typescript\n * const mapping = getOwaspNistMapping('A1');\n * // Returns: { 'OWASP-ID': 'A1', 'OWASP Name': 'Injection', 'NIST-ID': 'SI-10', ... }\n * ```\n */\nexport function getOwaspNistMapping(owaspId: string): OwaspNistMapping | undefined {\n  if (!owaspId || typeof owaspId !== 'string') {\n    return undefined;\n  }\n\n  return owaspIndex.get(owaspId);\n}\n\n/**\n * Get the NIST control ID for an OWASP Top 10 ID.\n *\n * @param owaspId - The OWASP ID (e.g., 'A1', 'A2')\n * @returns The NIST control ID, or undefined if not found\n *\n * @example\n * ```typescript\n * const nistId = getOwaspNistControl('A1');\n * // Returns: 'SI-10'\n * ```\n */\nexport function getOwaspNistControl(owaspId: string): string | undefined {\n  const mapping = getOwaspNistMapping(owaspId);\n  return mapping?.['NIST-ID'];\n}\n\n/**\n * Get the OWASP vulnerability name for an OWASP ID.\n *\n * @param owaspId - The OWASP ID (e.g., 'A1', 'A2')\n * @returns The OWASP vulnerability name, or undefined if not found\n *\n * @example\n * ```typescript\n * const name = getOwaspName('A1');\n * // Returns: 'Injection'\n * ```\n */\nexport function getOwaspName(owaspId: string): string | undefined {\n  const mapping = getOwaspNistMapping(owaspId);\n  return mapping?.['OWASP Name'];\n}\n\n/**\n * Get all OWASP IDs available in the database.\n *\n * @returns Array of all OWASP IDs\n *\n * @example\n * ```typescript\n * const ids = getAllOwaspIds();\n * // Returns: ['A1', 'A2', 'A3', ..., 'A10']\n * ```\n */\nexport function getAllOwaspIds(): string[] {\n  return Array.from(owaspIndex.keys());\n}\n\n/**\n * Check if an OWASP ID exists in the database.\n *\n * @param owaspId - The OWASP ID to check\n * @returns true if the OWASP ID exists, false otherwise\n *\n * @example\n * ```typescript\n * if (owaspExists('A1')) {\n *   console.log('OWASP ID found');\n * }\n * ```\n */\nexport function owaspExists(owaspId: string): boolean {\n  if (!owaspId || typeof owaspId !== 'string') {\n    return false;\n  }\n\n  return owaspIndex.has(owaspId);\n}\n\n/**\n * Get all OWASP to NIST mappings.\n *\n * @returns Array of all mappings\n *\n * @example\n * ```typescript\n * const mappings = getAllOwaspMappings();\n * // Returns all 10 OWASP Top 10 mappings\n * ```\n */\nexport function getAllOwaspMappings(): OwaspNistMappings {\n  return owaspData;\n}\n\n// Re-export types\nexport type { OwaspNistMapping, OwaspNistMappings } from './types.js';\n","","/**\n * Query functions for CWE to NIST mappings.\n *\n * Lookups are revision-aware: each accepts an optional `rev` defaulting to the\n * module-global current revision, so existing callers keep getting the default.\n */\n\nimport type { CweNistMapping, CweNistMappings } from './types.js';\nimport { getCurrentNistRevision } from '../nist/index.js';\nimport rawMappings from '../data/cwe-nist-mappings.json';\n\nconst mappings = rawMappings as CweNistMappings;\n\n// revision → (CWE-ID → mapping)\nconst byRev = new Map<number, Map<number, CweNistMapping>>();\nfor (const m of mappings) {\n  let idx = byRev.get(m.Rev);\n  if (!idx) {\n    idx = new Map<number, CweNistMapping>();\n    byRev.set(m.Rev, idx);\n  }\n  idx.set(m['CWE-ID'], m);\n}\n\nfunction indexFor(rev: number): Map<number, CweNistMapping> {\n  return byRev.get(rev) ?? new Map<number, CweNistMapping>();\n}\n\n/** Get the full mapping for a CWE ID at the given NIST revision. */\nexport function getCweNistMapping(\n  cweId: number,\n  rev: number = getCurrentNistRevision()\n): CweNistMapping | undefined {\n  return indexFor(rev).get(cweId);\n}\n\n/** Get the NIST control ID for a CWE ID at the given NIST revision. */\nexport function getCweNistControl(cweId: number, rev: number = getCurrentNistRevision()): string | undefined {\n  return getCweNistMapping(cweId, rev)?.['NIST-ID'];\n}\n\n/** Get the CWE name for a CWE ID at the given NIST revision. */\nexport function getCweName(cweId: number, rev: number = getCurrentNistRevision()): string | undefined {\n  return getCweNistMapping(cweId, rev)?.['CWE Name'];\n}\n\n/** Get all CWE IDs present at the given NIST revision. */\nexport function getAllCweIds(rev: number = getCurrentNistRevision()): number[] {\n  return Array.from(indexFor(rev).keys());\n}\n\n/** Check whether a CWE ID exists at the given NIST revision. */\nexport function cweExists(cweId: number, rev: number = getCurrentNistRevision()): boolean {\n  return indexFor(rev).has(cweId);\n}\n\n/** Get all CWE to NIST mappings (all revisions). */\nexport function getAllCweMappings(): CweNistMappings {\n  return [...mappings];\n}\n","","/**\n * Query functions for Nessus to NIST mappings\n */\n\nimport type { NessusNistMappings } from './types.js';\nimport rawMappings from '../data/nessus-nist-mappings.json';\n\nconst mappings = rawMappings as NessusNistMappings;\n\n/**\n * Get the NIST control ID for a Nessus plugin family and plugin ID\n * @param pluginFamily - The Nessus plugin family\n * @param pluginId - The Nessus plugin ID (optional, defaults to \"*\")\n * @returns The NIST control ID or undefined if not found\n */\nexport function getNessusNistControl(\n  pluginFamily: string,\n  pluginId = '*'\n): string | undefined {\n  // The mapping data carries numeric plugin IDs alongside the \"*\" wildcard, so\n  // compare on the string form — a strict === against the raw value never\n  // matches a scan's (string) plugin ID.\n  const exactMatch = mappings.find(\n    (m) => m.pluginFamily === pluginFamily && String(m.pluginID) === pluginId\n  );\n  if (exactMatch) {\n    return exactMatch['NIST-ID'];\n  }\n\n  // Fall back to wildcard match\n  const wildcardMatch = mappings.find(\n    (m) => m.pluginFamily === pluginFamily && String(m.pluginID) === '*'\n  );\n  return wildcardMatch?.['NIST-ID'];\n}\n\n/**\n * Get all mappings for a plugin family\n * @param pluginFamily - The Nessus plugin family\n * @returns Array of mappings for the plugin family\n */\nexport function getNessusPluginFamilyMappings(\n  pluginFamily: string\n): NessusNistMappings {\n  return mappings.filter((m) => m.pluginFamily === pluginFamily);\n}\n\n/**\n * Get all plugin families\n * @returns Array of all plugin families\n */\nexport function getAllNessusPluginFamilies(): string[] {\n  const families = new Set(mappings.map((m) => m.pluginFamily));\n  return Array.from(families);\n}\n\n/**\n * Check if a plugin family exists in the mappings\n * @param pluginFamily - The plugin family to check\n * @returns True if the plugin family exists\n */\nexport function nessusPluginFamilyExists(pluginFamily: string): boolean {\n  return mappings.some((m) => m.pluginFamily === pluginFamily);\n}\n\n/**\n * Get all Nessus to NIST mappings\n * @returns Array of all mappings\n */\nexport function getAllNessusMappings(): NessusNistMappings {\n  return [...mappings];\n}\n","","/**\n * Query functions for Nikto to NIST mappings\n */\n\nimport type { NiktoNistMappings } from './types.js';\nimport rawMappings from '../data/nikto-nist-mappings.json';\n\nconst mappings = rawMappings as NiktoNistMappings;\n\n/**\n * Get the NIST control ID for a Nikto test ID\n * @param niktoId - The Nikto test ID (string or number)\n * @returns The NIST control ID or undefined if not found\n */\nexport function getNiktoNistControl(niktoId: string | number): string | undefined {\n  const id = typeof niktoId === 'number' ? niktoId.toString() : niktoId;\n  return mappings[id];\n}\n\n/**\n * Get all Nikto test IDs\n * @returns Array of all Nikto test IDs\n */\nexport function getAllNiktoIds(): string[] {\n  return Object.keys(mappings);\n}\n\n/**\n * Check if a Nikto test ID exists in the mappings\n * @param niktoId - The Nikto test ID to check\n * @returns True if the Nikto test ID exists\n */\nexport function niktoExists(niktoId: string | number): boolean {\n  const id = typeof niktoId === 'number' ? niktoId.toString() : niktoId;\n  return id in mappings;\n}\n\n/**\n * Get all Nikto to NIST mappings\n * @returns Object mapping Nikto test IDs to NIST control IDs\n */\nexport function getAllNiktoMappings(): NiktoNistMappings {\n  return { ...mappings };\n}\n","","/**\n * Query functions for ScoutSuite to NIST mappings\n */\n\nimport type { ScoutsuiteNistMapping, ScoutsuiteNistMappings } from './types.js';\nimport rawMappings from '../data/scoutsuite-nist-mappings.json';\n\nconst mappings = rawMappings as ScoutsuiteNistMappings;\nconst indexByRule = new Map<string, ScoutsuiteNistMapping>(\n  mappings.map(m => [m.RULE, m])\n);\n\n/**\n * Get the full mapping for a ScoutSuite rule\n * @param rule - The ScoutSuite rule name\n * @returns The mapping object or undefined if not found\n */\nexport function getScoutsuiteNistMapping(rule: string): ScoutsuiteNistMapping | undefined {\n  return indexByRule.get(rule);\n}\n\n/**\n * Get the NIST control ID for a ScoutSuite rule\n * @param rule - The ScoutSuite rule name\n * @returns The NIST control ID or undefined if not found\n */\nexport function getScoutsuiteNistControl(rule: string): string | undefined {\n  const mapping = getScoutsuiteNistMapping(rule);\n  return mapping?.['NIST-ID'];\n}\n\n/**\n * Get all ScoutSuite rule names\n * @returns Array of all rule names\n */\nexport function getAllScoutsuiteRules(): string[] {\n  return Array.from(indexByRule.keys());\n}\n\n/**\n * Check if a ScoutSuite rule exists in the mappings\n * @param rule - The rule name to check\n * @returns True if the rule exists\n */\nexport function scoutsuiteRuleExists(rule: string): boolean {\n  return indexByRule.has(rule);\n}\n\n/**\n * Get all ScoutSuite to NIST mappings\n * @returns Array of all mappings\n */\nexport function getAllScoutsuiteMappings(): ScoutsuiteNistMappings {\n  return [...mappings];\n}\n","","/**\n * Query functions for AWS Config to NIST mappings.\n *\n * Lookups are revision-aware: each accepts an optional `rev` defaulting to the\n * module-global current revision, so existing callers keep getting the default.\n */\n\nimport type { AwsConfigNistMapping, AwsConfigNistMappings } from './types.js';\nimport { getCurrentNistRevision, SUPPORTED_NIST_REVISIONS } from '../nist/index.js';\nimport rawMappings from '../data/awsconfig-mappings.json';\n\nconst mappings = rawMappings as AwsConfigNistMappings;\n\n// revision → (key → mapping), for both source-identifier and rule-name lookup\nconst byIdentifier = new Map<number, Map<string, AwsConfigNistMapping>>();\nconst byRuleName = new Map<number, Map<string, AwsConfigNistMapping>>();\nfor (const m of mappings) {\n  if (!byIdentifier.has(m.Rev)) {\n    byIdentifier.set(m.Rev, new Map());\n    byRuleName.set(m.Rev, new Map());\n  }\n  byIdentifier.get(m.Rev)!.set(m.AwsConfigRuleSourceIdentifier, m);\n  byRuleName.get(m.Rev)!.set(m.AwsConfigRuleName, m);\n}\n\nfunction idIndex(rev: number): Map<string, AwsConfigNistMapping> {\n  return byIdentifier.get(rev) ?? new Map();\n}\nfunction nameIndex(rev: number): Map<string, AwsConfigNistMapping> {\n  return byRuleName.get(rev) ?? new Map();\n}\n\n/** Get the full mapping for an AWS Config rule by source identifier. */\nexport function getAwsConfigNistMappingByIdentifier(\n  identifier: string,\n  rev: number = getCurrentNistRevision()\n): AwsConfigNistMapping | undefined {\n  return idIndex(rev).get(identifier);\n}\n\n/** Get the full mapping for an AWS Config rule by rule name. */\nexport function getAwsConfigNistMappingByName(\n  ruleName: string,\n  rev: number = getCurrentNistRevision()\n): AwsConfigNistMapping | undefined {\n  return nameIndex(rev).get(ruleName);\n}\n\n/** Get the NIST control ID for an AWS Config rule by source identifier. */\nexport function getAwsConfigNistControlByIdentifier(\n  identifier: string,\n  rev: number = getCurrentNistRevision()\n): string | undefined {\n  return getAwsConfigNistMappingByIdentifier(identifier, rev)?.['NIST-ID'];\n}\n\n/** Get the NIST control ID for an AWS Config rule by rule name. */\nexport function getAwsConfigNistControlByName(\n  ruleName: string,\n  rev: number = getCurrentNistRevision()\n): string | undefined {\n  return getAwsConfigNistMappingByName(ruleName, rev)?.['NIST-ID'];\n}\n\n/** Get all AWS Config rule source identifiers present at the given revision. */\nexport function getAllAwsConfigIdentifiers(rev: number = getCurrentNistRevision()): string[] {\n  return Array.from(idIndex(rev).keys());\n}\n\n/** Get all AWS Config rule names present at the given revision. */\nexport function getAllAwsConfigRuleNames(rev: number = getCurrentNistRevision()): string[] {\n  return Array.from(nameIndex(rev).keys());\n}\n\n/** Check if an AWS Config rule exists by source identifier at the given revision. */\nexport function awsConfigIdentifierExists(identifier: string, rev: number = getCurrentNistRevision()): boolean {\n  return idIndex(rev).has(identifier);\n}\n\n/** Check if an AWS Config rule exists by rule name at the given revision. */\nexport function awsConfigRuleNameExists(ruleName: string, rev: number = getCurrentNistRevision()): boolean {\n  return nameIndex(rev).has(ruleName);\n}\n\n/**\n * Get the supported NIST revisions at which the rule resolves (by source\n * identifier or rule name), sorted ascending. Mirrors the resolution\n * buildNistTags performs, so a revision is included exactly when a conversion\n * at that revision would emit NIST tags. Empty means unmapped everywhere — a\n * coverage gap, not a revision mismatch.\n */\nexport function awsConfigMappedRevisions(identifier: string, ruleName: string): number[] {\n  const revs: number[] = [];\n  for (const rev of SUPPORTED_NIST_REVISIONS) {\n    const byId = identifier ? getAwsConfigNistControlByIdentifier(identifier, rev) : undefined;\n    const byName = ruleName ? getAwsConfigNistControlByName(ruleName, rev) : undefined;\n    if (byId || byName) {\n      revs.push(rev);\n    }\n  }\n  return revs;\n}\n\n/** Get all AWS Config to NIST mappings (all revisions). */\nexport function getAllAwsConfigMappings(): AwsConfigNistMappings {\n  return [...mappings];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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GAAGA,UAAQ;AACrB;;;AEhEA,MAAME,aAAWC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"index.js","names":["rawCCIData","rawNistCCIData","rawNistData","rawOwaspData","mappings","rawMappings","mappings","rawMappings","mappings","rawMappings","mappings","rawMappings","rawMappings"],"sources":["../src/data/cci-mappings.json","../src/data/nist-cci-mappings.json","../src/cci/index.ts","../src/data/nist-descriptions.json","../src/nist/index.ts","../src/data/owasp-nist-mappings.json","../src/owasp/index.ts","../src/data/cwe-nist-mappings.json","../src/cwe/index.ts","../src/data/nessus-nist-mappings.json","../src/nessus/index.ts","../src/data/nikto-nist-mappings.json","../src/nikto/index.ts","../src/data/scoutsuite-nist-mappings.json","../src/scoutsuite/index.ts","../src/data/awsconfig-mappings.json","../src/awsconfig/index.ts"],"sourcesContent":["","","/**\n * CCI (Control Correlation Identifier) mapping functions\n */\n\nimport type { CCIMappings, NistCCIMappings } from './types.js';\nimport rawCCIData from '../data/cci-mappings.json';\nimport rawNistCCIData from '../data/nist-cci-mappings.json';\n\nconst cciData = rawCCIData as CCIMappings;\nconst nistCCIData = rawNistCCIData as NistCCIMappings;\n\n/**\n * Get the definition/description for a CCI ID.\n *\n * @param cciId - The CCI ID (e.g., 'CCI-000001')\n * @returns The CCI definition, or undefined if not found\n *\n * @example\n * ```typescript\n * const def = getCCIDescription('CCI-000001');\n * // Returns: \"The organization develops an access control policy...\"\n * ```\n */\nexport function getCCIDescription(cciId: string): string | undefined {\n  if (!cciId || typeof cciId !== 'string') {\n    return undefined;\n  }\n\n  const item = cciData[cciId];\n  return item?.def;\n}\n\n/**\n * Get the NIST control mappings for a CCI ID.\n *\n * @param cciId - The CCI ID (e.g., 'CCI-000001')\n * @returns Array of NIST control references, or undefined if not found\n *\n * @example\n * ```typescript\n * const mappings = getCCINistMappings('CCI-000001');\n * // Returns: ['AC-1 a', 'AC-1.1 (i and ii)', 'AC-1 a 1']\n * ```\n */\nexport function getCCINistMappings(cciId: string): string[] | undefined {\n  if (!cciId || typeof cciId !== 'string') {\n    return undefined;\n  }\n\n  const item = cciData[cciId];\n  return item?.nist;\n}\n\n/**\n * Get all CCI IDs available in the database.\n *\n * @returns Array of all CCI IDs\n *\n * @example\n * ```typescript\n * const ids = getAllCCIIds();\n * // Returns: ['CCI-000001', 'CCI-000002', ...]\n * ```\n */\nexport function getAllCCIIds(): string[] {\n  return Object.keys(cciData);\n}\n\n/**\n * Check if a CCI ID exists in the database.\n *\n * @param cciId - The CCI ID to check\n * @returns true if the CCI exists, false otherwise\n *\n * @example\n * ```typescript\n * if (cciExists('CCI-000001')) {\n *   console.log('CCI found');\n * }\n * ```\n */\nexport function cciExists(cciId: string): boolean {\n  if (!cciId || typeof cciId !== 'string') {\n    return false;\n  }\n\n  return cciId in cciData;\n}\n\n/**\n * Extract the base NIST control identifier from a potentially qualified string.\n * For example, \"SI-10 a 1\" → \"SI-10\", \"AC-3 (2)\" → \"AC-3\".\n */\nfunction baseNistControl(control: string): string {\n  const idx = control.search(/[ (.]/);\n  return idx === -1 ? control : control.slice(0, idx);\n}\n\n/**\n * Get CCI IDs for a NIST control using the curated mapping table.\n * The input is normalized to its base control before lookup.\n *\n * @param nistControl - NIST control string (e.g., 'SI-10', 'AC-3 (2)')\n * @returns Array of CCI IDs, or undefined if not found\n *\n * @example\n * ```typescript\n * const ccis = getNistCCIMappings('SI-10');\n * // Returns: ['CCI-001310']\n * ```\n */\nexport function getNistCCIMappings(nistControl: string): string[] | undefined {\n  if (!nistControl || typeof nistControl !== 'string') {\n    return undefined;\n  }\n  const base = baseNistControl(nistControl);\n  return nistCCIData[base];\n}\n\n/**\n * Map NIST 800-53 controls to their CCI IDs using the curated mapping table.\n * Results are deduplicated and sorted.\n *\n * @param nistControls - Array of NIST control strings\n * @returns Deduplicated, sorted array of CCI IDs (empty array if no mappings found)\n *\n * @example\n * ```typescript\n * const ccis = nistToCci(['AC-3', 'SI-10']);\n * // Returns: ['CCI-000213', 'CCI-001310']\n * ```\n */\nexport function nistToCci(nistControls: string[]): string[] {\n  const seen = new Set<string>();\n  for (const control of nistControls) {\n    const ccis = getNistCCIMappings(control);\n    if (ccis) {\n      for (const cciId of ccis) {\n        seen.add(cciId);\n      }\n    }\n  }\n  return Array.from(seen).sort();\n}\n\n// Re-export types\nexport type { CCIItem, CCIMappings, NistCCIMappings } from './types.js';\n","","/**\n * NIST SP 800-53 control description functions\n */\n\nimport type { NISTDescriptions } from './types.js';\nimport rawNistData from '../data/nist-descriptions.json';\n\nconst nistData = rawNistData as NISTDescriptions;\n\n/**\n * NIST SP 800-53 revision selection.\n *\n * The revision is a module-global default that every NIST-emitting mapping\n * consults through its default lookups. Set it once at startup (the CLI's\n * `--nist-rev` flag does this) to switch the catalog all converters target.\n * For explicit, side-effect-free per-call selection, pass an explicit `rev` to\n * the mapping lookups instead of mutating this.\n */\n\n/** The revision mappings emit when nothing overrides it. */\nexport const DEFAULT_NIST_REVISION = 5;\n\n/** Revisions every NIST-emitting mapping table has rows for. */\nexport const SUPPORTED_NIST_REVISIONS: readonly number[] = [4, 5];\n\nlet currentNistRevision = DEFAULT_NIST_REVISION;\n\n/** Get the module-global default NIST revision. */\nexport function getCurrentNistRevision(): number {\n  return currentNistRevision;\n}\n\n/**\n * Set the module-global default NIST revision. Throws (without mutating state)\n * if the revision has no mapping data.\n */\nexport function setCurrentNistRevision(rev: number): void {\n  if (!SUPPORTED_NIST_REVISIONS.includes(rev)) {\n    throw new Error(\n      `unsupported NIST revision ${rev} (supported: ${SUPPORTED_NIST_REVISIONS.join(', ')})`\n    );\n  }\n  currentNistRevision = rev;\n}\n\n/** Restore the default revision. Intended for cleanup and tests. */\nexport function resetNistRevision(): void {\n  currentNistRevision = DEFAULT_NIST_REVISION;\n}\n\nlet nistStrict = false;\n\n/** Report whether strict NIST revision alignment is enabled. */\nexport function isNistStrict(): boolean {\n  return nistStrict;\n}\n\n/**\n * Toggle strict NIST revision alignment. When enabled, revision-divergent\n * mappings treat a rule mapped only at another revision as a hard error rather\n * than a silent omission.\n */\nexport function setNistStrict(strict: boolean): void {\n  nistStrict = strict;\n}\n\n/**\n * Get the description for a NIST control ID.\n *\n * @param nistId - The NIST control ID (e.g., 'AC-01', 'AC-01 a', 'AC-01 a 01')\n * @returns The NIST control description, or undefined if not found\n *\n * @example\n * ```typescript\n * const desc = getNISTDescription('AC-01');\n * // Returns: \"ACCESS CONTROL POLICY AND PROCEDURES\"\n * ```\n */\nexport function getNISTDescription(nistId: string): string | undefined {\n  if (!nistId || typeof nistId !== 'string') {\n    return undefined;\n  }\n\n  return nistData[nistId];\n}\n\n/**\n * Get all NIST control IDs available in the database.\n *\n * @returns Array of all NIST control IDs\n *\n * @example\n * ```typescript\n * const ids = getAllNISTIds();\n * // Returns: ['AC-01', 'AC-01 a', 'AC-02', ...]\n * ```\n */\nexport function getAllNISTIds(): string[] {\n  return Object.keys(nistData);\n}\n\n/**\n * Check if a NIST control ID exists in the database.\n *\n * @param nistId - The NIST control ID to check\n * @returns true if the NIST control exists, false otherwise\n *\n * @example\n * ```typescript\n * if (nistExists('AC-01')) {\n *   console.log('NIST control found');\n * }\n * ```\n */\nexport function nistExists(nistId: string): boolean {\n  if (!nistId || typeof nistId !== 'string') {\n    return false;\n  }\n\n  return nistId in nistData;\n}\n\n/**\n * Extract the NIST family from a NIST control ID.\n *\n * @param nistId - The NIST control ID (e.g., 'AC-01', 'AC-01 a')\n * @returns The NIST family code (e.g., 'AC'), or undefined if invalid\n *\n * @example\n * ```typescript\n * const family = getNISTFamily('AC-01');\n * // Returns: 'AC'\n *\n * const family2 = getNISTFamily('AC-01 a 01');\n * // Returns: 'AC'\n * ```\n */\nexport function getNISTFamily(nistId: string): string | undefined {\n  if (!nistId || typeof nistId !== 'string') {\n    return undefined;\n  }\n\n  // Extract family from format like \"AC-01\" or \"AC-01 a\"\n  const match = nistId.match(/^([A-Z]{2})-/);\n  if (!match) {\n    return undefined;\n  }\n\n  const family = match[1];\n\n  // Validate that this family exists in our database by checking\n  // if any controls start with this family\n  const familyPrefix = `${family}-`;\n  const hasFamily = Object.keys(nistData).some((key) => key.startsWith(familyPrefix));\n\n  return hasFamily ? family : undefined;\n}\n\n/**\n * Canonical NIST 800-53 fallback tags for converters when a finding has no\n * CWE or the CWE has no NIST mapping. Categories match heimdall2's global.ts.\n *\n * - SA-11: Developer Security Testing and Evaluation\n * - RA-5: Vulnerability Monitoring and Scanning\n * - SI-2: Flaw Remediation\n * - CM-8: System Component Inventory\n */\n\n/** Static analysis and vulnerability scanning tools (SA-11 + RA-5). */\nexport const DEFAULT_STATIC_ANALYSIS_NIST_TAGS: string[] = ['SA-11', 'RA-5'];\n\n/** Tools that identify outdated packages or flaws requiring patching (SI-2 + RA-5). */\nexport const DEFAULT_REMEDIATION_NIST_TAGS: string[] = ['SI-2', 'RA-5'];\n\n/** Dependency/inventory management tools (CM-8). */\nexport const DEFAULT_COMPONENT_MANAGEMENT_NIST_TAGS: string[] = ['CM-8'];\n\n// Re-export types\nexport type { NISTDescriptions } from './types.js';\n","","/**\n * OWASP Top 10 to NIST mapping functions\n */\n\nimport type { OwaspNistMappings, OwaspNistMapping } from './types.js';\nimport rawOwaspData from '../data/owasp-nist-mappings.json';\n\nconst owaspData = rawOwaspData as OwaspNistMappings;\nconst owaspIndex = new Map<string, OwaspNistMapping>(\n  owaspData.map(item => [item['OWASP-ID'], item])\n);\n\n/**\n * Get the NIST mapping for an OWASP Top 10 ID.\n *\n * @param owaspId - The OWASP ID (e.g., 'A1', 'A2')\n * @returns The mapping object, or undefined if not found\n *\n * @example\n * ```typescript\n * const mapping = getOwaspNistMapping('A1');\n * // Returns: { 'OWASP-ID': 'A1', 'OWASP Name': 'Injection', 'NIST-ID': 'SI-10', ... }\n * ```\n */\nexport function getOwaspNistMapping(owaspId: string): OwaspNistMapping | undefined {\n  if (!owaspId || typeof owaspId !== 'string') {\n    return undefined;\n  }\n\n  return owaspIndex.get(owaspId);\n}\n\n/**\n * Get the NIST control ID for an OWASP Top 10 ID.\n *\n * @param owaspId - The OWASP ID (e.g., 'A1', 'A2')\n * @returns The NIST control ID, or undefined if not found\n *\n * @example\n * ```typescript\n * const nistId = getOwaspNistControl('A1');\n * // Returns: 'SI-10'\n * ```\n */\nexport function getOwaspNistControl(owaspId: string): string | undefined {\n  const mapping = getOwaspNistMapping(owaspId);\n  return mapping?.['NIST-ID'];\n}\n\n/**\n * Get the OWASP vulnerability name for an OWASP ID.\n *\n * @param owaspId - The OWASP ID (e.g., 'A1', 'A2')\n * @returns The OWASP vulnerability name, or undefined if not found\n *\n * @example\n * ```typescript\n * const name = getOwaspName('A1');\n * // Returns: 'Injection'\n * ```\n */\nexport function getOwaspName(owaspId: string): string | undefined {\n  const mapping = getOwaspNistMapping(owaspId);\n  return mapping?.['OWASP Name'];\n}\n\n/**\n * Get all OWASP IDs available in the database.\n *\n * @returns Array of all OWASP IDs\n *\n * @example\n * ```typescript\n * const ids = getAllOwaspIds();\n * // Returns: ['A1', 'A2', 'A3', ..., 'A10']\n * ```\n */\nexport function getAllOwaspIds(): string[] {\n  return Array.from(owaspIndex.keys());\n}\n\n/**\n * Check if an OWASP ID exists in the database.\n *\n * @param owaspId - The OWASP ID to check\n * @returns true if the OWASP ID exists, false otherwise\n *\n * @example\n * ```typescript\n * if (owaspExists('A1')) {\n *   console.log('OWASP ID found');\n * }\n * ```\n */\nexport function owaspExists(owaspId: string): boolean {\n  if (!owaspId || typeof owaspId !== 'string') {\n    return false;\n  }\n\n  return owaspIndex.has(owaspId);\n}\n\n/**\n * Get all OWASP to NIST mappings.\n *\n * @returns Array of all mappings\n *\n * @example\n * ```typescript\n * const mappings = getAllOwaspMappings();\n * // Returns all 10 OWASP Top 10 mappings\n * ```\n */\nexport function getAllOwaspMappings(): OwaspNistMappings {\n  return owaspData;\n}\n\n// Re-export types\nexport type { OwaspNistMapping, OwaspNistMappings } from './types.js';\n","","/**\n * Query functions for CWE to NIST mappings.\n *\n * Lookups are revision-aware: each accepts an optional `rev` defaulting to the\n * module-global current revision, so existing callers keep getting the default.\n */\n\nimport type { CweNistMapping, CweNistMappings } from './types.js';\nimport { getCurrentNistRevision } from '../nist/index.js';\nimport rawMappings from '../data/cwe-nist-mappings.json';\n\nconst mappings = rawMappings as CweNistMappings;\n\n// revision → (CWE-ID → mapping)\nconst byRev = new Map<number, Map<number, CweNistMapping>>();\nfor (const m of mappings) {\n  let idx = byRev.get(m.Rev);\n  if (!idx) {\n    idx = new Map<number, CweNistMapping>();\n    byRev.set(m.Rev, idx);\n  }\n  idx.set(m['CWE-ID'], m);\n}\n\nfunction indexFor(rev: number): Map<number, CweNistMapping> {\n  return byRev.get(rev) ?? new Map<number, CweNistMapping>();\n}\n\n/** Get the full mapping for a CWE ID at the given NIST revision. */\nexport function getCweNistMapping(\n  cweId: number,\n  rev: number = getCurrentNistRevision()\n): CweNistMapping | undefined {\n  return indexFor(rev).get(cweId);\n}\n\n/** Get the NIST control ID for a CWE ID at the given NIST revision. */\nexport function getCweNistControl(cweId: number, rev: number = getCurrentNistRevision()): string | undefined {\n  return getCweNistMapping(cweId, rev)?.['NIST-ID'];\n}\n\n/** Get the CWE name for a CWE ID at the given NIST revision. */\nexport function getCweName(cweId: number, rev: number = getCurrentNistRevision()): string | undefined {\n  return getCweNistMapping(cweId, rev)?.['CWE Name'];\n}\n\n/** Get all CWE IDs present at the given NIST revision. */\nexport function getAllCweIds(rev: number = getCurrentNistRevision()): number[] {\n  return Array.from(indexFor(rev).keys());\n}\n\n/** Check whether a CWE ID exists at the given NIST revision. */\nexport function cweExists(cweId: number, rev: number = getCurrentNistRevision()): boolean {\n  return indexFor(rev).has(cweId);\n}\n\n/** Get all CWE to NIST mappings (all revisions). */\nexport function getAllCweMappings(): CweNistMappings {\n  return [...mappings];\n}\n","","/**\n * Query functions for Nessus to NIST mappings\n */\n\nimport type { NessusNistMappings } from './types.js';\nimport rawMappings from '../data/nessus-nist-mappings.json';\n\nconst mappings = rawMappings as NessusNistMappings;\n\n/**\n * Get the NIST control ID for a Nessus plugin family and plugin ID\n * @param pluginFamily - The Nessus plugin family\n * @param pluginId - The Nessus plugin ID (optional, defaults to \"*\")\n * @returns The NIST control ID or undefined if not found\n */\nexport function getNessusNistControl(\n  pluginFamily: string,\n  pluginId = '*'\n): string | undefined {\n  // The mapping data carries numeric plugin IDs alongside the \"*\" wildcard, so\n  // compare on the string form — a strict === against the raw value never\n  // matches a scan's (string) plugin ID.\n  const exactMatch = mappings.find(\n    (m) => m.pluginFamily === pluginFamily && String(m.pluginID) === pluginId\n  );\n  if (exactMatch) {\n    return exactMatch['NIST-ID'];\n  }\n\n  // Fall back to wildcard match\n  const wildcardMatch = mappings.find(\n    (m) => m.pluginFamily === pluginFamily && String(m.pluginID) === '*'\n  );\n  return wildcardMatch?.['NIST-ID'];\n}\n\n/**\n * Get all mappings for a plugin family\n * @param pluginFamily - The Nessus plugin family\n * @returns Array of mappings for the plugin family\n */\nexport function getNessusPluginFamilyMappings(\n  pluginFamily: string\n): NessusNistMappings {\n  return mappings.filter((m) => m.pluginFamily === pluginFamily);\n}\n\n/**\n * Get all plugin families\n * @returns Array of all plugin families\n */\nexport function getAllNessusPluginFamilies(): string[] {\n  const families = new Set(mappings.map((m) => m.pluginFamily));\n  return Array.from(families);\n}\n\n/**\n * Check if a plugin family exists in the mappings\n * @param pluginFamily - The plugin family to check\n * @returns True if the plugin family exists\n */\nexport function nessusPluginFamilyExists(pluginFamily: string): boolean {\n  return mappings.some((m) => m.pluginFamily === pluginFamily);\n}\n\n/**\n * Get all Nessus to NIST mappings\n * @returns Array of all mappings\n */\nexport function getAllNessusMappings(): NessusNistMappings {\n  return [...mappings];\n}\n","","/**\n * Query functions for Nikto to NIST mappings\n */\n\nimport type { NiktoNistMappings } from './types.js';\nimport rawMappings from '../data/nikto-nist-mappings.json';\n\nconst mappings = rawMappings as NiktoNistMappings;\n\n/**\n * Get the NIST control ID for a Nikto test ID\n * @param niktoId - The Nikto test ID (string or number)\n * @returns The NIST control ID or undefined if not found\n */\nexport function getNiktoNistControl(niktoId: string | number): string | undefined {\n  const id = typeof niktoId === 'number' ? niktoId.toString() : niktoId;\n  return mappings[id];\n}\n\n/**\n * Get all Nikto test IDs\n * @returns Array of all Nikto test IDs\n */\nexport function getAllNiktoIds(): string[] {\n  return Object.keys(mappings);\n}\n\n/**\n * Check if a Nikto test ID exists in the mappings\n * @param niktoId - The Nikto test ID to check\n * @returns True if the Nikto test ID exists\n */\nexport function niktoExists(niktoId: string | number): boolean {\n  const id = typeof niktoId === 'number' ? niktoId.toString() : niktoId;\n  return id in mappings;\n}\n\n/**\n * Get all Nikto to NIST mappings\n * @returns Object mapping Nikto test IDs to NIST control IDs\n */\nexport function getAllNiktoMappings(): NiktoNistMappings {\n  return { ...mappings };\n}\n","","/**\n * Query functions for ScoutSuite to NIST mappings\n */\n\nimport type { ScoutsuiteNistMapping, ScoutsuiteNistMappings } from './types.js';\nimport rawMappings from '../data/scoutsuite-nist-mappings.json';\n\nconst mappings = rawMappings as ScoutsuiteNistMappings;\nconst indexByRule = new Map<string, ScoutsuiteNistMapping>(\n  mappings.map(m => [m.RULE, m])\n);\n\n/**\n * Get the full mapping for a ScoutSuite rule\n * @param rule - The ScoutSuite rule name\n * @returns The mapping object or undefined if not found\n */\nexport function getScoutsuiteNistMapping(rule: string): ScoutsuiteNistMapping | undefined {\n  return indexByRule.get(rule);\n}\n\n/**\n * Get the NIST control ID for a ScoutSuite rule\n * @param rule - The ScoutSuite rule name\n * @returns The NIST control ID or undefined if not found\n */\nexport function getScoutsuiteNistControl(rule: string): string | undefined {\n  const mapping = getScoutsuiteNistMapping(rule);\n  return mapping?.['NIST-ID'];\n}\n\n/**\n * Get all ScoutSuite rule names\n * @returns Array of all rule names\n */\nexport function getAllScoutsuiteRules(): string[] {\n  return Array.from(indexByRule.keys());\n}\n\n/**\n * Check if a ScoutSuite rule exists in the mappings\n * @param rule - The rule name to check\n * @returns True if the rule exists\n */\nexport function scoutsuiteRuleExists(rule: string): boolean {\n  return indexByRule.has(rule);\n}\n\n/**\n * Get all ScoutSuite to NIST mappings\n * @returns Array of all mappings\n */\nexport function getAllScoutsuiteMappings(): ScoutsuiteNistMappings {\n  return [...mappings];\n}\n","","/**\n * Query functions for AWS Config to NIST mappings.\n *\n * Lookups are revision-aware: each accepts an optional `rev` defaulting to the\n * module-global current revision, so existing callers keep getting the default.\n */\n\nimport type { AwsConfigNistMapping, AwsConfigNistMappings } from './types.js';\nimport { getCurrentNistRevision, SUPPORTED_NIST_REVISIONS } from '../nist/index.js';\nimport rawMappings from '../data/awsconfig-mappings.json';\n\nconst mappings = rawMappings as AwsConfigNistMappings;\n\n// revision → (key → mapping), for both source-identifier and rule-name lookup\nconst byIdentifier = new Map<number, Map<string, AwsConfigNistMapping>>();\nconst byRuleName = new Map<number, Map<string, AwsConfigNistMapping>>();\nfor (const m of mappings) {\n  if (!byIdentifier.has(m.Rev)) {\n    byIdentifier.set(m.Rev, new Map());\n    byRuleName.set(m.Rev, new Map());\n  }\n  byIdentifier.get(m.Rev)!.set(m.AwsConfigRuleSourceIdentifier, m);\n  byRuleName.get(m.Rev)!.set(m.AwsConfigRuleName, m);\n}\n\nfunction idIndex(rev: number): Map<string, AwsConfigNistMapping> {\n  return byIdentifier.get(rev) ?? new Map();\n}\nfunction nameIndex(rev: number): Map<string, AwsConfigNistMapping> {\n  return byRuleName.get(rev) ?? new Map();\n}\n\n/** Get the full mapping for an AWS Config rule by source identifier. */\nexport function getAwsConfigNistMappingByIdentifier(\n  identifier: string,\n  rev: number = getCurrentNistRevision()\n): AwsConfigNistMapping | undefined {\n  return idIndex(rev).get(identifier);\n}\n\n/** Get the full mapping for an AWS Config rule by rule name. */\nexport function getAwsConfigNistMappingByName(\n  ruleName: string,\n  rev: number = getCurrentNistRevision()\n): AwsConfigNistMapping | undefined {\n  return nameIndex(rev).get(ruleName);\n}\n\n/** Get the NIST control ID for an AWS Config rule by source identifier. */\nexport function getAwsConfigNistControlByIdentifier(\n  identifier: string,\n  rev: number = getCurrentNistRevision()\n): string | undefined {\n  return getAwsConfigNistMappingByIdentifier(identifier, rev)?.['NIST-ID'];\n}\n\n/** Get the NIST control ID for an AWS Config rule by rule name. */\nexport function getAwsConfigNistControlByName(\n  ruleName: string,\n  rev: number = getCurrentNistRevision()\n): string | undefined {\n  return getAwsConfigNistMappingByName(ruleName, rev)?.['NIST-ID'];\n}\n\n/**\n * Resolve NIST controls for a decorated rule name such as Security Hub's\n * \"securityhub-<canonical>-<hash>\", where an exact lookup fails. Returns the\n * split controls of the canonical rule whose name is contained in the given\n * name; the longest such match wins. Returns [] if none match.\n */\nexport function getAwsConfigNistControlsBySubstring(\n  name: string,\n  rev: number = getCurrentNistRevision()\n): string[] {\n  if (!name) return [];\n  const lower = name.toLowerCase();\n  let best: AwsConfigNistMapping | undefined;\n  let bestLen = 0;\n  for (const [key, m] of nameIndex(rev)) {\n    if (key && key.length > bestLen && lower.includes(key.toLowerCase())) {\n      best = m;\n      bestLen = key.length;\n    }\n  }\n  if (!best) return [];\n  return best['NIST-ID']\n    .split('|')\n    .map((s) => s.trim())\n    .filter(Boolean);\n}\n\n/** Get all AWS Config rule source identifiers present at the given revision. */\nexport function getAllAwsConfigIdentifiers(rev: number = getCurrentNistRevision()): string[] {\n  return Array.from(idIndex(rev).keys());\n}\n\n/** Get all AWS Config rule names present at the given revision. */\nexport function getAllAwsConfigRuleNames(rev: number = getCurrentNistRevision()): string[] {\n  return Array.from(nameIndex(rev).keys());\n}\n\n/** Check if an AWS Config rule exists by source identifier at the given revision. */\nexport function awsConfigIdentifierExists(identifier: string, rev: number = getCurrentNistRevision()): boolean {\n  return idIndex(rev).has(identifier);\n}\n\n/** Check if an AWS Config rule exists by rule name at the given revision. */\nexport function awsConfigRuleNameExists(ruleName: string, rev: number = getCurrentNistRevision()): boolean {\n  return nameIndex(rev).has(ruleName);\n}\n\n/**\n * Get the supported NIST revisions at which the rule resolves (by source\n * identifier or rule name), sorted ascending. Mirrors the resolution\n * buildNistTags performs, so a revision is included exactly when a conversion\n * at that revision would emit NIST tags. Empty means unmapped everywhere — a\n * coverage gap, not a revision mismatch.\n */\nexport function awsConfigMappedRevisions(identifier: string, ruleName: string): number[] {\n  const revs: number[] = [];\n  for (const rev of SUPPORTED_NIST_REVISIONS) {\n    const byId = identifier ? getAwsConfigNistControlByIdentifier(identifier, rev) : undefined;\n    const byName = ruleName ? getAwsConfigNistControlByName(ruleName, rev) : undefined;\n    if (byId || byName) {\n      revs.push(rev);\n    }\n  }\n  return revs;\n}\n\n/** Get all AWS Config to NIST mappings (all revisions). */\nexport function getAllAwsConfigMappings(): AwsConfigNistMappings {\n  return [...mappings];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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GAAGA,UAAQ;AACrB;;;AEhEA,MAAME,aAAWC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mitre/hdf-mappings",
-  "version": "3.4.0",
+  "version": "3.4.2",
   "description": "CCI/NIST/CIS/CMMC security framework mappings for HDF",
   "publishConfig": {
     "access": "public"