@mitre/hdf-utilities 3.7.2 → 3.8.0-next.42532249979.1

package/README.md

@@ -100,6 +100,9 @@ import { sha256, sha512, generateHash, hashObject, verifyHash } from '@mitre/hdf
 const hash = await sha256('content to hash');
 console.log(hash); // hex-encoded hash
 
+// Raw bytes hash as they are; text is hashed as its UTF-8 bytes
+const fileHash = await sha256(new Uint8Array([0x61, 0x62, 0x63]));
+
 // Hash with custom options
 const customHash = await generateHash('data', {
   algorithm: 'sha512',

package/dist/csv/index.d.ts

@@ -1,5 +1,4 @@
 import { extractColumn, findRows } from "../object/index.js";
-//#region src/csv/index.d.ts
 /**
  * Options for parsing CSV
  */
@@ -97,6 +96,5 @@ export declare function sanitizeCsvArray(values: unknown[]): string[];
  * @returns New object with sanitized values
  */
 export declare function sanitizeCsvObject<T extends Record<string, unknown>>(obj: T): Record<string, string>;
-//#endregion
 export { extractColumn as extractCsvColumn, findRows as findCsvRows };
 //# sourceMappingURL=index.d.ts.map

package/dist/csv/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/csv/index.ts"],"mappings":";;;;;iBAkBiB;EACf;EACA;EACA,mBAAmB,gBAAgB;EACnC;EACA;EACA;;;;;iBAMe;EACf;EACA;EACA;EACA;;;;;;;;;wBAwEc,SAAS,IAAI,yBAC3B,aACA,UAAU,QAAQ,mBACjB;;;;;;;;wBAoDa,cACd,aACA,UAAU,QAAQ;;;;;;;;;;;wBAiCJ,SAAS,IAAI,yBAC3B,MAAM,KACN,UAAU,QAAQ;EAAqB;;;;;;;;;;;;wBA6GzB,cACd,kBACA,UAAU,QAAQ;EAAqB;;;;;;;wBA4BzB,WAAW;;;;;;;;;;;;;;;wBA+BX,iBAAiB;;;;;;;wBAcjB,iBAAiB;;;;;;;wBAUjB,kBAAkB,UAAU,yBAC1C,KAAK,IACJ"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/csv/index.ts"],"mappings":";;;;iBAkBiB;EACf;EACA;EACA,mBAAmB,gBAAgB;EACnC;EACA;EACA;;;;;iBAMe;EACf;EACA;EACA;EACA;;;;;;;;;wBAwEc,SAAS,IAAI,yBAC3B,aACA,UAAU,QAAQ,mBACjB;;;;;;;;wBAoDa,cACd,aACA,UAAU,QAAQ;;;;;;;;;;;wBAiCJ,SAAS,IAAI,yBAC3B,MAAM,KACN,UAAU,QAAQ;EAAqB;;;;;;;;;;;;wBA6GzB,cACd,kBACA,UAAU,QAAQ;EAAqB;;;;;;;wBA4BzB,WAAW;;;;;;;;;;;;;;;wBA+BX,iBAAiB;;;;;;;wBAcjB,iBAAiB;;;;;;;wBAUjB,kBAAkB,UAAU,yBAC1C,KAAK,IACJ"}

package/dist/csv/index.js

@@ -1,6 +1,6 @@
 import { extractColumn, findRows } from "../object/index.js";
 import { dsvFormat } from "d3-dsv";
-//#region src/csv/index.ts
+// src/csv/index.ts
 /**
 * CSV parsing and generation utilities using d3-dsv
 *
@@ -271,7 +271,6 @@ function sanitizeCsvObject(obj) {
 	for (const [key, value] of Object.entries(obj)) sanitized[key] = sanitizeCsvValue(value);
 	return sanitized;
 }
-//#endregion
 export { buildCsv, buildCsvArray, extractColumn as extractCsvColumn, findRows as findCsvRows, isValidCsv, parseCsv, parseCsvArray, sanitizeCsvArray, sanitizeCsvObject, sanitizeCsvValue };
 
 //# sourceMappingURL=index.js.map

package/dist/hash/index.d.ts

@@ -1,4 +1,3 @@
-//#region src/hash/index.d.ts
 /**
  * Hash utilities for HDF content
  * Provides cryptographic hashing functions for content identification and integrity verification
@@ -7,11 +6,15 @@
 /**
  * Supported hash algorithms
  */
-export type HashAlgorithm = 'sha256' | 'sha512';
+export type HashAlgorithm = 'sha256' | 'sha384' | 'sha512';
 /**
  * Supported output encodings
  */
 export type HashEncoding = 'hex' | 'base64';
+/**
+ * Data that can be hashed: text, hashed as its UTF-8 bytes, or raw bytes
+ */
+export type HashInput = string | Uint8Array;
 /**
  * Options for hash generation
  */
