http-vary 0.0.1 → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 - present Arthur Fiorette
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/compare.d.ts

@@ -33,5 +33,5 @@ import type { CompareHeaders, VaryHeader } from './types';
  * @returns {boolean} `true` if the headers are equivalent for the given Vary header,
  *   `false` otherwise
  */
-export declare function compare(vary: VaryHeader, source: CompareHeaders, target: CompareHeaders): boolean;
+export declare function compare(vary: VaryHeader, source: CompareHeaders, target: CompareHeaders): vary is string[];
 //# sourceMappingURL=compare.d.ts.map

package/dist/compare.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../src/compare.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,OAAO,CACrB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,GACrB,OAAO,CAoCT"}
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../src/compare.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,OAAO,CACrB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,cAAc,GACrB,IAAI,IAAI,MAAM,EAAE,CAoClB"}

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/parse.ts","../src/compare.ts"],"sourcesContent":["import type { VaryHeader } from './types';\n\nconst VALID_HEADER_NAME_REGEX = /^[a-z0-9-]+$/i;\n\n/**\n * Parses the Vary header as defined in\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * The Vary header indicates which request headers a server considers when selecting or\n * generating a response, enabling proper HTTP caching behavior.\n *\n * @remarks\n * - Header field names are normalized to lowercase\n * - Duplicate fields are automatically deduplicated\n * - Invalid header names (per RFC 9110) are silently skipped\n * - If the header contains `'*'`, the function returns `'*'` (wildcard)\n * - Returns `null` for invalid input or when no valid fields are found\n *\n * @example\n *\n * ```ts\n * parse('Accept-Encoding, User-Agent');\n * // => ['accept-encoding', 'user-agent']\n *\n * parse('*');\n * // => '*'\n *\n * parse('Invalid Header!');\n * // => null\n * ```\n *\n * @param {string} headerStr - The Vary header value to parse (e.g., \"Accept-Encoding,\n *   User-Agent\")\n * @param {number} [maxLength=16] - Maximum number of header fields to parse for DoS\n *   protection. Default is `16`\n * @returns {VaryHeader | null} The parsed Vary header as an array of lowercase field\n *   names, `'*'` for wildcard, or `null` if invalid.\n */\nexport function parse(headerStr?: string, maxLength = 16): VaryHeader | null {\n  // Invalid header name\n  if (typeof headerStr !== 'string') {\n    return null;\n  }\n\n  // RFC says only '*' is valid alone, but some servers may send invalid headers like '*, Accept-Encoding'\n  if (headerStr.includes('*')) {\n    return '*';\n  }\n\n  const values = new Set<string>();\n\n  for (let i = 0; i < headerStr.length; i++) {\n    const char = headerStr[i];\n\n    if (char === ' ' || char === '\\t' || char === ',') {\n      continue;\n    }\n\n    const start = i;\n\n    while (i < headerStr.length) {\n      const char = headerStr[i];\n\n      if (char === ',') {\n        break;\n      }\n\n      i++;\n    }\n\n    const headerName = headerStr.slice(start, i).trim().toLowerCase();\n\n    // Skip invalid header names\n    if (headerName.length === 0 || !VALID_HEADER_NAME_REGEX.test(headerName)) {\n      continue;\n    }\n\n    values.add(headerName);\n\n    // DOS protection to avoid overly large vary headers\n    if (values.size >= maxLength) {\n      break;\n    }\n  }\n\n  // Ensures no empty set is returned\n  if (values.size === 0) {\n    return null;\n  }\n\n  return Array.from(values);\n}\n","import type { CompareHeaders, VaryHeader } from './types';\n\n/**\n * Checks if {@linkcode source} and {@linkcode target} headers are equivalent for the given\n * Vary header, as per\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * This function determines if two requests would receive the same cached response based\n * on the Vary header requirements.\n *\n * @remarks\n * - Returns `false` for wildcard vary (`'*'`) as responses always differ\n * - Header name matching is case-insensitive (per RFC 9110)\n * - Missing headers are treated as `undefined`\n * - String values are trimmed before comparison\n * - Array values are converted to strings via `.toString()`\n * - Uses loose equality (!=) for comparison\n * - Empty strings are distinct from missing headers\n *\n * @example\n *\n * ```ts\n * const vary = ['accept-encoding', 'user-agent'];\n * const headers1 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n * const headers2 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n *\n * compare(vary, headers1, headers2);\n * // => true\n * ```\n *\n * @param {VaryHeader} vary - The Vary header specifying which fields to compare\n * @param {CompareHeaders} source - The first set of request headers\n * @param {CompareHeaders} target - The second set of request headers\n * @returns {boolean} `true` if the headers are equivalent for the given Vary header,\n *   `false` otherwise\n */\nexport function compare(\n  vary: VaryHeader,\n  source: CompareHeaders,\n  target: CompareHeaders\n): boolean {\n  // Wildcard always differs\n  if (vary === '*') {\n    return false;\n  }\n\n  const sourceKeys = Object.keys(source);\n  const targetKeys = Object.keys(target);\n\n  for (const field of vary) {\n    let sourceValue: string | undefined;\n    let targetValue: string | undefined;\n\n    // Case-insensitive header lookup in source\n    for (const key of sourceKeys) {\n      if (key.toLowerCase() === field) {\n        sourceValue = source[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // Case-insensitive header lookup in target\n    for (const key of targetKeys) {\n      if (key.toLowerCase() === field) {\n        targetValue = target[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // biome-ignore lint/suspicious/noDoubleEquals: Intentional loose comparison\n    if (sourceValue != targetValue) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"names":["VALID_HEADER_NAME_REGEX","vary","source","target","_step","sourceKeys","Object","keys","targetKeys","_iterator","_createForOfIteratorHelperLoose","done","_step2","field","value","sourceValue","targetValue","_iterator2","key","toLowerCase","_source$key","toString","trim","_step3","_iterator3","_target$_key","headerStr","maxLength","includes","values","Set","i","length","char","start","headerName","slice","test","add","size","Array","from"],"mappings":"oyBAEA,IAAMA,EAA0B,yCCmC9BC,EACAC,EACAC,GAGA,GAAa,MAATF,EACF,OACF,EAKA,IAHA,IAGwBG,EAHlBC,EAAaC,OAAOC,KAAKL,GACzBM,EAAaF,OAAOC,KAAKJ,GAE/BM,EAAAC,EAAoBT,KAAIG,EAAAK,KAAAE,MAAE,CAKxB,IALS,IAKmBC,EALnBC,EAAKT,EAAAU,MACVC,OAA+B,EAC/BC,OAGJ,EAAAC,EAAAP,EAAkBL,KAAUO,EAAAK,KAAAN,MAAE,CAAA,IAAnBO,EAAGN,EAAAE,MACZ,GAAII,EAAIC,gBAAkBN,EAAO,CAAA,IAAAO,EAC/BL,SAAWK,EAAGlB,EAAOgB,KAAgB,OAAZE,EAAXA,EAAaC,iBAAU,EAAvBD,EAAyBE,OACvC,KACF,CACF,CAGA,IAAA,IAA4BC,EAA5BC,EAAAd,EAAkBF,KAAUe,EAAAC,KAAAb,MAAE,CAAnB,IAAAO,EAAGK,EAAAT,MACZ,GAAII,EAAIC,gBAAkBN,EAAO,CAAAY,IAAAA,EAC/BT,EAAyBS,OAAdA,EAAGtB,EAAOe,KAAPO,OAAWA,EAAXA,EAAaJ,iBAAbI,EAAAA,EAAyBH,OACvC,KACF,CACF,CAGA,GAAIP,GAAeC,EACjB,OACF,CACF,CAEA,OACF,CAAA,yBDtCsBU,EAAoBC,GAExC,YAFwCA,IAAAA,EAAY,IAE3B,iBAAdD,EACT,OACF,KAGA,GAAIA,EAAUE,SAAS,KACrB,MAAO,IAKT,IAFA,IAAMC,EAAS,IAAIC,IAEVC,EAAI,EAAGA,EAAIL,EAAUM,OAAQD,IAAK,CACzC,IAAME,EAAOP,EAAUK,GAEvB,GAAa,MAATE,GAAyB,OAATA,GAA0B,MAATA,EAArC,CAMA,IAFA,IAAMC,EAAQH,EAEPA,EAAIL,EAAUM,QAGN,MAFAN,EAAUK,IAMvBA,IAGF,IAAMI,EAAaT,EAAUU,MAAMF,EAAOH,GAAGT,OAAOH,cAGpD,GAA0B,IAAtBgB,EAAWH,QAAiBhC,EAAwBqC,KAAKF,KAI7DN,EAAOS,IAAIH,GAGPN,EAAOU,MAAQZ,GACjB,KAzBF,CA2BF,CAGA,OAAoB,IAAhBE,EAAOU,KACF,KAGFC,MAAMC,KAAKZ,EACpB"}
+{"version":3,"file":"index.js","sources":["../src/parse.ts","../src/compare.ts"],"sourcesContent":["import type { VaryHeader } from './types';\n\nconst VALID_HEADER_NAME_REGEX = /^[a-z0-9-]+$/i;\n\n/**\n * Parses the Vary header as defined in\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * The Vary header indicates which request headers a server considers when selecting or\n * generating a response, enabling proper HTTP caching behavior.\n *\n * @remarks\n * - Header field names are normalized to lowercase\n * - Duplicate fields are automatically deduplicated\n * - Invalid header names (per RFC 9110) are silently skipped\n * - If the header contains `'*'`, the function returns `'*'` (wildcard)\n * - Returns `null` for invalid input or when no valid fields are found\n *\n * @example\n *\n * ```ts\n * parse('Accept-Encoding, User-Agent');\n * // => ['accept-encoding', 'user-agent']\n *\n * parse('*');\n * // => '*'\n *\n * parse('Invalid Header!');\n * // => null\n * ```\n *\n * @param {string} headerStr - The Vary header value to parse (e.g., \"Accept-Encoding,\n *   User-Agent\")\n * @param {number} [maxLength=16] - Maximum number of header fields to parse for DoS\n *   protection. Default is `16`\n * @returns {VaryHeader | null} The parsed Vary header as an array of lowercase field\n *   names, `'*'` for wildcard, or `null` if invalid.\n */\nexport function parse(headerStr?: string, maxLength = 16): VaryHeader | null {\n  // Invalid header name\n  if (typeof headerStr !== 'string') {\n    return null;\n  }\n\n  // RFC says only '*' is valid alone, but some servers may send invalid headers like '*, Accept-Encoding'\n  if (headerStr.includes('*')) {\n    return '*';\n  }\n\n  const values = new Set<string>();\n\n  for (let i = 0; i < headerStr.length; i++) {\n    const char = headerStr[i];\n\n    if (char === ' ' || char === '\\t' || char === ',') {\n      continue;\n    }\n\n    const start = i;\n\n    while (i < headerStr.length) {\n      const char = headerStr[i];\n\n      if (char === ',') {\n        break;\n      }\n\n      i++;\n    }\n\n    const headerName = headerStr.slice(start, i).trim().toLowerCase();\n\n    // Skip invalid header names\n    if (headerName.length === 0 || !VALID_HEADER_NAME_REGEX.test(headerName)) {\n      continue;\n    }\n\n    values.add(headerName);\n\n    // DOS protection to avoid overly large vary headers\n    if (values.size >= maxLength) {\n      break;\n    }\n  }\n\n  // Ensures no empty set is returned\n  if (values.size === 0) {\n    return null;\n  }\n\n  return Array.from(values);\n}\n","import type { CompareHeaders, VaryHeader } from './types';\n\n/**\n * Checks if {@linkcode source} and {@linkcode target} headers are equivalent for the given\n * Vary header, as per\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * This function determines if two requests would receive the same cached response based\n * on the Vary header requirements.\n *\n * @remarks\n * - Returns `false` for wildcard vary (`'*'`) as responses always differ\n * - Header name matching is case-insensitive (per RFC 9110)\n * - Missing headers are treated as `undefined`\n * - String values are trimmed before comparison\n * - Array values are converted to strings via `.toString()`\n * - Uses loose equality (!=) for comparison\n * - Empty strings are distinct from missing headers\n *\n * @example\n *\n * ```ts\n * const vary = ['accept-encoding', 'user-agent'];\n * const headers1 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n * const headers2 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n *\n * compare(vary, headers1, headers2);\n * // => true\n * ```\n *\n * @param {VaryHeader} vary - The Vary header specifying which fields to compare\n * @param {CompareHeaders} source - The first set of request headers\n * @param {CompareHeaders} target - The second set of request headers\n * @returns {boolean} `true` if the headers are equivalent for the given Vary header,\n *   `false` otherwise\n */\nexport function compare(\n  vary: VaryHeader,\n  source: CompareHeaders,\n  target: CompareHeaders\n): vary is string[] {\n  // Wildcard always differs\n  if (vary === '*') {\n    return false;\n  }\n\n  const sourceKeys = Object.keys(source);\n  const targetKeys = Object.keys(target);\n\n  for (const field of vary) {\n    let sourceValue: string | undefined;\n    let targetValue: string | undefined;\n\n    // Case-insensitive header lookup in source\n    for (const key of sourceKeys) {\n      if (key.toLowerCase() === field) {\n        sourceValue = source[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // Case-insensitive header lookup in target\n    for (const key of targetKeys) {\n      if (key.toLowerCase() === field) {\n        targetValue = target[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // biome-ignore lint/suspicious/noDoubleEquals: Intentional loose comparison\n    if (sourceValue != targetValue) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"names":["VALID_HEADER_NAME_REGEX","vary","source","target","_step","sourceKeys","Object","keys","targetKeys","_iterator","_createForOfIteratorHelperLoose","done","_step2","field","value","sourceValue","targetValue","_iterator2","key","toLowerCase","_source$key","toString","trim","_step3","_iterator3","_target$_key","headerStr","maxLength","includes","values","Set","i","length","char","start","headerName","slice","test","add","size","Array","from"],"mappings":"oyBAEA,IAAMA,EAA0B,yCCmC9BC,EACAC,EACAC,GAGA,GAAa,MAATF,EACF,OACF,EAKA,IAHA,IAGwBG,EAHlBC,EAAaC,OAAOC,KAAKL,GACzBM,EAAaF,OAAOC,KAAKJ,GAE/BM,EAAAC,EAAoBT,KAAIG,EAAAK,KAAAE,MAAE,CAKxB,IALS,IAKmBC,EALnBC,EAAKT,EAAAU,MACVC,OAA+B,EAC/BC,OAGJ,EAAAC,EAAAP,EAAkBL,KAAUO,EAAAK,KAAAN,MAAE,CAAA,IAAnBO,EAAGN,EAAAE,MACZ,GAAII,EAAIC,gBAAkBN,EAAO,CAAA,IAAAO,EAC/BL,SAAWK,EAAGlB,EAAOgB,KAAgB,OAAZE,EAAXA,EAAaC,iBAAU,EAAvBD,EAAyBE,OACvC,KACF,CACF,CAGA,IAAA,IAA4BC,EAA5BC,EAAAd,EAAkBF,KAAUe,EAAAC,KAAAb,MAAE,CAAnB,IAAAO,EAAGK,EAAAT,MACZ,GAAII,EAAIC,gBAAkBN,EAAO,CAAAY,IAAAA,EAC/BT,EAAyBS,OAAdA,EAAGtB,EAAOe,KAAPO,OAAWA,EAAXA,EAAaJ,iBAAbI,EAAAA,EAAyBH,OACvC,KACF,CACF,CAGA,GAAIP,GAAeC,EACjB,OACF,CACF,CAEA,OACF,CAAA,yBDtCsBU,EAAoBC,GAExC,YAFwCA,IAAAA,EAAY,IAE3B,iBAAdD,EACT,OACF,KAGA,GAAIA,EAAUE,SAAS,KACrB,MAAO,IAKT,IAFA,IAAMC,EAAS,IAAIC,IAEVC,EAAI,EAAGA,EAAIL,EAAUM,OAAQD,IAAK,CACzC,IAAME,EAAOP,EAAUK,GAEvB,GAAa,MAATE,GAAyB,OAATA,GAA0B,MAATA,EAArC,CAMA,IAFA,IAAMC,EAAQH,EAEPA,EAAIL,EAAUM,QAGN,MAFAN,EAAUK,IAMvBA,IAGF,IAAMI,EAAaT,EAAUU,MAAMF,EAAOH,GAAGT,OAAOH,cAGpD,GAA0B,IAAtBgB,EAAWH,QAAiBhC,EAAwBqC,KAAKF,KAI7DN,EAAOS,IAAIH,GAGPN,EAAOU,MAAQZ,GACjB,KAzBF,CA2BF,CAGA,OAAoB,IAAhBE,EAAOU,KACF,KAGFC,MAAMC,KAAKZ,EACpB"}

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../src/compare.ts","../src/parse.ts"],"sourcesContent":["import type { CompareHeaders, VaryHeader } from './types';\n\n/**\n * Checks if {@linkcode source} and {@linkcode target} headers are equivalent for the given\n * Vary header, as per\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * This function determines if two requests would receive the same cached response based\n * on the Vary header requirements.\n *\n * @remarks\n * - Returns `false` for wildcard vary (`'*'`) as responses always differ\n * - Header name matching is case-insensitive (per RFC 9110)\n * - Missing headers are treated as `undefined`\n * - String values are trimmed before comparison\n * - Array values are converted to strings via `.toString()`\n * - Uses loose equality (!=) for comparison\n * - Empty strings are distinct from missing headers\n *\n * @example\n *\n * ```ts\n * const vary = ['accept-encoding', 'user-agent'];\n * const headers1 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n * const headers2 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n *\n * compare(vary, headers1, headers2);\n * // => true\n * ```\n *\n * @param {VaryHeader} vary - The Vary header specifying which fields to compare\n * @param {CompareHeaders} source - The first set of request headers\n * @param {CompareHeaders} target - The second set of request headers\n * @returns {boolean} `true` if the headers are equivalent for the given Vary header,\n *   `false` otherwise\n */\nexport function compare(\n  vary: VaryHeader,\n  source: CompareHeaders,\n  target: CompareHeaders\n): boolean {\n  // Wildcard always differs\n  if (vary === '*') {\n    return false;\n  }\n\n  const sourceKeys = Object.keys(source);\n  const targetKeys = Object.keys(target);\n\n  for (const field of vary) {\n    let sourceValue: string | undefined;\n    let targetValue: string | undefined;\n\n    // Case-insensitive header lookup in source\n    for (const key of sourceKeys) {\n      if (key.toLowerCase() === field) {\n        sourceValue = source[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // Case-insensitive header lookup in target\n    for (const key of targetKeys) {\n      if (key.toLowerCase() === field) {\n        targetValue = target[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // biome-ignore lint/suspicious/noDoubleEquals: Intentional loose comparison\n    if (sourceValue != targetValue) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","import type { VaryHeader } from './types';\n\nconst VALID_HEADER_NAME_REGEX = /^[a-z0-9-]+$/i;\n\n/**\n * Parses the Vary header as defined in\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * The Vary header indicates which request headers a server considers when selecting or\n * generating a response, enabling proper HTTP caching behavior.\n *\n * @remarks\n * - Header field names are normalized to lowercase\n * - Duplicate fields are automatically deduplicated\n * - Invalid header names (per RFC 9110) are silently skipped\n * - If the header contains `'*'`, the function returns `'*'` (wildcard)\n * - Returns `null` for invalid input or when no valid fields are found\n *\n * @example\n *\n * ```ts\n * parse('Accept-Encoding, User-Agent');\n * // => ['accept-encoding', 'user-agent']\n *\n * parse('*');\n * // => '*'\n *\n * parse('Invalid Header!');\n * // => null\n * ```\n *\n * @param {string} headerStr - The Vary header value to parse (e.g., \"Accept-Encoding,\n *   User-Agent\")\n * @param {number} [maxLength=16] - Maximum number of header fields to parse for DoS\n *   protection. Default is `16`\n * @returns {VaryHeader | null} The parsed Vary header as an array of lowercase field\n *   names, `'*'` for wildcard, or `null` if invalid.\n */\nexport function parse(headerStr?: string, maxLength = 16): VaryHeader | null {\n  // Invalid header name\n  if (typeof headerStr !== 'string') {\n    return null;\n  }\n\n  // RFC says only '*' is valid alone, but some servers may send invalid headers like '*, Accept-Encoding'\n  if (headerStr.includes('*')) {\n    return '*';\n  }\n\n  const values = new Set<string>();\n\n  for (let i = 0; i < headerStr.length; i++) {\n    const char = headerStr[i];\n\n    if (char === ' ' || char === '\\t' || char === ',') {\n      continue;\n    }\n\n    const start = i;\n\n    while (i < headerStr.length) {\n      const char = headerStr[i];\n\n      if (char === ',') {\n        break;\n      }\n\n      i++;\n    }\n\n    const headerName = headerStr.slice(start, i).trim().toLowerCase();\n\n    // Skip invalid header names\n    if (headerName.length === 0 || !VALID_HEADER_NAME_REGEX.test(headerName)) {\n      continue;\n    }\n\n    values.add(headerName);\n\n    // DOS protection to avoid overly large vary headers\n    if (values.size >= maxLength) {\n      break;\n    }\n  }\n\n  // Ensures no empty set is returned\n  if (values.size === 0) {\n    return null;\n  }\n\n  return Array.from(values);\n}\n"],"names":["compare","vary","source","target","_step","sourceKeys","Object","keys","targetKeys","_iterator","_createForOfIteratorHelperLoose","done","_step2","field","value","sourceValue","targetValue","_iterator2","key","toLowerCase","_source$key","toString","trim","_step3","_iterator3","_target$_key","VALID_HEADER_NAME_REGEX","parse","headerStr","maxLength","includes","values","Set","i","length","char","start","headerName","slice","test","add","size","Array","from"],"mappings":"6yBAoCgBA,EACdC,EACAC,EACAC,GAGA,GAAa,MAATF,EACF,OACF,EAKA,IAHA,IAGwBG,EAHlBC,EAAaC,OAAOC,KAAKL,GACzBM,EAAaF,OAAOC,KAAKJ,GAE/BM,EAAAC,EAAoBT,KAAIG,EAAAK,KAAAE,MAAE,CAKxB,IALS,IAKmBC,EALnBC,EAAKT,EAAAU,MACVC,OAA+B,EAC/BC,OAGJ,EAAAC,EAAAP,EAAkBL,KAAUO,EAAAK,KAAAN,MAAE,CAAA,IAAnBO,EAAGN,EAAAE,MACZ,GAAII,EAAIC,gBAAkBN,EAAO,CAAA,IAAAO,EAC/BL,SAAWK,EAAGlB,EAAOgB,KAAgB,OAAZE,EAAXA,EAAaC,iBAAU,EAAvBD,EAAyBE,OACvC,KACF,CACF,CAGA,IAAA,IAA4BC,EAA5BC,EAAAd,EAAkBF,KAAUe,EAAAC,KAAAb,MAAE,CAAnB,IAAAO,EAAGK,EAAAT,MACZ,GAAII,EAAIC,gBAAkBN,EAAO,CAAAY,IAAAA,EAC/BT,EAAyBS,OAAdA,EAAGtB,EAAOe,KAAPO,OAAWA,EAAXA,EAAaJ,iBAAbI,EAAAA,EAAyBH,OACvC,KACF,CACF,CAGA,GAAIP,GAAeC,EACjB,OACF,CACF,CAEA,OACF,CAAA,CC1EA,IAAMU,EAA0B,yBAoChBC,EAAMC,EAAoBC,GAExC,YAFwCA,IAAAA,EAAY,IAE3B,iBAAdD,EACT,OACF,KAGA,GAAIA,EAAUE,SAAS,KACrB,MAAO,IAKT,IAFA,IAAMC,EAAS,IAAIC,IAEVC,EAAI,EAAGA,EAAIL,EAAUM,OAAQD,IAAK,CACzC,IAAME,EAAOP,EAAUK,GAEvB,GAAa,MAATE,GAAyB,OAATA,GAA0B,MAATA,EAArC,CAMA,IAFA,IAAMC,EAAQH,EAEPA,EAAIL,EAAUM,QAGN,MAFAN,EAAUK,IAMvBA,IAGF,IAAMI,EAAaT,EAAUU,MAAMF,EAAOH,GAAGX,OAAOH,cAGpD,GAA0B,IAAtBkB,EAAWH,QAAiBR,EAAwBa,KAAKF,KAI7DN,EAAOS,IAAIH,GAGPN,EAAOU,MAAQZ,GACjB,KAzBF,CA2BF,CAGA,OAAoB,IAAhBE,EAAOU,KACF,KAGFC,MAAMC,KAAKZ,EACpB"}
+{"version":3,"file":"index.mjs","sources":["../src/compare.ts","../src/parse.ts"],"sourcesContent":["import type { CompareHeaders, VaryHeader } from './types';\n\n/**\n * Checks if {@linkcode source} and {@linkcode target} headers are equivalent for the given\n * Vary header, as per\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * This function determines if two requests would receive the same cached response based\n * on the Vary header requirements.\n *\n * @remarks\n * - Returns `false` for wildcard vary (`'*'`) as responses always differ\n * - Header name matching is case-insensitive (per RFC 9110)\n * - Missing headers are treated as `undefined`\n * - String values are trimmed before comparison\n * - Array values are converted to strings via `.toString()`\n * - Uses loose equality (!=) for comparison\n * - Empty strings are distinct from missing headers\n *\n * @example\n *\n * ```ts\n * const vary = ['accept-encoding', 'user-agent'];\n * const headers1 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n * const headers2 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n *\n * compare(vary, headers1, headers2);\n * // => true\n * ```\n *\n * @param {VaryHeader} vary - The Vary header specifying which fields to compare\n * @param {CompareHeaders} source - The first set of request headers\n * @param {CompareHeaders} target - The second set of request headers\n * @returns {boolean} `true` if the headers are equivalent for the given Vary header,\n *   `false` otherwise\n */\nexport function compare(\n  vary: VaryHeader,\n  source: CompareHeaders,\n  target: CompareHeaders\n): vary is string[] {\n  // Wildcard always differs\n  if (vary === '*') {\n    return false;\n  }\n\n  const sourceKeys = Object.keys(source);\n  const targetKeys = Object.keys(target);\n\n  for (const field of vary) {\n    let sourceValue: string | undefined;\n    let targetValue: string | undefined;\n\n    // Case-insensitive header lookup in source\n    for (const key of sourceKeys) {\n      if (key.toLowerCase() === field) {\n        sourceValue = source[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // Case-insensitive header lookup in target\n    for (const key of targetKeys) {\n      if (key.toLowerCase() === field) {\n        targetValue = target[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // biome-ignore lint/suspicious/noDoubleEquals: Intentional loose comparison\n    if (sourceValue != targetValue) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","import type { VaryHeader } from './types';\n\nconst VALID_HEADER_NAME_REGEX = /^[a-z0-9-]+$/i;\n\n/**\n * Parses the Vary header as defined in\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * The Vary header indicates which request headers a server considers when selecting or\n * generating a response, enabling proper HTTP caching behavior.\n *\n * @remarks\n * - Header field names are normalized to lowercase\n * - Duplicate fields are automatically deduplicated\n * - Invalid header names (per RFC 9110) are silently skipped\n * - If the header contains `'*'`, the function returns `'*'` (wildcard)\n * - Returns `null` for invalid input or when no valid fields are found\n *\n * @example\n *\n * ```ts\n * parse('Accept-Encoding, User-Agent');\n * // => ['accept-encoding', 'user-agent']\n *\n * parse('*');\n * // => '*'\n *\n * parse('Invalid Header!');\n * // => null\n * ```\n *\n * @param {string} headerStr - The Vary header value to parse (e.g., \"Accept-Encoding,\n *   User-Agent\")\n * @param {number} [maxLength=16] - Maximum number of header fields to parse for DoS\n *   protection. Default is `16`\n * @returns {VaryHeader | null} The parsed Vary header as an array of lowercase field\n *   names, `'*'` for wildcard, or `null` if invalid.\n */\nexport function parse(headerStr?: string, maxLength = 16): VaryHeader | null {\n  // Invalid header name\n  if (typeof headerStr !== 'string') {\n    return null;\n  }\n\n  // RFC says only '*' is valid alone, but some servers may send invalid headers like '*, Accept-Encoding'\n  if (headerStr.includes('*')) {\n    return '*';\n  }\n\n  const values = new Set<string>();\n\n  for (let i = 0; i < headerStr.length; i++) {\n    const char = headerStr[i];\n\n    if (char === ' ' || char === '\\t' || char === ',') {\n      continue;\n    }\n\n    const start = i;\n\n    while (i < headerStr.length) {\n      const char = headerStr[i];\n\n      if (char === ',') {\n        break;\n      }\n\n      i++;\n    }\n\n    const headerName = headerStr.slice(start, i).trim().toLowerCase();\n\n    // Skip invalid header names\n    if (headerName.length === 0 || !VALID_HEADER_NAME_REGEX.test(headerName)) {\n      continue;\n    }\n\n    values.add(headerName);\n\n    // DOS protection to avoid overly large vary headers\n    if (values.size >= maxLength) {\n      break;\n    }\n  }\n\n  // Ensures no empty set is returned\n  if (values.size === 0) {\n    return null;\n  }\n\n  return Array.from(values);\n}\n"],"names":["compare","vary","source","target","_step","sourceKeys","Object","keys","targetKeys","_iterator","_createForOfIteratorHelperLoose","done","_step2","field","value","sourceValue","targetValue","_iterator2","key","toLowerCase","_source$key","toString","trim","_step3","_iterator3","_target$_key","VALID_HEADER_NAME_REGEX","parse","headerStr","maxLength","includes","values","Set","i","length","char","start","headerName","slice","test","add","size","Array","from"],"mappings":"6yBAoCgBA,EACdC,EACAC,EACAC,GAGA,GAAa,MAATF,EACF,OACF,EAKA,IAHA,IAGwBG,EAHlBC,EAAaC,OAAOC,KAAKL,GACzBM,EAAaF,OAAOC,KAAKJ,GAE/BM,EAAAC,EAAoBT,KAAIG,EAAAK,KAAAE,MAAE,CAKxB,IALS,IAKmBC,EALnBC,EAAKT,EAAAU,MACVC,OAA+B,EAC/BC,OAGJ,EAAAC,EAAAP,EAAkBL,KAAUO,EAAAK,KAAAN,MAAE,CAAA,IAAnBO,EAAGN,EAAAE,MACZ,GAAII,EAAIC,gBAAkBN,EAAO,CAAA,IAAAO,EAC/BL,SAAWK,EAAGlB,EAAOgB,KAAgB,OAAZE,EAAXA,EAAaC,iBAAU,EAAvBD,EAAyBE,OACvC,KACF,CACF,CAGA,IAAA,IAA4BC,EAA5BC,EAAAd,EAAkBF,KAAUe,EAAAC,KAAAb,MAAE,CAAnB,IAAAO,EAAGK,EAAAT,MACZ,GAAII,EAAIC,gBAAkBN,EAAO,CAAAY,IAAAA,EAC/BT,EAAyBS,OAAdA,EAAGtB,EAAOe,KAAPO,OAAWA,EAAXA,EAAaJ,iBAAbI,EAAAA,EAAyBH,OACvC,KACF,CACF,CAGA,GAAIP,GAAeC,EACjB,OACF,CACF,CAEA,OACF,CAAA,CC1EA,IAAMU,EAA0B,yBAoChBC,EAAMC,EAAoBC,GAExC,YAFwCA,IAAAA,EAAY,IAE3B,iBAAdD,EACT,OACF,KAGA,GAAIA,EAAUE,SAAS,KACrB,MAAO,IAKT,IAFA,IAAMC,EAAS,IAAIC,IAEVC,EAAI,EAAGA,EAAIL,EAAUM,OAAQD,IAAK,CACzC,IAAME,EAAOP,EAAUK,GAEvB,GAAa,MAATE,GAAyB,OAATA,GAA0B,MAATA,EAArC,CAMA,IAFA,IAAMC,EAAQH,EAEPA,EAAIL,EAAUM,QAGN,MAFAN,EAAUK,IAMvBA,IAGF,IAAMI,EAAaT,EAAUU,MAAMF,EAAOH,GAAGX,OAAOH,cAGpD,GAA0B,IAAtBkB,EAAWH,QAAiBR,EAAwBa,KAAKF,KAI7DN,EAAOS,IAAIH,GAGPN,EAAOU,MAAQZ,GACjB,KAzBF,CA2BF,CAGA,OAAoB,IAAhBE,EAAOU,KACF,KAGFC,MAAMC,KAAKZ,EACpB"}

package/dist/index.modern.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.modern.mjs","sources":["../src/compare.ts","../src/parse.ts"],"sourcesContent":["import type { CompareHeaders, VaryHeader } from './types';\n\n/**\n * Checks if {@linkcode source} and {@linkcode target} headers are equivalent for the given\n * Vary header, as per\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * This function determines if two requests would receive the same cached response based\n * on the Vary header requirements.\n *\n * @remarks\n * - Returns `false` for wildcard vary (`'*'`) as responses always differ\n * - Header name matching is case-insensitive (per RFC 9110)\n * - Missing headers are treated as `undefined`\n * - String values are trimmed before comparison\n * - Array values are converted to strings via `.toString()`\n * - Uses loose equality (!=) for comparison\n * - Empty strings are distinct from missing headers\n *\n * @example\n *\n * ```ts\n * const vary = ['accept-encoding', 'user-agent'];\n * const headers1 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n * const headers2 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n *\n * compare(vary, headers1, headers2);\n * // => true\n * ```\n *\n * @param {VaryHeader} vary - The Vary header specifying which fields to compare\n * @param {CompareHeaders} source - The first set of request headers\n * @param {CompareHeaders} target - The second set of request headers\n * @returns {boolean} `true` if the headers are equivalent for the given Vary header,\n *   `false` otherwise\n */\nexport function compare(\n  vary: VaryHeader,\n  source: CompareHeaders,\n  target: CompareHeaders\n): boolean {\n  // Wildcard always differs\n  if (vary === '*') {\n    return false;\n  }\n\n  const sourceKeys = Object.keys(source);\n  const targetKeys = Object.keys(target);\n\n  for (const field of vary) {\n    let sourceValue: string | undefined;\n    let targetValue: string | undefined;\n\n    // Case-insensitive header lookup in source\n    for (const key of sourceKeys) {\n      if (key.toLowerCase() === field) {\n        sourceValue = source[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // Case-insensitive header lookup in target\n    for (const key of targetKeys) {\n      if (key.toLowerCase() === field) {\n        targetValue = target[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // biome-ignore lint/suspicious/noDoubleEquals: Intentional loose comparison\n    if (sourceValue != targetValue) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","import type { VaryHeader } from './types';\n\nconst VALID_HEADER_NAME_REGEX = /^[a-z0-9-]+$/i;\n\n/**\n * Parses the Vary header as defined in\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * The Vary header indicates which request headers a server considers when selecting or\n * generating a response, enabling proper HTTP caching behavior.\n *\n * @remarks\n * - Header field names are normalized to lowercase\n * - Duplicate fields are automatically deduplicated\n * - Invalid header names (per RFC 9110) are silently skipped\n * - If the header contains `'*'`, the function returns `'*'` (wildcard)\n * - Returns `null` for invalid input or when no valid fields are found\n *\n * @example\n *\n * ```ts\n * parse('Accept-Encoding, User-Agent');\n * // => ['accept-encoding', 'user-agent']\n *\n * parse('*');\n * // => '*'\n *\n * parse('Invalid Header!');\n * // => null\n * ```\n *\n * @param {string} headerStr - The Vary header value to parse (e.g., \"Accept-Encoding,\n *   User-Agent\")\n * @param {number} [maxLength=16] - Maximum number of header fields to parse for DoS\n *   protection. Default is `16`\n * @returns {VaryHeader | null} The parsed Vary header as an array of lowercase field\n *   names, `'*'` for wildcard, or `null` if invalid.\n */\nexport function parse(headerStr?: string, maxLength = 16): VaryHeader | null {\n  // Invalid header name\n  if (typeof headerStr !== 'string') {\n    return null;\n  }\n\n  // RFC says only '*' is valid alone, but some servers may send invalid headers like '*, Accept-Encoding'\n  if (headerStr.includes('*')) {\n    return '*';\n  }\n\n  const values = new Set<string>();\n\n  for (let i = 0; i < headerStr.length; i++) {\n    const char = headerStr[i];\n\n    if (char === ' ' || char === '\\t' || char === ',') {\n      continue;\n    }\n\n    const start = i;\n\n    while (i < headerStr.length) {\n      const char = headerStr[i];\n\n      if (char === ',') {\n        break;\n      }\n\n      i++;\n    }\n\n    const headerName = headerStr.slice(start, i).trim().toLowerCase();\n\n    // Skip invalid header names\n    if (headerName.length === 0 || !VALID_HEADER_NAME_REGEX.test(headerName)) {\n      continue;\n    }\n\n    values.add(headerName);\n\n    // DOS protection to avoid overly large vary headers\n    if (values.size >= maxLength) {\n      break;\n    }\n  }\n\n  // Ensures no empty set is returned\n  if (values.size === 0) {\n    return null;\n  }\n\n  return Array.from(values);\n}\n"],"names":["compare","vary","source","target","sourceKeys","Object","keys","targetKeys","field","sourceValue","targetValue","key","toLowerCase","_source$key","toString","trim","_target$key","VALID_HEADER_NAME_REGEX","parse","headerStr","maxLength","includes","values","Set","i","length","char","start","headerName","slice","test","add","size","Array","from"],"mappings":"SAoCgBA,EACdC,EACAC,EACAC,GAGA,GAAa,MAATF,EACF,OAAO,EAGT,MAAMG,EAAaC,OAAOC,KAAKJ,GACzBK,EAAaF,OAAOC,KAAKH,GAE/B,IAAK,MAAMK,KAASP,EAAM,CACxB,IAAIQ,EACAC,EAGJ,IAAK,MAAMC,KAAOP,EAChB,GAAIO,EAAIC,gBAAkBJ,EAAO,CAAAK,IAAAA,EAC/BJ,EAAyB,OAAdI,EAAGX,EAAOS,KAAgB,OAAZE,EAAXA,EAAaC,iBAAU,EAAvBD,EAAyBE,OACvC,KACF,CAIF,IAAK,MAAMJ,KAAOJ,EAChB,GAAII,EAAIC,gBAAkBJ,EAAO,CAAAQ,IAAAA,EAC/BN,EAAyB,OAAdM,EAAGb,EAAOQ,KAAPK,OAAWA,EAAXA,EAAaF,iBAAbE,EAAAA,EAAyBD,OACvC,KACF,CAIF,GAAIN,GAAeC,EACjB,QAEJ,CAEA,OACF,CAAA,CC1EA,MAAMO,EAA0B,yBAoChBC,EAAMC,EAAoBC,EAAY,IAEpD,GAAyB,iBAAdD,EACT,YAIF,GAAIA,EAAUE,SAAS,KACrB,MAAO,IAGT,MAAMC,EAAS,IAAIC,IAEnB,IAAK,IAAIC,EAAI,EAAGA,EAAIL,EAAUM,OAAQD,IAAK,CACzC,MAAME,EAAOP,EAAUK,GAEvB,GAAa,MAATE,GAAyB,OAATA,GAA0B,MAATA,EACnC,SAGF,MAAMC,EAAQH,EAEd,KAAOA,EAAIL,EAAUM,QAGN,MAFAN,EAAUK,IAMvBA,IAGF,MAAMI,EAAaT,EAAUU,MAAMF,EAAOH,GAAGT,OAAOH,cAGpD,GAA0B,IAAtBgB,EAAWH,QAAiBR,EAAwBa,KAAKF,KAI7DN,EAAOS,IAAIH,GAGPN,EAAOU,MAAQZ,GACjB,KAEJ,CAGA,OAAoB,IAAhBE,EAAOU,KACF,KAGFC,MAAMC,KAAKZ,EACpB"}
+{"version":3,"file":"index.modern.mjs","sources":["../src/compare.ts","../src/parse.ts"],"sourcesContent":["import type { CompareHeaders, VaryHeader } from './types';\n\n/**\n * Checks if {@linkcode source} and {@linkcode target} headers are equivalent for the given\n * Vary header, as per\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * This function determines if two requests would receive the same cached response based\n * on the Vary header requirements.\n *\n * @remarks\n * - Returns `false` for wildcard vary (`'*'`) as responses always differ\n * - Header name matching is case-insensitive (per RFC 9110)\n * - Missing headers are treated as `undefined`\n * - String values are trimmed before comparison\n * - Array values are converted to strings via `.toString()`\n * - Uses loose equality (!=) for comparison\n * - Empty strings are distinct from missing headers\n *\n * @example\n *\n * ```ts\n * const vary = ['accept-encoding', 'user-agent'];\n * const headers1 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n * const headers2 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n *\n * compare(vary, headers1, headers2);\n * // => true\n * ```\n *\n * @param {VaryHeader} vary - The Vary header specifying which fields to compare\n * @param {CompareHeaders} source - The first set of request headers\n * @param {CompareHeaders} target - The second set of request headers\n * @returns {boolean} `true` if the headers are equivalent for the given Vary header,\n *   `false` otherwise\n */\nexport function compare(\n  vary: VaryHeader,\n  source: CompareHeaders,\n  target: CompareHeaders\n): vary is string[] {\n  // Wildcard always differs\n  if (vary === '*') {\n    return false;\n  }\n\n  const sourceKeys = Object.keys(source);\n  const targetKeys = Object.keys(target);\n\n  for (const field of vary) {\n    let sourceValue: string | undefined;\n    let targetValue: string | undefined;\n\n    // Case-insensitive header lookup in source\n    for (const key of sourceKeys) {\n      if (key.toLowerCase() === field) {\n        sourceValue = source[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // Case-insensitive header lookup in target\n    for (const key of targetKeys) {\n      if (key.toLowerCase() === field) {\n        targetValue = target[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // biome-ignore lint/suspicious/noDoubleEquals: Intentional loose comparison\n    if (sourceValue != targetValue) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","import type { VaryHeader } from './types';\n\nconst VALID_HEADER_NAME_REGEX = /^[a-z0-9-]+$/i;\n\n/**\n * Parses the Vary header as defined in\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * The Vary header indicates which request headers a server considers when selecting or\n * generating a response, enabling proper HTTP caching behavior.\n *\n * @remarks\n * - Header field names are normalized to lowercase\n * - Duplicate fields are automatically deduplicated\n * - Invalid header names (per RFC 9110) are silently skipped\n * - If the header contains `'*'`, the function returns `'*'` (wildcard)\n * - Returns `null` for invalid input or when no valid fields are found\n *\n * @example\n *\n * ```ts\n * parse('Accept-Encoding, User-Agent');\n * // => ['accept-encoding', 'user-agent']\n *\n * parse('*');\n * // => '*'\n *\n * parse('Invalid Header!');\n * // => null\n * ```\n *\n * @param {string} headerStr - The Vary header value to parse (e.g., \"Accept-Encoding,\n *   User-Agent\")\n * @param {number} [maxLength=16] - Maximum number of header fields to parse for DoS\n *   protection. Default is `16`\n * @returns {VaryHeader | null} The parsed Vary header as an array of lowercase field\n *   names, `'*'` for wildcard, or `null` if invalid.\n */\nexport function parse(headerStr?: string, maxLength = 16): VaryHeader | null {\n  // Invalid header name\n  if (typeof headerStr !== 'string') {\n    return null;\n  }\n\n  // RFC says only '*' is valid alone, but some servers may send invalid headers like '*, Accept-Encoding'\n  if (headerStr.includes('*')) {\n    return '*';\n  }\n\n  const values = new Set<string>();\n\n  for (let i = 0; i < headerStr.length; i++) {\n    const char = headerStr[i];\n\n    if (char === ' ' || char === '\\t' || char === ',') {\n      continue;\n    }\n\n    const start = i;\n\n    while (i < headerStr.length) {\n      const char = headerStr[i];\n\n      if (char === ',') {\n        break;\n      }\n\n      i++;\n    }\n\n    const headerName = headerStr.slice(start, i).trim().toLowerCase();\n\n    // Skip invalid header names\n    if (headerName.length === 0 || !VALID_HEADER_NAME_REGEX.test(headerName)) {\n      continue;\n    }\n\n    values.add(headerName);\n\n    // DOS protection to avoid overly large vary headers\n    if (values.size >= maxLength) {\n      break;\n    }\n  }\n\n  // Ensures no empty set is returned\n  if (values.size === 0) {\n    return null;\n  }\n\n  return Array.from(values);\n}\n"],"names":["compare","vary","source","target","sourceKeys","Object","keys","targetKeys","field","sourceValue","targetValue","key","toLowerCase","_source$key","toString","trim","_target$key","VALID_HEADER_NAME_REGEX","parse","headerStr","maxLength","includes","values","Set","i","length","char","start","headerName","slice","test","add","size","Array","from"],"mappings":"SAoCgBA,EACdC,EACAC,EACAC,GAGA,GAAa,MAATF,EACF,OAAO,EAGT,MAAMG,EAAaC,OAAOC,KAAKJ,GACzBK,EAAaF,OAAOC,KAAKH,GAE/B,IAAK,MAAMK,KAASP,EAAM,CACxB,IAAIQ,EACAC,EAGJ,IAAK,MAAMC,KAAOP,EAChB,GAAIO,EAAIC,gBAAkBJ,EAAO,CAAAK,IAAAA,EAC/BJ,EAAyB,OAAdI,EAAGX,EAAOS,KAAgB,OAAZE,EAAXA,EAAaC,iBAAU,EAAvBD,EAAyBE,OACvC,KACF,CAIF,IAAK,MAAMJ,KAAOJ,EAChB,GAAII,EAAIC,gBAAkBJ,EAAO,CAAAQ,IAAAA,EAC/BN,EAAyB,OAAdM,EAAGb,EAAOQ,KAAPK,OAAWA,EAAXA,EAAaF,iBAAbE,EAAAA,EAAyBD,OACvC,KACF,CAIF,GAAIN,GAAeC,EACjB,QAEJ,CAEA,OACF,CAAA,CC1EA,MAAMO,EAA0B,yBAoChBC,EAAMC,EAAoBC,EAAY,IAEpD,GAAyB,iBAAdD,EACT,YAIF,GAAIA,EAAUE,SAAS,KACrB,MAAO,IAGT,MAAMC,EAAS,IAAIC,IAEnB,IAAK,IAAIC,EAAI,EAAGA,EAAIL,EAAUM,OAAQD,IAAK,CACzC,MAAME,EAAOP,EAAUK,GAEvB,GAAa,MAATE,GAAyB,OAATA,GAA0B,MAATA,EACnC,SAGF,MAAMC,EAAQH,EAEd,KAAOA,EAAIL,EAAUM,QAGN,MAFAN,EAAUK,IAMvBA,IAGF,MAAMI,EAAaT,EAAUU,MAAMF,EAAOH,GAAGT,OAAOH,cAGpD,GAA0B,IAAtBgB,EAAWH,QAAiBR,EAAwBa,KAAKF,KAI7DN,EAAOS,IAAIH,GAGPN,EAAOU,MAAQZ,GACjB,KAEJ,CAGA,OAAoB,IAAhBE,EAAOU,KACF,KAGFC,MAAMC,KAAKZ,EACpB"}

package/dist/index.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.umd.js","sources":["../src/parse.ts","../src/compare.ts"],"sourcesContent":["import type { VaryHeader } from './types';\n\nconst VALID_HEADER_NAME_REGEX = /^[a-z0-9-]+$/i;\n\n/**\n * Parses the Vary header as defined in\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * The Vary header indicates which request headers a server considers when selecting or\n * generating a response, enabling proper HTTP caching behavior.\n *\n * @remarks\n * - Header field names are normalized to lowercase\n * - Duplicate fields are automatically deduplicated\n * - Invalid header names (per RFC 9110) are silently skipped\n * - If the header contains `'*'`, the function returns `'*'` (wildcard)\n * - Returns `null` for invalid input or when no valid fields are found\n *\n * @example\n *\n * ```ts\n * parse('Accept-Encoding, User-Agent');\n * // => ['accept-encoding', 'user-agent']\n *\n * parse('*');\n * // => '*'\n *\n * parse('Invalid Header!');\n * // => null\n * ```\n *\n * @param {string} headerStr - The Vary header value to parse (e.g., \"Accept-Encoding,\n *   User-Agent\")\n * @param {number} [maxLength=16] - Maximum number of header fields to parse for DoS\n *   protection. Default is `16`\n * @returns {VaryHeader | null} The parsed Vary header as an array of lowercase field\n *   names, `'*'` for wildcard, or `null` if invalid.\n */\nexport function parse(headerStr?: string, maxLength = 16): VaryHeader | null {\n  // Invalid header name\n  if (typeof headerStr !== 'string') {\n    return null;\n  }\n\n  // RFC says only '*' is valid alone, but some servers may send invalid headers like '*, Accept-Encoding'\n  if (headerStr.includes('*')) {\n    return '*';\n  }\n\n  const values = new Set<string>();\n\n  for (let i = 0; i < headerStr.length; i++) {\n    const char = headerStr[i];\n\n    if (char === ' ' || char === '\\t' || char === ',') {\n      continue;\n    }\n\n    const start = i;\n\n    while (i < headerStr.length) {\n      const char = headerStr[i];\n\n      if (char === ',') {\n        break;\n      }\n\n      i++;\n    }\n\n    const headerName = headerStr.slice(start, i).trim().toLowerCase();\n\n    // Skip invalid header names\n    if (headerName.length === 0 || !VALID_HEADER_NAME_REGEX.test(headerName)) {\n      continue;\n    }\n\n    values.add(headerName);\n\n    // DOS protection to avoid overly large vary headers\n    if (values.size >= maxLength) {\n      break;\n    }\n  }\n\n  // Ensures no empty set is returned\n  if (values.size === 0) {\n    return null;\n  }\n\n  return Array.from(values);\n}\n","import type { CompareHeaders, VaryHeader } from './types';\n\n/**\n * Checks if {@linkcode source} and {@linkcode target} headers are equivalent for the given\n * Vary header, as per\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * This function determines if two requests would receive the same cached response based\n * on the Vary header requirements.\n *\n * @remarks\n * - Returns `false` for wildcard vary (`'*'`) as responses always differ\n * - Header name matching is case-insensitive (per RFC 9110)\n * - Missing headers are treated as `undefined`\n * - String values are trimmed before comparison\n * - Array values are converted to strings via `.toString()`\n * - Uses loose equality (!=) for comparison\n * - Empty strings are distinct from missing headers\n *\n * @example\n *\n * ```ts\n * const vary = ['accept-encoding', 'user-agent'];\n * const headers1 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n * const headers2 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n *\n * compare(vary, headers1, headers2);\n * // => true\n * ```\n *\n * @param {VaryHeader} vary - The Vary header specifying which fields to compare\n * @param {CompareHeaders} source - The first set of request headers\n * @param {CompareHeaders} target - The second set of request headers\n * @returns {boolean} `true` if the headers are equivalent for the given Vary header,\n *   `false` otherwise\n */\nexport function compare(\n  vary: VaryHeader,\n  source: CompareHeaders,\n  target: CompareHeaders\n): boolean {\n  // Wildcard always differs\n  if (vary === '*') {\n    return false;\n  }\n\n  const sourceKeys = Object.keys(source);\n  const targetKeys = Object.keys(target);\n\n  for (const field of vary) {\n    let sourceValue: string | undefined;\n    let targetValue: string | undefined;\n\n    // Case-insensitive header lookup in source\n    for (const key of sourceKeys) {\n      if (key.toLowerCase() === field) {\n        sourceValue = source[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // Case-insensitive header lookup in target\n    for (const key of targetKeys) {\n      if (key.toLowerCase() === field) {\n        targetValue = target[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // biome-ignore lint/suspicious/noDoubleEquals: Intentional loose comparison\n    if (sourceValue != targetValue) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"names":["VALID_HEADER_NAME_REGEX","vary","source","target","_step","sourceKeys","Object","keys","targetKeys","_iterator","_createForOfIteratorHelperLoose","done","_step2","field","value","sourceValue","targetValue","_iterator2","key","toLowerCase","_source$key","toString","trim","_step3","_iterator3","_target$_key","headerStr","maxLength","includes","values","Set","i","length","char","start","headerName","slice","test","add","size","Array","from"],"mappings":"sgCAEA,IAAMA,EAA0B,mCCmC9BC,EACAC,EACAC,GAGA,GAAa,MAATF,EACF,OACF,EAKA,IAHA,IAGwBG,EAHlBC,EAAaC,OAAOC,KAAKL,GACzBM,EAAaF,OAAOC,KAAKJ,GAE/BM,EAAAC,EAAoBT,KAAIG,EAAAK,KAAAE,MAAE,CAKxB,IALS,IAKmBC,EALnBC,EAAKT,EAAAU,MACVC,OAA+B,EAC/BC,OAGJ,EAAAC,EAAAP,EAAkBL,KAAUO,EAAAK,KAAAN,MAAE,CAAA,IAAnBO,EAAGN,EAAAE,MACZ,GAAII,EAAIC,gBAAkBN,EAAO,CAAA,IAAAO,EAC/BL,SAAWK,EAAGlB,EAAOgB,KAAgB,OAAZE,EAAXA,EAAaC,iBAAU,EAAvBD,EAAyBE,OACvC,KACF,CACF,CAGA,IAAA,IAA4BC,EAA5BC,EAAAd,EAAkBF,KAAUe,EAAAC,KAAAb,MAAE,CAAnB,IAAAO,EAAGK,EAAAT,MACZ,GAAII,EAAIC,gBAAkBN,EAAO,CAAAY,IAAAA,EAC/BT,EAAyBS,OAAdA,EAAGtB,EAAOe,KAAPO,OAAWA,EAAXA,EAAaJ,iBAAbI,EAAAA,EAAyBH,OACvC,KACF,CACF,CAGA,GAAIP,GAAeC,EACjB,OACF,CACF,CAEA,OACF,CAAA,mBDtCsBU,EAAoBC,GAExC,YAFwCA,IAAAA,EAAY,IAE3B,iBAAdD,EACT,OACF,KAGA,GAAIA,EAAUE,SAAS,KACrB,MAAO,IAKT,IAFA,IAAMC,EAAS,IAAIC,IAEVC,EAAI,EAAGA,EAAIL,EAAUM,OAAQD,IAAK,CACzC,IAAME,EAAOP,EAAUK,GAEvB,GAAa,MAATE,GAAyB,OAATA,GAA0B,MAATA,EAArC,CAMA,IAFA,IAAMC,EAAQH,EAEPA,EAAIL,EAAUM,QAGN,MAFAN,EAAUK,IAMvBA,IAGF,IAAMI,EAAaT,EAAUU,MAAMF,EAAOH,GAAGT,OAAOH,cAGpD,GAA0B,IAAtBgB,EAAWH,QAAiBhC,EAAwBqC,KAAKF,KAI7DN,EAAOS,IAAIH,GAGPN,EAAOU,MAAQZ,GACjB,KAzBF,CA2BF,CAGA,OAAoB,IAAhBE,EAAOU,KACF,KAGFC,MAAMC,KAAKZ,EACpB"}
+{"version":3,"file":"index.umd.js","sources":["../src/parse.ts","../src/compare.ts"],"sourcesContent":["import type { VaryHeader } from './types';\n\nconst VALID_HEADER_NAME_REGEX = /^[a-z0-9-]+$/i;\n\n/**\n * Parses the Vary header as defined in\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * The Vary header indicates which request headers a server considers when selecting or\n * generating a response, enabling proper HTTP caching behavior.\n *\n * @remarks\n * - Header field names are normalized to lowercase\n * - Duplicate fields are automatically deduplicated\n * - Invalid header names (per RFC 9110) are silently skipped\n * - If the header contains `'*'`, the function returns `'*'` (wildcard)\n * - Returns `null` for invalid input or when no valid fields are found\n *\n * @example\n *\n * ```ts\n * parse('Accept-Encoding, User-Agent');\n * // => ['accept-encoding', 'user-agent']\n *\n * parse('*');\n * // => '*'\n *\n * parse('Invalid Header!');\n * // => null\n * ```\n *\n * @param {string} headerStr - The Vary header value to parse (e.g., \"Accept-Encoding,\n *   User-Agent\")\n * @param {number} [maxLength=16] - Maximum number of header fields to parse for DoS\n *   protection. Default is `16`\n * @returns {VaryHeader | null} The parsed Vary header as an array of lowercase field\n *   names, `'*'` for wildcard, or `null` if invalid.\n */\nexport function parse(headerStr?: string, maxLength = 16): VaryHeader | null {\n  // Invalid header name\n  if (typeof headerStr !== 'string') {\n    return null;\n  }\n\n  // RFC says only '*' is valid alone, but some servers may send invalid headers like '*, Accept-Encoding'\n  if (headerStr.includes('*')) {\n    return '*';\n  }\n\n  const values = new Set<string>();\n\n  for (let i = 0; i < headerStr.length; i++) {\n    const char = headerStr[i];\n\n    if (char === ' ' || char === '\\t' || char === ',') {\n      continue;\n    }\n\n    const start = i;\n\n    while (i < headerStr.length) {\n      const char = headerStr[i];\n\n      if (char === ',') {\n        break;\n      }\n\n      i++;\n    }\n\n    const headerName = headerStr.slice(start, i).trim().toLowerCase();\n\n    // Skip invalid header names\n    if (headerName.length === 0 || !VALID_HEADER_NAME_REGEX.test(headerName)) {\n      continue;\n    }\n\n    values.add(headerName);\n\n    // DOS protection to avoid overly large vary headers\n    if (values.size >= maxLength) {\n      break;\n    }\n  }\n\n  // Ensures no empty set is returned\n  if (values.size === 0) {\n    return null;\n  }\n\n  return Array.from(values);\n}\n","import type { CompareHeaders, VaryHeader } from './types';\n\n/**\n * Checks if {@linkcode source} and {@linkcode target} headers are equivalent for the given\n * Vary header, as per\n * {@link https://www.rfc-editor.org/rfc/rfc9110.html#name-vary RFC 9110 Section 12.5.5}.\n *\n * This function determines if two requests would receive the same cached response based\n * on the Vary header requirements.\n *\n * @remarks\n * - Returns `false` for wildcard vary (`'*'`) as responses always differ\n * - Header name matching is case-insensitive (per RFC 9110)\n * - Missing headers are treated as `undefined`\n * - String values are trimmed before comparison\n * - Array values are converted to strings via `.toString()`\n * - Uses loose equality (!=) for comparison\n * - Empty strings are distinct from missing headers\n *\n * @example\n *\n * ```ts\n * const vary = ['accept-encoding', 'user-agent'];\n * const headers1 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n * const headers2 = { 'Accept-Encoding': 'gzip', 'User-Agent': 'Chrome' };\n *\n * compare(vary, headers1, headers2);\n * // => true\n * ```\n *\n * @param {VaryHeader} vary - The Vary header specifying which fields to compare\n * @param {CompareHeaders} source - The first set of request headers\n * @param {CompareHeaders} target - The second set of request headers\n * @returns {boolean} `true` if the headers are equivalent for the given Vary header,\n *   `false` otherwise\n */\nexport function compare(\n  vary: VaryHeader,\n  source: CompareHeaders,\n  target: CompareHeaders\n): vary is string[] {\n  // Wildcard always differs\n  if (vary === '*') {\n    return false;\n  }\n\n  const sourceKeys = Object.keys(source);\n  const targetKeys = Object.keys(target);\n\n  for (const field of vary) {\n    let sourceValue: string | undefined;\n    let targetValue: string | undefined;\n\n    // Case-insensitive header lookup in source\n    for (const key of sourceKeys) {\n      if (key.toLowerCase() === field) {\n        sourceValue = source[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // Case-insensitive header lookup in target\n    for (const key of targetKeys) {\n      if (key.toLowerCase() === field) {\n        targetValue = target[key]?.toString()?.trim();\n        break;\n      }\n    }\n\n    // biome-ignore lint/suspicious/noDoubleEquals: Intentional loose comparison\n    if (sourceValue != targetValue) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"names":["VALID_HEADER_NAME_REGEX","vary","source","target","_step","sourceKeys","Object","keys","targetKeys","_iterator","_createForOfIteratorHelperLoose","done","_step2","field","value","sourceValue","targetValue","_iterator2","key","toLowerCase","_source$key","toString","trim","_step3","_iterator3","_target$_key","headerStr","maxLength","includes","values","Set","i","length","char","start","headerName","slice","test","add","size","Array","from"],"mappings":"sgCAEA,IAAMA,EAA0B,mCCmC9BC,EACAC,EACAC,GAGA,GAAa,MAATF,EACF,OACF,EAKA,IAHA,IAGwBG,EAHlBC,EAAaC,OAAOC,KAAKL,GACzBM,EAAaF,OAAOC,KAAKJ,GAE/BM,EAAAC,EAAoBT,KAAIG,EAAAK,KAAAE,MAAE,CAKxB,IALS,IAKmBC,EALnBC,EAAKT,EAAAU,MACVC,OAA+B,EAC/BC,OAGJ,EAAAC,EAAAP,EAAkBL,KAAUO,EAAAK,KAAAN,MAAE,CAAA,IAAnBO,EAAGN,EAAAE,MACZ,GAAII,EAAIC,gBAAkBN,EAAO,CAAA,IAAAO,EAC/BL,SAAWK,EAAGlB,EAAOgB,KAAgB,OAAZE,EAAXA,EAAaC,iBAAU,EAAvBD,EAAyBE,OACvC,KACF,CACF,CAGA,IAAA,IAA4BC,EAA5BC,EAAAd,EAAkBF,KAAUe,EAAAC,KAAAb,MAAE,CAAnB,IAAAO,EAAGK,EAAAT,MACZ,GAAII,EAAIC,gBAAkBN,EAAO,CAAAY,IAAAA,EAC/BT,EAAyBS,OAAdA,EAAGtB,EAAOe,KAAPO,OAAWA,EAAXA,EAAaJ,iBAAbI,EAAAA,EAAyBH,OACvC,KACF,CACF,CAGA,GAAIP,GAAeC,EACjB,OACF,CACF,CAEA,OACF,CAAA,mBDtCsBU,EAAoBC,GAExC,YAFwCA,IAAAA,EAAY,IAE3B,iBAAdD,EACT,OACF,KAGA,GAAIA,EAAUE,SAAS,KACrB,MAAO,IAKT,IAFA,IAAMC,EAAS,IAAIC,IAEVC,EAAI,EAAGA,EAAIL,EAAUM,OAAQD,IAAK,CACzC,IAAME,EAAOP,EAAUK,GAEvB,GAAa,MAATE,GAAyB,OAATA,GAA0B,MAATA,EAArC,CAMA,IAFA,IAAMC,EAAQH,EAEPA,EAAIL,EAAUM,QAGN,MAFAN,EAAUK,IAMvBA,IAGF,IAAMI,EAAaT,EAAUU,MAAMF,EAAOH,GAAGT,OAAOH,cAGpD,GAA0B,IAAtBgB,EAAWH,QAAiBhC,EAAwBqC,KAAKF,KAI7DN,EAAOS,IAAIH,GAGPN,EAAOU,MAAQZ,GACjB,KAzBF,CA2BF,CAGA,OAAoB,IAAhBE,EAAOU,KACF,KAGFC,MAAMC,KAAKZ,EACpB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "http-vary",
-  "version": "0.0.1",
+  "version": "1.0.1",
   "description": "A minimal parser and utility for the HTTP Vary header.",
   "keywords": [
     "vary",
@@ -38,11 +38,11 @@
     "LICENSE",
     "README.md"
   ],
+  "devDependencies": {
+    "microbundle": "^0.15.1"
+  },
   "scripts": {
     "build": "microbundle --tsconfig tsconfig.build.json",
     "test": "jest --coverage"
-  },
-  "devDependencies": {
-    "microbundle": "catalog:bundle"
   }
-}
+}

package/src/compare.ts

@@ -38,7 +38,7 @@ export function compare(
   vary: VaryHeader,
   source: CompareHeaders,
   target: CompareHeaders
-): boolean {
+): vary is string[] {
   // Wildcard always differs
   if (vary === '*') {
     return false;