@@ -24,7 +27,7 @@ export interface HashOptions {
 /**
  * Generate a hash of the given data
  *
- * @param data - String data to hash
+ * @param data - Text or bytes to hash
  * @param options - Hash generation options
  * @returns Hex-encoded hash string
  *
@@ -34,11 +37,11 @@ export interface HashOptions {
  * // Returns: 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9'
  * ```
  */
-export declare function generateHash(data: string, options?: HashOptions): Promise<string>;
+export declare function generateHash(data: HashInput, options?: HashOptions): Promise<string>;
 /**
  * Generate a SHA-256 hash (recommended for most use cases)
  *
- * @param data - String data to hash
+ * @param data - Text or bytes to hash
  * @returns Hex-encoded SHA-256 hash
  *
  * @example
@@ -47,11 +50,11 @@ export declare function generateHash(data: string, options?: HashOptions): Promi
  * // Returns: 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9'
  * ```
  */
-export declare function sha256(data: string): Promise<string>;
+export declare function sha256(data: HashInput): Promise<string>;
 /**
  * Generate a SHA-512 hash (enhanced security for sensitive data)
  *
- * @param data - String data to hash
+ * @param data - Text or bytes to hash
  * @returns Hex-encoded SHA-512 hash
  *
  * @example
@@ -60,7 +63,7 @@ export declare function sha256(data: string): Promise<string>;
  * // Returns: '309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f'
  * ```
  */
-export declare function sha512(data: string): Promise<string>;
+export declare function sha512(data: HashInput): Promise<string>;
 /**
  * Generate a hash of an object by stringifying it first
  * Useful for hashing HDF control objects or other structured data
@@ -80,7 +83,7 @@ export declare function hashObject(obj: unknown, options?: HashOptions): Promise
 /**
  * Verify that data matches a given hash
  *
- * @param data - String data to verify
+ * @param data - Text or bytes to verify
  * @param expectedHash - Expected hash value
  * @param options - Hash generation options (must match hash generation)
  * @returns True if data matches the hash
@@ -92,6 +95,5 @@ export declare function hashObject(obj: unknown, options?: HashOptions): Promise
  * const isValid = await verifyHash(data, hash); // true
  * ```
  */
-export declare function verifyHash(data: string, expectedHash: string, options?: HashOptions): Promise<boolean>;
-//#endregion
+export declare function verifyHash(data: HashInput, expectedHash: string, options?: HashOptions): Promise<boolean>;
 //# sourceMappingURL=index.d.ts.map

package/dist/hash/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/hash/index.ts"],"mappings":";;;;;;;;;YASY;;;;YAKA;;;;iBAKK;;EAEf,YAAY;;EAEZ,WAAW;;;;;;;;;;;;;;;wBA0CS,aAAa,cAAc,UAAS,cAAmB;;;;;;;;;;;;;wBAoBvD,OAAO,eAAe;;;;;;;;;;;;;wBAgBtB,OAAO,eAAe;;;;;;;;;;;;;;;;wBAmBtB,WAAW,cAAc,UAAS,cAAmB;;;;;;;;;;;;;;;;wBAqBrD,WACpB,cACA,sBACA,UAAS,cACR"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/hash/index.ts"],"mappings":";;;;;;;;YASY;;;;YAKA;;;;YAKA,qBAAqB;;;;iBAKhB;;EAEf,YAAY;;EAEZ,WAAW;;;;;;;;;;;;;;;wBAuDS,aAAa,MAAM,WAAW,UAAS,cAAmB;;;;;;;;;;;;;wBAmB1D,OAAO,MAAM,YAAY;;;;;;;;;;;;;wBAgBzB,OAAO,MAAM,YAAY;;;;;;;;;;;;;;;;wBAmBzB,WAAW,cAAc,UAAS,cAAmB;;;;;;;;;;;;;;;;wBAqBrD,WACpB,MAAM,WACN,sBACA,UAAS,cACR"}

package/dist/hash/index.js

@@ -1,9 +1,18 @@
-//#region src/hash/index.ts
+// src/hash/index.ts
 /** Map our algorithm names to Web Crypto algorithm identifiers */
 const ALGORITHM_MAP = {
 	sha256: "SHA-256",
+	sha384: "SHA-384",
 	sha512: "SHA-512"
 };
+/** Web Crypto refuses a view over shared memory, so such a view is copied first. */
+function digestInput(data) {
+	if (typeof data === "string") return new TextEncoder().encode(data);
+	return isArrayBufferBacked(data) ? data : new Uint8Array(data);
+}
+function isArrayBufferBacked(bytes) {
+	return bytes.buffer instanceof ArrayBuffer;
+}
 /** Convert an ArrayBuffer to a hex string */
 function bufferToHex(buffer) {
 	const bytes = new Uint8Array(buffer);
@@ -21,7 +30,7 @@ function bufferToBase64(buffer) {
 /**
 * Generate a hash of the given data
 *
-* @param data - String data to hash
+* @param data - Text or bytes to hash
 * @param options - Hash generation options
 * @returns Hex-encoded hash string
 *
@@ -34,14 +43,13 @@ function bufferToBase64(buffer) {
 async function generateHash(data, options = {}) {
 	const { algorithm = "sha256", encoding = "hex" } = options;
 	const webAlgorithm = ALGORITHM_MAP[algorithm];
-	const encoded = new TextEncoder().encode(data);
-	const hashBuffer = await globalThis.crypto.subtle.digest(webAlgorithm, encoded);
+	const hashBuffer = await globalThis.crypto.subtle.digest(webAlgorithm, digestInput(data));
 	return encoding === "base64" ? bufferToBase64(hashBuffer) : bufferToHex(hashBuffer);
 }
 /**
 * Generate a SHA-256 hash (recommended for most use cases)
 *
-* @param data - String data to hash
+* @param data - Text or bytes to hash
 * @returns Hex-encoded SHA-256 hash
 *
 * @example
@@ -56,7 +64,7 @@ async function sha256(data) {
 /**
 * Generate a SHA-512 hash (enhanced security for sensitive data)
 *
-* @param data - String data to hash
+* @param data - Text or bytes to hash
 * @returns Hex-encoded SHA-512 hash
 *
 * @example
@@ -89,7 +97,7 @@ async function hashObject(obj, options = {}) {
 /**
 * Verify that data matches a given hash
 *
-* @param data - String data to verify
+* @param data - Text or bytes to verify
 * @param expectedHash - Expected hash value
 * @param options - Hash generation options (must match hash generation)
 * @returns True if data matches the hash
@@ -104,7 +112,6 @@ async function hashObject(obj, options = {}) {
 async function verifyHash(data, expectedHash, options = {}) {
 	return await generateHash(data, options) === expectedHash;
 }
-//#endregion
 export { generateHash, hashObject, sha256, sha512, verifyHash };
 
 //# sourceMappingURL=index.js.map

package/dist/hash/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/hash/index.ts"],"sourcesContent":["/**\n * Hash utilities for HDF content\n * Provides cryptographic hashing functions for content identification and integrity verification\n * Uses the Web Crypto API (globalThis.crypto.subtle) for browser and Node.js compatibility\n */\n\n/**\n * Supported hash algorithms\n */\nexport type HashAlgorithm = 'sha256' | 'sha512';\n\n/**\n * Supported output encodings\n */\nexport type HashEncoding = 'hex' | 'base64';\n\n/**\n * Options for hash generation\n */\nexport interface HashOptions {\n  /** Hash algorithm (default: 'sha256') */\n  algorithm?: HashAlgorithm;\n  /** Output encoding (default: 'hex') */\n  encoding?: HashEncoding;\n}\n\n/** Map our algorithm names to Web Crypto algorithm identifiers */\nconst ALGORITHM_MAP: Record<HashAlgorithm, string> = {\n  sha256: 'SHA-256',\n  sha512: 'SHA-512',\n};\n\n/** Convert an ArrayBuffer to a hex string */\nfunction bufferToHex(buffer: ArrayBuffer): string {\n  const bytes = new Uint8Array(buffer);\n  let hex = '';\n  for (const b of bytes) {\n    hex += b.toString(16).padStart(2, '0');\n  }\n  return hex;\n}\n\n/** Convert an ArrayBuffer to a base64 string */\nfunction bufferToBase64(buffer: ArrayBuffer): string {\n  const bytes = new Uint8Array(buffer);\n  let binary = '';\n  for (const b of bytes) {\n    binary += String.fromCharCode(b);\n  }\n  return btoa(binary);\n}\n\n/**\n * Generate a hash of the given data\n *\n * @param data - String data to hash\n * @param options - Hash generation options\n * @returns Hex-encoded hash string\n *\n * @example\n * ```typescript\n * const hash = await generateHash('hello world');\n * // Returns: 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9'\n * ```\n */\nexport async function generateHash(data: string, options: HashOptions = {}): Promise<string> {\n  const { algorithm = 'sha256', encoding = 'hex' } = options;\n  const webAlgorithm = ALGORITHM_MAP[algorithm];\n  const encoded = new TextEncoder().encode(data);\n  const hashBuffer = await globalThis.crypto.subtle.digest(webAlgorithm, encoded);\n  return encoding === 'base64' ? bufferToBase64(hashBuffer) : bufferToHex(hashBuffer);\n}\n\n/**\n * Generate a SHA-256 hash (recommended for most use cases)\n *\n * @param data - String data to hash\n * @returns Hex-encoded SHA-256 hash\n *\n * @example\n * ```typescript\n * const hash = await sha256('hello world');\n * // Returns: 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9'\n * ```\n */\nexport async function sha256(data: string): Promise<string> {\n  return generateHash(data, { algorithm: 'sha256' });\n}\n\n/**\n * Generate a SHA-512 hash (enhanced security for sensitive data)\n *\n * @param data - String data to hash\n * @returns Hex-encoded SHA-512 hash\n *\n * @example\n * ```typescript\n * const hash = await sha512('hello world');\n * // Returns: '309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f'\n * ```\n */\nexport async function sha512(data: string): Promise<string> {\n  return generateHash(data, { algorithm: 'sha512' });\n}\n\n/**\n * Generate a hash of an object by stringifying it first\n * Useful for hashing HDF control objects or other structured data\n *\n * @param obj - Object to hash\n * @param options - Hash generation options\n * @returns Hex-encoded hash string\n *\n * @example\n * ```typescript\n * const control = { id: 'V-12345', title: 'Test Control' };\n * const hash = await hashObject(control);\n * // Returns hash of the JSON-stringified object\n * ```\n */\nexport async function hashObject(obj: unknown, options: HashOptions = {}): Promise<string> {\n  // JSON.stringify returns undefined for undefined, so handle it explicitly\n  const stringified = obj === undefined ? 'undefined' : JSON.stringify(obj);\n  return generateHash(stringified, options);\n}\n\n/**\n * Verify that data matches a given hash\n *\n * @param data - String data to verify\n * @param expectedHash - Expected hash value\n * @param options - Hash generation options (must match hash generation)\n * @returns True if data matches the hash\n *\n * @example\n * ```typescript\n * const data = 'hello world';\n * const hash = await sha256(data);\n * const isValid = await verifyHash(data, hash); // true\n * ```\n */\nexport async function verifyHash(\n  data: string,\n  expectedHash: string,\n  options: HashOptions = {}\n): Promise<boolean> {\n  const actualHash = await generateHash(data, options);\n  return actualHash === expectedHash;\n}\n"],"mappings":";;AA2BA,MAAM,gBAA+C;CACnD,QAAQ;CACR,QAAQ;AACV;;AAGA,SAAS,YAAY,QAA6B;CAChD,MAAM,QAAQ,IAAI,WAAW,MAAM;CACnC,IAAI,MAAM;CACV,KAAK,MAAM,KAAK,OACd,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;CAEvC,OAAO;AACT;;AAGA,SAAS,eAAe,QAA6B;CACnD,MAAM,QAAQ,IAAI,WAAW,MAAM;CACnC,IAAI,SAAS;CACb,KAAK,MAAM,KAAK,OACd,UAAU,OAAO,aAAa,CAAC;CAEjC,OAAO,KAAK,MAAM;AACpB;;;;;;;;;;;;;;AAeA,eAAsB,aAAa,MAAc,UAAuB,CAAC,GAAoB;CAC3F,MAAM,EAAE,YAAY,UAAU,WAAW,UAAU;CACnD,MAAM,eAAe,cAAc;CACnC,MAAM,UAAU,IAAI,YAAY,CAAC,CAAC,OAAO,IAAI;CAC7C,MAAM,aAAa,MAAM,WAAW,OAAO,OAAO,OAAO,cAAc,OAAO;CAC9E,OAAO,aAAa,WAAW,eAAe,UAAU,IAAI,YAAY,UAAU;AACpF;;;;;;;;;;;;;AAcA,eAAsB,OAAO,MAA+B;CAC1D,OAAO,aAAa,MAAM,EAAE,WAAW,SAAS,CAAC;AACnD;;;;;;;;;;;;;AAcA,eAAsB,OAAO,MAA+B;CAC1D,OAAO,aAAa,MAAM,EAAE,WAAW,SAAS,CAAC;AACnD;;;;;;;;;;;;;;;;AAiBA,eAAsB,WAAW,KAAc,UAAuB,CAAC,GAAoB;CAGzF,OAAO,aADa,QAAQ,KAAA,IAAY,cAAc,KAAK,UAAU,GAAG,GACvC,OAAO;AAC1C;;;;;;;;;;;;;;;;AAiBA,eAAsB,WACpB,MACA,cACA,UAAuB,CAAC,GACN;CAElB,OAAO,MADkB,aAAa,MAAM,OAAO,MAC7B;AACxB"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/hash/index.ts"],"sourcesContent":["/**\n * Hash utilities for HDF content\n * Provides cryptographic hashing functions for content identification and integrity verification\n * Uses the Web Crypto API (globalThis.crypto.subtle) for browser and Node.js compatibility\n */\n\n/**\n * Supported hash algorithms\n */\nexport type HashAlgorithm = 'sha256' | 'sha384' | 'sha512';\n\n/**\n * Supported output encodings\n */\nexport type HashEncoding = 'hex' | 'base64';\n\n/**\n * Data that can be hashed: text, hashed as its UTF-8 bytes, or raw bytes\n */\nexport type HashInput = string | Uint8Array;\n\n/**\n * Options for hash generation\n */\nexport interface HashOptions {\n  /** Hash algorithm (default: 'sha256') */\n  algorithm?: HashAlgorithm;\n  /** Output encoding (default: 'hex') */\n  encoding?: HashEncoding;\n}\n\n/** Map our algorithm names to Web Crypto algorithm identifiers */\nconst ALGORITHM_MAP: Record<HashAlgorithm, string> = {\n  sha256: 'SHA-256',\n  sha384: 'SHA-384',\n  sha512: 'SHA-512',\n};\n\n/** Web Crypto refuses a view over shared memory, so such a view is copied first. */\nfunction digestInput(data: HashInput): Uint8Array<ArrayBuffer> {\n  if (typeof data === 'string') {\n    return new TextEncoder().encode(data);\n  }\n  return isArrayBufferBacked(data) ? data : new Uint8Array(data);\n}\n\nfunction isArrayBufferBacked(bytes: Uint8Array): bytes is Uint8Array<ArrayBuffer> {\n  return bytes.buffer instanceof ArrayBuffer;\n}\n\n/** Convert an ArrayBuffer to a hex string */\nfunction bufferToHex(buffer: ArrayBuffer): string {\n  const bytes = new Uint8Array(buffer);\n  let hex = '';\n  for (const b of bytes) {\n    hex += b.toString(16).padStart(2, '0');\n  }\n  return hex;\n}\n\n/** Convert an ArrayBuffer to a base64 string */\nfunction bufferToBase64(buffer: ArrayBuffer): string {\n  const bytes = new Uint8Array(buffer);\n  let binary = '';\n  for (const b of bytes) {\n    binary += String.fromCharCode(b);\n  }\n  return btoa(binary);\n}\n\n/**\n * Generate a hash of the given data\n *\n * @param data - Text or bytes to hash\n * @param options - Hash generation options\n * @returns Hex-encoded hash string\n *\n * @example\n * ```typescript\n * const hash = await generateHash('hello world');\n * // Returns: 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9'\n * ```\n */\nexport async function generateHash(data: HashInput, options: HashOptions = {}): Promise<string> {\n  const { algorithm = 'sha256', encoding = 'hex' } = options;\n  const webAlgorithm = ALGORITHM_MAP[algorithm];\n  const hashBuffer = await globalThis.crypto.subtle.digest(webAlgorithm, digestInput(data));\n  return encoding === 'base64' ? bufferToBase64(hashBuffer) : bufferToHex(hashBuffer);\n}\n\n/**\n * Generate a SHA-256 hash (recommended for most use cases)\n *\n * @param data - Text or bytes to hash\n * @returns Hex-encoded SHA-256 hash\n *\n * @example\n * ```typescript\n * const hash = await sha256('hello world');\n * // Returns: 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9'\n * ```\n */\nexport async function sha256(data: HashInput): Promise<string> {\n  return generateHash(data, { algorithm: 'sha256' });\n}\n\n/**\n * Generate a SHA-512 hash (enhanced security for sensitive data)\n *\n * @param data - Text or bytes to hash\n * @returns Hex-encoded SHA-512 hash\n *\n * @example\n * ```typescript\n * const hash = await sha512('hello world');\n * // Returns: '309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f'\n * ```\n */\nexport async function sha512(data: HashInput): Promise<string> {\n  return generateHash(data, { algorithm: 'sha512' });\n}\n\n/**\n * Generate a hash of an object by stringifying it first\n * Useful for hashing HDF control objects or other structured data\n *\n * @param obj - Object to hash\n * @param options - Hash generation options\n * @returns Hex-encoded hash string\n *\n * @example\n * ```typescript\n * const control = { id: 'V-12345', title: 'Test Control' };\n * const hash = await hashObject(control);\n * // Returns hash of the JSON-stringified object\n * ```\n */\nexport async function hashObject(obj: unknown, options: HashOptions = {}): Promise<string> {\n  // JSON.stringify returns undefined for undefined, so handle it explicitly\n  const stringified = obj === undefined ? 'undefined' : JSON.stringify(obj);\n  return generateHash(stringified, options);\n}\n\n/**\n * Verify that data matches a given hash\n *\n * @param data - Text or bytes to verify\n * @param expectedHash - Expected hash value\n * @param options - Hash generation options (must match hash generation)\n * @returns True if data matches the hash\n *\n * @example\n * ```typescript\n * const data = 'hello world';\n * const hash = await sha256(data);\n * const isValid = await verifyHash(data, hash); // true\n * ```\n */\nexport async function verifyHash(\n  data: HashInput,\n  expectedHash: string,\n  options: HashOptions = {}\n): Promise<boolean> {\n  const actualHash = await generateHash(data, options);\n  return actualHash === expectedHash;\n}\n"],"mappings":";;AAgCA,MAAM,gBAA+C;CACnD,QAAQ;CACR,QAAQ;CACR,QAAQ;AACV;;AAGA,SAAS,YAAY,MAA0C;CAC7D,IAAI,OAAO,SAAS,UAClB,OAAO,IAAI,YAAY,CAAC,CAAC,OAAO,IAAI;CAEtC,OAAO,oBAAoB,IAAI,IAAI,OAAO,IAAI,WAAW,IAAI;AAC/D;AAEA,SAAS,oBAAoB,OAAqD;CAChF,OAAO,MAAM,kBAAkB;AACjC;;AAGA,SAAS,YAAY,QAA6B;CAChD,MAAM,QAAQ,IAAI,WAAW,MAAM;CACnC,IAAI,MAAM;CACV,KAAK,MAAM,KAAK,OACd,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;CAEvC,OAAO;AACT;;AAGA,SAAS,eAAe,QAA6B;CACnD,MAAM,QAAQ,IAAI,WAAW,MAAM;CACnC,IAAI,SAAS;CACb,KAAK,MAAM,KAAK,OACd,UAAU,OAAO,aAAa,CAAC;CAEjC,OAAO,KAAK,MAAM;AACpB;;;;;;;;;;;;;;AAeA,eAAsB,aAAa,MAAiB,UAAuB,CAAC,GAAoB;CAC9F,MAAM,EAAE,YAAY,UAAU,WAAW,UAAU;CACnD,MAAM,eAAe,cAAc;CACnC,MAAM,aAAa,MAAM,WAAW,OAAO,OAAO,OAAO,cAAc,YAAY,IAAI,CAAC;CACxF,OAAO,aAAa,WAAW,eAAe,UAAU,IAAI,YAAY,UAAU;AACpF;;;;;;;;;;;;;AAcA,eAAsB,OAAO,MAAkC;CAC7D,OAAO,aAAa,MAAM,EAAE,WAAW,SAAS,CAAC;AACnD;;;;;;;;;;;;;AAcA,eAAsB,OAAO,MAAkC;CAC7D,OAAO,aAAa,MAAM,EAAE,WAAW,SAAS,CAAC;AACnD;;;;;;;;;;;;;;;;AAiBA,eAAsB,WAAW,KAAc,UAAuB,CAAC,GAAoB;CAGzF,OAAO,aADa,QAAQ,KAAA,IAAY,cAAc,KAAK,UAAU,GAAG,GACvC,OAAO;AAC1C;;;;;;;;;;;;;;;;AAiBA,eAAsB,WACpB,MACA,cACA,UAAuB,CAAC,GACN;CAElB,OAAO,MADkB,aAAa,MAAM,OAAO,MAC7B;AACxB"}

package/dist/{index-i4P63h9e.d.ts → index-CdhaEDAp.d.ts}

@@ -1,4 +1,3 @@
-//#region src/json/canonical.d.ts
 /**
  * Canonical JSON — the encoding HDF uses for content-addressed checksums, such
  * as the amendment chain's `previousChecksum`.
@@ -26,8 +25,6 @@
 declare function canonicalJson(value: unknown): string;
 /** Returns the hex-encoded SHA-256 of a value's canonical JSON encoding. */
 declare function canonicalChecksum(value: unknown): Promise<string>;
-//#endregion
-//#region src/json/index.d.ts
 /**
  * Options for JSON stringification
  */
@@ -78,6 +75,5 @@ declare function isValidJSON(input: unknown): boolean;
  * documented cross-language divergence, not something this helper can close.
  */
 declare function formatJsonNumber(value: number): string;
-//#endregion
 export { stringifyJSON as a, parseJSON as i, formatJsonNumber as n, canonicalChecksum as o, isValidJSON as r, canonicalJson as s, StringifyOptions as t };
-//# sourceMappingURL=index-i4P63h9e.d.ts.map
+//# sourceMappingURL=index-CdhaEDAp.d.ts.map

package/dist/index-CdhaEDAp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CdhaEDAp.d.ts","names":[],"sources":["../src/json/canonical.ts","../src/json/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;iBAkIgB,cAAc;;iBAKR,kBAAkB,iBAAiB;;;;UCjIxC;;EAEf;;EAEA;;;;;;;;iBASc,UAAU,aAAa,gBAAgB;;;;;;;;iBAuBvC,cAAc,gBAAgB,UAAS;;;;;;iBAkBvC,YAAY;;;;;;;;;;;;;;;;;;;;iBAoCZ,iBAAiB"}

package/dist/index.d.ts

@@ -1,10 +1,9 @@
 import { extractColumn, findRows, findValuesByKey } from "./object/index.js";
 import { CsvBuildOptions, CsvParseOptions, buildCsv, buildCsvArray, isValidCsv, parseCsv, parseCsvArray, sanitizeCsvArray, sanitizeCsvObject, sanitizeCsvValue } from "./csv/index.js";
-import { HashAlgorithm, HashEncoding, HashOptions, generateHash, hashObject, sha256, sha512, verifyHash } from "./hash/index.js";
-import { a as stringifyJSON, i as parseJSON, n as formatJsonNumber, o as canonicalChecksum, r as isValidJSON, s as canonicalJson, t as StringifyOptions } from "./index-i4P63h9e.js";
-import { buildXml, extractTextFromXml, isValidXml, isXmlChar, parseXml, parseXmlWithArrays, xmlSafeText } from "./xml/index.js";
+import { HashAlgorithm, HashEncoding, HashInput, HashOptions, generateHash, hashObject, sha256, sha512, verifyHash } from "./hash/index.js";
+import { a as stringifyJSON, i as parseJSON, n as formatJsonNumber, o as canonicalChecksum, r as isValidJSON, s as canonicalJson, t as StringifyOptions } from "./index-CdhaEDAp.js";
+import { XmlPrologueDeclarations, buildXml, containsXmlDoctype, containsXmlEntityDeclarations, extractTextFromXml, inspectXmlPrologue, isValidXml, isXmlChar, parseXml, parseXmlWithArrays, xmlSafeText } from "./xml/index.js";
 import { absentIfGoZeroTime, encodeBase64Utf8, formatTimestamp, formatTimestampSeconds, isGoZeroTime, normalizeHdfTimestamps, parseTimestamp, replaceHtmlTags, stripHtml, trimUtcFraction } from "./string/index.js";
-//#region src/severity/index.d.ts
 /**
  * Severity-to-impact mapping utilities.
  *
@@ -82,8 +81,6 @@ export declare function cvssScoreToSeverity(score: number): 'none' | 'low' | 'me
  * marker so a defaulted impact stays distinguishable from a genuine medium.
  */
 export declare function isUnratedSeverity(severity?: string | null): boolean;
-//#endregion
-//#region src/status/index.d.ts
 /**
  * Canonical HDF result-status ordering and effective-status computation.
  *
@@ -187,8 +184,6 @@ export declare function governingImpactOverrideIndex(overrides: readonly StatusO
  * Parity: ComputeEffectiveImpact in go/status.go.
  */
 export declare function computeEffectiveImpact(input: EffectiveStatusInput, referenceTimestamp?: string): number;
-//#endregion
-//#region src/cvss/index.d.ts
 /**
  * CVSS vector parsing and validation utilities.
  *
@@ -276,8 +271,6 @@ export declare function cvss40MacroVector(vector: string): string;
  *   metric value is out of the 4.0 enum.
  */
 export declare function computeCvss40Score(vector: string): CvssScore;
-//#endregion
-//#region src/cwe/index.d.ts
 /**
  * CWE identifier extraction — the TypeScript twin of hdf-utilities/go/cwe.go.
  *
@@ -293,8 +286,6 @@ export declare const CWE_PATTERN: RegExp;
  * names none. Parity: ExtractCWEIDs in go/cwe.go.
  */
 export declare function extractCWEIDs(text: string): string[];
-//#endregion
-//#region src/cpe/index.d.ts
 /**
  * CPE 2.3 URI parser for HDF converters.
  *
@@ -365,8 +356,6 @@ interface ParsedCpe {
  * ```
  */
 export declare function parseCpe(cpeUri: string): ParsedCpe | null;
-//#endregion
-//#region src/purl/index.d.ts
 /**
  * Package URL (PURL) parser for SBOM and CVE-scanner ingestion.
  *
@@ -421,8 +410,6 @@ interface ParsedPurl {
  * ```
  */
 export declare function parsePurl(purlStr: string): ParsedPurl | null;
-//#endregion
-//#region src/size/index.d.ts
 /** Default maximum input size (256 MB), matching the Go DefaultMaxInputSize. */
 export declare const DEFAULT_MAX_INPUT_SIZE: number;
 /**
@@ -443,6 +430,5 @@ export declare function resolveMaxInputSize(maxSize?: number): number;
  * string input, so it matches the Go []byte length for the same document.
  */
 export declare function validateInputSize(input: string | Uint8Array, maxSize?: number): void;
-//#endregion
-export { type CpePart, type CsvBuildOptions, type CsvParseOptions, type CvssScore, type CvssValidationResult, type EffectiveStatusInput, type HashAlgorithm, type HashEncoding, type HashOptions, type ParsedCpe, type ParsedCvssVector, type ParsedPurl, type StatusOverrideInput, type StatusSeverity, type StringifyOptions, absentIfGoZeroTime, buildCsv, buildCsvArray, buildXml, canonicalChecksum, canonicalJson, encodeBase64Utf8, extractColumn, extractColumn as extractCsvColumn, extractTextFromXml, findRows as findCsvRows, findRows, findValuesByKey as findJsonValues, findValuesByKey, findValuesByKey as findXmlValues, formatJsonNumber, formatTimestamp, formatTimestampSeconds, generateHash, hashObject, isGoZeroTime, isValidCsv, isValidJSON, isValidXml, isXmlChar, normalizeHdfTimestamps, parseCsv, parseCsvArray, parseJSON, parseTimestamp, parseXml, parseXmlWithArrays, replaceHtmlTags, sanitizeCsvArray, sanitizeCsvObject, sanitizeCsvValue, sha256, sha512, stringifyJSON, stripHtml, trimUtcFraction, verifyHash, xmlSafeText };
+export { type CpePart, type CsvBuildOptions, type CsvParseOptions, type CvssScore, type CvssValidationResult, type EffectiveStatusInput, type HashAlgorithm, type HashEncoding, type HashInput, type HashOptions, type ParsedCpe, type ParsedCvssVector, type ParsedPurl, type StatusOverrideInput, type StatusSeverity, type StringifyOptions, type XmlPrologueDeclarations, absentIfGoZeroTime, buildCsv, buildCsvArray, buildXml, canonicalChecksum, canonicalJson, containsXmlDoctype, containsXmlEntityDeclarations, encodeBase64Utf8, extractColumn, extractColumn as extractCsvColumn, extractTextFromXml, findRows as findCsvRows, findRows, findValuesByKey as findJsonValues, findValuesByKey, findValuesByKey as findXmlValues, formatJsonNumber, formatTimestamp, formatTimestampSeconds, generateHash, hashObject, inspectXmlPrologue, isGoZeroTime, isValidCsv, isValidJSON, isValidXml, isXmlChar, normalizeHdfTimestamps, parseCsv, parseCsvArray, parseJSON, parseTimestamp, parseXml, parseXmlWithArrays, replaceHtmlTags, sanitizeCsvArray, sanitizeCsvObject, sanitizeCsvValue, sha256, sha512, stringifyJSON, stripHtml, trimUtcFraction, verifyHash, xmlSafeText };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/severity/index.ts","../src/status/index.ts","../src/cvss/index.ts","../src/cwe/index.ts","../src/cpe/index.ts","../src/purl/index.ts","../src/size/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;wBAgCgB,iBAAiB;wBACjB,iBAAiB;wBACjB,iBAAiB;;;;;;;;;;wBAsBjB,4BACd,qCACA,SAAS,wBACT;;;;;;;;;wBAkBc,YAAY;;;;;;;wBAUZ,iBAAiB;wBACjB,iBAAiB;wBACjB,iBAAiB;;;;;;;;;;;;;;;;;;wBA2BjB,oBACd;;;;;;;;wBAsBc,kBAAkB;;;;;;;;;;;;qBC/HrB;;KASD,yBAAyB;;wBAMrB,WAAW;;;;;wBASX,YAAY;;;;;UAiBX;;EAEf;;EAEA;;EAEA;;;;;;EAMA;;;;;;;;wBAiBc,wBACd,oBAAoB,uBACpB,8BACC;;;;;;;;;wBAaa,uBACd,oBAAoB,uBACpB,WAAW,2BACX;;;;;;wBAmBc,6BACd,oBAAoB,uBACpB;;UAgBe;EACf;EACA;EACA,qBAAqB;;;;;;;;;;;;;;;wBAgBP,uBACd,OAAO,sBACP;;;;;;;;;;wBAuBc,6BACd,oBAAoB,uBACpB;;;;;;;;;;;;;;wBAsBc,uBACd,OAAO,sBACP;;;;;;;;;;;;;;;UCjMe;;EAEf;;EAEA,SAAS;;UAGM;EACf;EACA;;;;;;;;;;;;wBA2Ic,gBAAgB,iBAAiB;;;;;;;;;;;;;;;;;;wBA4DjC,mBACd,gBACA,mBACC;;UAsCc;;EAEf;;EAEA;;;;;EAKA;;;;;;;;;;;;wBAsDc,iBAAiB,iBAAiB;;wBA6KlC,kBAAkB;;;;;;;;;;;wBAiMlB,mBAAmB,iBAAiB;;;;;;;;;;;qBC5qBvC,aAAW;;;;;;wBAOR,cAAc;;;;;;;;;;;;;;;;;;KCAlB;;;;;;;;UASK;;EAEf;;EAEA,MAAM;EACN;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAuEc,SAAS,iBAAiB;;;;;;;;;;;;;;;;;;;UC/FzB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,YAAY;;EAEZ;;EAEA;;;;;;;;;;;;;;;;;;;;;wBAwBc,UAAU,kBAAkB;;;;qBCpD/B;;;;;wBAaG,uBAAuB;;;;;;wBASvB,oBAAoB;;;;;;;wBAYpB,kBAAkB,gBAAgB,YAAY"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/severity/index.ts","../src/status/index.ts","../src/cvss/index.ts","../src/cwe/index.ts","../src/cpe/index.ts","../src/purl/index.ts","../src/size/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;wBAgCgB,iBAAiB;wBACjB,iBAAiB;wBACjB,iBAAiB;;;;;;;;;;wBAsBjB,4BACd,qCACA,SAAS,wBACT;;;;;;;;;wBAkBc,YAAY;;;;;;;wBAUZ,iBAAiB;wBACjB,iBAAiB;wBACjB,iBAAiB;;;;;;;;;;;;;;;;;;wBA2BjB,oBACd;;;;;;;;wBAsBc,kBAAkB;;;;;;;;;;qBC/HrB;;KASD,yBAAyB;;wBAMrB,WAAW;;;;;wBASX,YAAY;;;;;UAiBX;;EAEf;;EAEA;;EAEA;;;;;;EAMA;;;;;;;;wBAiBc,wBACd,oBAAoB,uBACpB,8BACC;;;;;;;;;wBAaa,uBACd,oBAAoB,uBACpB,WAAW,2BACX;;;;;;wBAmBc,6BACd,oBAAoB,uBACpB;;UAgBe;EACf;EACA;EACA,qBAAqB;;;;;;;;;;;;;;;wBAgBP,uBACd,OAAO,sBACP;;;;;;;;;;wBAuBc,6BACd,oBAAoB,uBACpB;;;;;;;;;;;;;;wBAsBc,uBACd,OAAO,sBACP;;;;;;;;;;;;;UCjMe;;EAEf;;EAEA,SAAS;;UAGM;EACf;EACA;;;;;;;;;;;;wBA2Ic,gBAAgB,iBAAiB;;;;;;;;;;;;;;;;;;wBA4DjC,mBACd,gBACA,mBACC;;UAsCc;;EAEf;;EAEA;;;;;EAKA;;;;;;;;;;;;wBAsDc,iBAAiB,iBAAiB;;wBA6KlC,kBAAkB;;;;;;;;;;;wBAiMlB,mBAAmB,iBAAiB;;;;;;;;;qBC5qBvC,aAAW;;;;;;wBAOR,cAAc;;;;;;;;;;;;;;;;KCAlB;;;;;;;;UASK;;EAEf;;EAEA,MAAM;EACN;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAuEc,SAAS,iBAAiB;;;;;;;;;;;;;;;;;UC/FzB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,YAAY;;EAEZ;;EAEA;;;;;;;;;;;;;;;;;;;;;wBAwBc,UAAU,kBAAkB;;qBCpD/B;;;;;wBAaG,uBAAuB;;;;;;wBASvB,oBAAoB;;;;;;;wBAYpB,kBAAkB,gBAAgB,YAAY"}

package/dist/index.js

@@ -1,10 +1,10 @@
-import { a as canonicalChecksum, i as stringifyJSON, n as isValidJSON, o as canonicalJson, r as parseJSON, t as formatJsonNumber } from "./json-DdbPTX2g.js";
+import { a as canonicalChecksum, i as stringifyJSON, n as isValidJSON, o as canonicalJson, r as parseJSON, t as formatJsonNumber } from "./json-gD9tW9Dt.js";
 import { extractColumn, findRows, findValuesByKey } from "./object/index.js";
 import { generateHash, hashObject, sha256, sha512, verifyHash } from "./hash/index.js";
-import { buildXml, extractTextFromXml, isValidXml, isXmlChar, parseXml, parseXmlWithArrays, xmlSafeText } from "./xml/index.js";
+import { buildXml, containsXmlDoctype, containsXmlEntityDeclarations, extractTextFromXml, inspectXmlPrologue, isValidXml, isXmlChar, parseXml, parseXmlWithArrays, xmlSafeText } from "./xml/index.js";
 import { buildCsv, buildCsvArray, isValidCsv, parseCsv, parseCsvArray, sanitizeCsvArray, sanitizeCsvObject, sanitizeCsvValue } from "./csv/index.js";
 import { absentIfGoZeroTime, encodeBase64Utf8, formatTimestamp, formatTimestampSeconds, isGoZeroTime, normalizeHdfTimestamps, parseTimestamp, replaceHtmlTags, stripHtml, trimUtcFraction } from "./string/index.js";
-//#region src/severity/index.ts
+// src/severity/index.ts
 /**
 * Severity-to-impact mapping utilities.
 *
@@ -109,8 +109,7 @@ function isUnratedSeverity(severity) {
 	const s = severity.trim().toLowerCase();
 	return s === "" || unratedSeverityTokens.has(s);
 }
-//#endregion
-//#region src/status/index.ts
+// src/status/index.ts
 /**
 * Canonical HDF result-status ordering and effective-status computation.
 *
@@ -249,8 +248,7 @@ function computeEffectiveImpact(input, referenceTimestamp) {
 	if (index >= 0) return input.overrides[index].impact;
 	return input.impact;
 }
-//#endregion
-//#region src/cvss/cvss40-data.json
+// src/cvss/cvss40-data.json
 var cvss40_data_default = {
 	_comment: "CVSS 4.0 scoring data tables extracted VERBATIM from the FIRST reference calculator (https://github.com/FIRSTdotorg/cvss-v4-calculator; cvss_lookup.js / max_composed.js / max_severity.js). Regenerate via scratchpad/extract-data.mjs. Consumed byte-identical by Go (go/cvss40-data.json, //go:embed) and TS (src/cvss/cvss40-data.json).",
 	lookup: {
@@ -600,8 +598,7 @@ var cvss40_data_default = {
 		}
 	}
 };
-//#endregion
-//#region src/cvss/index.ts
+// src/cvss/index.ts
 /**
 * CVSS vector parsing and validation utilities.
 *
@@ -1606,8 +1603,7 @@ function computeCvss40Score(vector) {
 		temporalScore
 	};
 }
-//#endregion
-//#region src/cwe/index.ts
+// src/cwe/index.ts
 /**
 * CWE identifier extraction — the TypeScript twin of hdf-utilities/go/cwe.go.
 *
@@ -1629,8 +1625,7 @@ function extractCWEIDs(text) {
 	ids.sort();
 	return ids;
 }
-//#endregion
-//#region src/cpe/index.ts
+// src/cpe/index.ts
 const CPE_PREFIX = "cpe:2.3:";
 const EXPECTED_TOTAL_FIELDS = 13;
 const PRODUCT_FIELD_COUNT = 11;
@@ -1730,8 +1725,7 @@ function parseCpe(cpeUri) {
 		warnings
 	};
 }
-//#endregion
-//#region src/purl/index.ts
+// src/purl/index.ts
 const PURL_PREFIX = "pkg:";
 /**
 * Parse a Package URL string.
@@ -1850,8 +1844,7 @@ function safeDecode(s) {
 		return s;
 	}
 }
-//#endregion
-//#region src/size/index.ts
+// src/size/index.ts
 /** Default maximum input size (256 MB), matching the Go DefaultMaxInputSize. */
 const DEFAULT_MAX_INPUT_SIZE = 268435456;
 let configuredMaxInputSize = 0;
@@ -1910,7 +1903,6 @@ function utf8ByteLength(s) {
 	}
 	return bytes;
 }
-//#endregion
-export { CWE_PATTERN, DEFAULT_MAX_INPUT_SIZE, STATUS_SEVERITY_ORDER, absentIfGoZeroTime, buildCsv, buildCsvArray, buildXml, canonicalChecksum, canonicalJson, computeCvss40Score, computeCvssScore, computeEffectiveImpact, computeEffectiveStatus, cvss40MacroVector, cvssScoreToSeverity, encodeBase64Utf8, extractCWEIDs, extractColumn, extractColumn as extractCsvColumn, extractTextFromXml, findRows as findCsvRows, findRows, findValuesByKey as findJsonValues, findValuesByKey, findValuesByKey as findXmlValues, formatJsonNumber, formatTimestamp, formatTimestampSeconds, generateHash, governingImpactOverrideIndex, governingOverrideIndex, governingStatusOverride, governingStatusOverrideIndex, hashObject, impactToSeverity, isGoZeroTime, isUnratedSeverity, isValidCsv, isValidJSON, isValidXml, isXmlChar, normalizeHdfTimestamps, parseCpe, parseCsv, parseCsvArray, parseCvssVector, parseJSON, parsePurl, parseTimestamp, parseXml, parseXmlWithArrays, replaceHtmlTags, resolveMaxInputSize, roundImpact, sanitizeCsvArray, sanitizeCsvObject, sanitizeCsvValue, setDefaultMaxInputSize, severityToImpact, severityToImpactWithAliases, sha256, sha512, statusRank, stringifyJSON, stripHtml, trimUtcFraction, validateCvssVector, validateInputSize, verifyHash, worstStatus, xmlSafeText };
+export { CWE_PATTERN, DEFAULT_MAX_INPUT_SIZE, STATUS_SEVERITY_ORDER, absentIfGoZeroTime, buildCsv, buildCsvArray, buildXml, canonicalChecksum, canonicalJson, computeCvss40Score, computeCvssScore, computeEffectiveImpact, computeEffectiveStatus, containsXmlDoctype, containsXmlEntityDeclarations, cvss40MacroVector, cvssScoreToSeverity, encodeBase64Utf8, extractCWEIDs, extractColumn, extractColumn as extractCsvColumn, extractTextFromXml, findRows as findCsvRows, findRows, findValuesByKey as findJsonValues, findValuesByKey, findValuesByKey as findXmlValues, formatJsonNumber, formatTimestamp, formatTimestampSeconds, generateHash, governingImpactOverrideIndex, governingOverrideIndex, governingStatusOverride, governingStatusOverrideIndex, hashObject, impactToSeverity, inspectXmlPrologue, isGoZeroTime, isUnratedSeverity, isValidCsv, isValidJSON, isValidXml, isXmlChar, normalizeHdfTimestamps, parseCpe, parseCsv, parseCsvArray, parseCvssVector, parseJSON, parsePurl, parseTimestamp, parseXml, parseXmlWithArrays, replaceHtmlTags, resolveMaxInputSize, roundImpact, sanitizeCsvArray, sanitizeCsvObject, sanitizeCsvValue, setDefaultMaxInputSize, severityToImpact, severityToImpactWithAliases, sha256, sha512, statusRank, stringifyJSON, stripHtml, trimUtcFraction, validateCvssVector, validateInputSize, verifyHash, worstStatus, xmlSafeText };
 
 //# sourceMappingURL=index.js.map