@johntalton/http-util 5.1.6 → 6.1.0

package/src/{conditional.js → headers/conditional.js}

@@ -1,4 +1,6 @@
-import { isQuoted, stripQuotes } from './quote.js'
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: includes helper classes */
+/** biome-ignore-all lint/nursery/noExcessiveLinesPerFile: includes temporal and date support */
+import { isQuoted, stripQuotes } from './util/quote.js'
 
 /**
  * @typedef {Object} WeakEtagItem
@@ -24,7 +26,7 @@ import { isQuoted, stripQuotes } from './quote.js'
 /** @typedef {WeakEtagItem | NotWeakEtagItem | AnyEtagItem } EtagItem */
 
 /**
- * @typedef {Object} IMFFixDate
+ * @typedef {Object} IMFFixDateItem
  * @property {typeof DATE_DAYS[number]} dayName
  * @property {number} day
  * @property {typeof DATE_MONTHS[number]} month
@@ -32,9 +34,40 @@ import { isQuoted, stripQuotes } from './quote.js'
  * @property {number} hour
  * @property {number} minute
  * @property {number} second
+ */
+
+/**
+ * @typedef {Object} IMFFixDateItemExtension
  * @property {Date|undefined} [date]
+ * @property {Temporal.Instant|undefined} [instant]
  */
 
+/** @typedef {IMFFixDateItem & IMFFixDateItemExtension} IMFFixDate */
+/** @typedef {IMFFixDate|Date|Temporal.Instant|undefined} IMFFixDateInput */
+
+export const FEATURE_TEMPORAL = typeof Temporal !== 'undefined'
+
+export const IMF_FIX_DATE_FORMATTER = new Intl.DateTimeFormat('en-US', {
+	timeZone: 'UTC',
+	weekday: 'short',
+	year: 'numeric',
+	month: 'short',
+	day: '2-digit',
+	hour: '2-digit',
+	minute: '2-digit',
+	second: '2-digit',
+	hour12: false
+})
+
+/**
+ * @param {IMFFixDate|Date|Temporal.Instant|undefined} reference
+ * @returns {reference is Temporal.Instant}
+ */
+export function isTemporalInstant(reference) {
+	if(!FEATURE_TEMPORAL) { return false }
+	return reference instanceof Temporal.Instant
+}
+
 export const CONDITION_ETAG_SEPARATOR = ','
 export const CONDITION_ETAG_ANY = '*'
 export const CONDITION_ETAG_WEAK_PREFIX = 'W/'
@@ -54,25 +87,36 @@ export const MINIMUM_YEAR = 1900
 export const MAXIMUM_DAY = 31
 
 /**
+ * @deprecated
+ * @see {@link ETag.isValid}
  * @param {string} etag
  */
 export function isValidEtag(etag) {
-	// %x21 / %x23-7E  and %x80-FF
-	for(const c of etag) {
-		if(c.charCodeAt(0) < 0x21) { return false }
-		if(c.charCodeAt(0) > 0xFF) { return false }
-		if(c === ETAG_QUOTE) { return false }
-	}
-	return true
+	return ETag.isValid(etag)
 }
 
 export class ETag {
+	/**
+	 * @param {string} etag
+	 */
+	static isValid(etag) {
+		if(etag === undefined) { return false }
+
+		// %x21 / %x23-7E  and %x80-FF
+		for(const c of etag) {
+			if(c.charCodeAt(0) < 0x21) { return false }
+			if(c.charCodeAt(0) > 0xFF) { return false }
+			if(c === ETAG_QUOTE) { return false }
+		}
+		return true
+	}
+
 	/**
 	 * @param {string} etag
 	 * @returns {WeakEtagItem}
 	 */
 	static weak(etag) {
-		if(!isValidEtag(etag)) { throw new Error('invalid etag format') }
+		if(!ETag.isValid(etag)) { throw new Error('invalid etag format') }
 		return { any: false, weak: true, etag }
 	}
 
@@ -81,7 +125,7 @@ export class ETag {
 	 * @returns {NotWeakEtagItem}
 	 */
 	static strong(etag) {
-		if(!isValidEtag(etag)) { throw new Error('invalid etag format') }
+		if(!ETag.isValid(etag)) { throw new Error('invalid etag format') }
 		return { any: false, weak: false, etag }
 	}
 
@@ -106,8 +150,9 @@ export class ETag {
 		if(!isQuoted(quotedEtag)) { return undefined }
 		const etag = stripQuotes(quotedEtag)
 		if(etag === undefined) { return undefined }
-		if(!isValidEtag(etag)) { return undefined }
-		if(etag === CONDITION_ETAG_ANY) { return undefined }
+		if(etag === '') { return undefined }
+		if(etag === CONDITION_ETAG_ANY) { return ANY_ETAG_ITEM } // todo: should this return undefined?
+		if(!ETag.isValid(etag)) { return undefined }
 
 		return {
 			weak,
@@ -117,6 +162,100 @@ export class ETag {
 	}
 }
 
+export class FixDate {
+
+	/**
+	 * True if {@link test} is after (exclusive) the {@link reference}
+	 * (compares are seconds precision)
+	 * @param {IMFFixDateInput} reference
+	 * @param {IMFFixDateInput} test
+	 * @returns {boolean}
+	 */
+	static isAfter(reference, test) {
+		if(reference === undefined) { return false }
+		if(test === undefined) { return false }
+
+		if(FEATURE_TEMPORAL) {
+			/** @type {Temporal.RoundingOptions<Temporal.TimeUnit>} */
+			const precision = {
+				smallestUnit: 'second',
+				roundingMode: 'trunc'
+			}
+
+			const referenceInstant = FixDate.toInstant(reference)?.round(precision)
+			const testInstant = FixDate.toInstant(test)?.round(precision)
+
+			if(referenceInstant === undefined) { return false }
+			if(testInstant === undefined) { return false }
+
+			return Temporal.Instant.compare(referenceInstant, testInstant) === -1
+		}
+
+		//
+		const referenceDate = FixDate.toDate(reference)
+		const testDate = FixDate.toDate(test)
+
+		if(referenceDate === undefined) { return false }
+		if(testDate === undefined) { return false }
+
+		// this effectively rounds to seconds
+		referenceDate.setMilliseconds(0)
+		testDate.setMilliseconds(0)
+
+		return testDate > referenceDate
+	}
+
+	/**
+	 * @param {IMFFixDateInput} reference
+	 * @returns {Temporal.Instant|undefined}
+	 */
+	static toInstant(reference) {
+		if(!FEATURE_TEMPORAL) { return undefined }
+		if(reference === undefined) { return undefined }
+
+		if(isTemporalInstant(reference)) { return reference }
+		if(reference instanceof Date) { return reference.toTemporalInstant() }
+
+		if(reference.instant !== undefined) { return reference.instant }
+		if(reference.date !== undefined) { return reference.date.toTemporalInstant() }
+
+		const { year, month: monthName, day, hour, minute, second } = reference
+
+		const zeroMonth = DATE_MONTHS.indexOf(monthName)
+		if(zeroMonth === -1) { return undefined }
+		const month = zeroMonth + 1
+
+		const zdt = Temporal.ZonedDateTime.from({
+			year,
+			month,
+			day,
+			hour,
+			minute,
+			second,
+			timeZone: 'UTC'
+		})
+
+		return zdt.toInstant()
+	}
+
+	/**
+	 * @param {IMFFixDateInput} reference
+	 * @returns {Date|undefined}
+	 */
+	static toDate(reference) {
+		if(reference === undefined) { return undefined }
+
+		if(reference instanceof Date) { return reference }
+		if(isTemporalInstant(reference)) { return new Date(reference.epochMilliseconds) }
+
+		if(FEATURE_TEMPORAL && (reference.instant !== undefined)) { return new Date(reference.instant.epochMilliseconds) }
+		if(reference.date !== undefined) { return reference.date }
+
+		const { year, month, day, hour, minute, second } = reference
+		return new Date(Date.UTC(year, DATE_MONTHS.indexOf(month), day, hour, minute, second))
+	}
+}
+
 export class Conditional {
 	/**
 	 * @param {EtagItem|undefined} etagItem
@@ -130,7 +269,7 @@ export class Conditional {
 		}
 
 		if(etagItem.etag === CONDITION_ETAG_ANY) { return undefined }
-		if(!isValidEtag(etagItem.etag)) { return undefined }
+		if(!ETag.isValid(etagItem.etag)) { return undefined }
 
 		const prefix = etagItem.weak ? CONDITION_ETAG_WEAK_PREFIX : ''
 		return `${prefix}${ETAG_QUOTE}${etagItem.etag}${ETAG_QUOTE}`
@@ -149,29 +288,47 @@ export class Conditional {
 	}
 
 	/**
-	 * @param {Array<EtagItem>} etagItemList
+	 * @param {Array<EtagItem>|undefined} etagItemList
 	 */
 	static hasAny(etagItemList) {
-		return etagItemList.find(item => item.any) !== undefined
+		return etagItemList?.find(item => item.any) !== undefined
 	}
 
 	/**
-	 * @param {Array<EtagItem>} etagItemList
-	 * @param {string} etag
+	 * @param {Array<EtagItem>|undefined} etagItemList
+	 * @param {string|undefined} etag
 	 */
 	static hasEtag(etagItemList, etag) {
-		return etagItemList.find(item => item.etag === etag) !== undefined
+		return etagItemList?.find(item => item.etag === etag) !== undefined
 	}
 
 	/**
-	 * @param {IMFFixDate|undefined} fixDate
+	 * @param {IMFFixDateInput|string|undefined} reference
 	 * @returns {string|undefined}
 	 */
-	static encodeFixDate(fixDate) {
-		if(fixDate === undefined) { return undefined }
-		if(fixDate.date !== undefined) { return fixDate.date.toUTCString() }
+	static encodeFixDate(reference) {
+		if(reference === undefined) { return undefined }
+
+		if(typeof reference === 'string') { return reference }
+		if(reference instanceof Date) { return reference.toUTCString() }
+		if(isTemporalInstant(reference)) {
+
+			const parts = IMF_FIX_DATE_FORMATTER.formatToParts(reference)
+			const m = new Map(parts.map(p => [ p.type, p.value ]))
+			const weekday = m.get('weekday') ?? 'ERR'
+			const day = m.get('day') ?? '00'
+			const month = m.get('month') ?? '00'
+			const year = m.get('year') ?? '0000'
+			const hour = m.get('hour') ?? '00'
+			const minute = m.get('minute') ?? '00'
+			const second = m.get('second') ?? '00'
+
+			return `${weekday}, ${day} ${month} ${year} ${hour}:${minute}:${second} ${DATE_ZONE}`
+		}
 
-		const { year, month, day, hour, minute, second } = fixDate
+		if(reference.date !== undefined) { return reference.date.toUTCString() }
+
+		const { year, month, day, hour, minute, second } = reference
 		const d = new Date(Date.UTC(year, DATE_MONTHS.indexOf(month), day, hour, minute, second))
 		return d.toUTCString()
 	}
@@ -241,105 +398,21 @@ export class Conditional {
 		if(minute > 60 || minute < 0) { return undefined }
 		if(second > 60 || second < 0) { return undefined }
 
-		//
-		return {
+		const fixDate = {
 			dayName,
 			day,
 			month,
 			year,
 			hour,
 			minute,
-			second,
-			date: new Date(Date.UTC(year, DATE_MONTHS.indexOf(month), day, hour, minute, second)),
-			// temporal:
+			second
+		}
+
+		//
+		return {
+			...fixDate,
+			date: FixDate.toDate(fixDate),
+			instant: FixDate.toInstant(fixDate)
 		}
 	}
 }
-
-// Ok
-// console.log(Conditional.encodeEtag({ any: true, weak: false, etag: '*' }))
-// console.log(Conditional.encodeEtag({ any: true, weak: true, etag: '*' }))
-// console.log(Conditional.encodeEtag({ any: false, weak: false, etag: 'Foo' }))
-// console.log(Conditional.encodeEtag({ any: false, weak: true, etag: 'WeakFoo' }))
-
-// Error
-// console.log(Conditional.encodeEtag(undefined))
-// console.log(Conditional.encodeEtag({ any: true, weak: false, etag: 'NotAsterisk' }))
-// console.log(Conditional.encodeEtag({ any: false, weak: false, etag: 'Foo\tBar' }))
-// console.log(Conditional.encodeEtag({ any: false, weak: false, etag: 'Foo"Bar' }))
-// console.log(Conditional.encodeEtag({ any: false, weak: false, etag: '*' }))
-
-
-// Ok
-// console.log(Conditional.parseEtagList('"bfc13a64729c4290ef5b2c2730249c88ca92d82d"'))
-// console.log(Conditional.parseEtagList('W/"67ab43", "54ed21", "7892dd"'))
-// console.log(Conditional.parseEtagList('*'))
-// console.log(Conditional.parseEtagList('"!ÿ©"'))
-// console.log(Conditional.parseEtagList('"!","ÿ", "©"'))
-// console.log(Conditional.parseEtagList('"!","ÿ"   ,\t"©"'))
-
-// Error
-// console.log(Conditional.parseEtagList('"*"'))
-// console.log(Conditional.parseEtagList('W/'))
-// console.log(Conditional.parseEtagList('W/"'))
-// console.log(Conditional.parseEtagList('W/""'))
-// console.log(Conditional.parseEtagList(''))
-// console.log(Conditional.parseEtagList('"'))
-// console.log(Conditional.parseEtagList('""'))
-// console.log(Conditional.parseEtagList('"""'))
-// console.log(Conditional.parseEtagList('" "'))
-// console.log(Conditional.parseEtagList('"\n"'))
-// console.log(Conditional.parseEtagList('"\t"'))
-
-//
-// const testsOk = [
-// 	'Sun, 06 Nov 1994 08:49:37 GMT',
-// 	'Sun, 06 Nov 1994 00:00:00 GMT',
-// 	'Tue, 01 Nov 1994 00:00:00 GMT',
-// 	'Thu, 06 Nov 3000 08:49:37 GMT',
-// 	'Sun, 06 Nov 1994 23:59:59 GMT',
-// 	new String('Sun, 06 Nov 1994 08:49:37 GMT'),
-// ]
-// for(const test of testsOk) {
-// 	const result = Conditional.parseFixDate(test)
-// 	if(result?.date.toUTCString() !== test.toString()) {
-// 		console.log('🛑', test, result, result?.date.toUTCString())
-// 		break
-// 	}
-// }
-
-
-
-// const testBad = [
-// 	undefined,
-// 	null,
-// 	{},
-// 	new String(),
-// 	'',
-// 	'Anything',
-// 	'   ,               :  :   GMT',
-// 	'Sun,    Nov        :  :   GMT',
-// 	'Sun, 00 Nov 0000 00:00:00 GMT',
-// 	'Sun, 06 Nov 1994 08-49-37 GMT',
-// 	'Sun  06 Nov 1994 08:49:37 GMT',
-// 	'FOO, 06 Nov 1994 08:49:37 GMT',
-// 	'Sun, 32 Nov 1994 08:49:37 GMT',
-// 	'Sun, 00 Nov 1994 08:49:37 GMT',
-// 	'Sun, 06 Nov 0900 08:49:37 GMT',
-// 	'Sun, 06 Nov 1994 08:49:37 UTC',
-// 	'Sun, 06 Nov 1994 30:49:37 GMT',
-// 	'Sun,\t06 Nov 1994 08:49:37 GMT',
-
-// 	'Sunday, 06-Nov-94 08:49:37 GMT',
-// 	'Sun Nov  6 08:49:37 1994',
-// 	'Sun Nov  6 08:49:37 1994      ',
-
-// ]
-// for(const test of testBad) {
-// 	const result = Conditional.parseFixDate(test)
-// 	if(result !== undefined) {
-// 		console.log('🛑', test, result)
-// 		break
-// 	}
-// }
-

package/src/headers/content-disposition.js

@@ -0,0 +1,44 @@
+import { KVP } from './util/kvp.js'
+
+/**
+ * @typedef {Object} Disposition
+ * @property {string} disposition
+ * @property {Map<string, string|undefined>} parameters
+ * @property {string|undefined} [name]
+ * @property {string|undefined} [filename]
+ */
+
+export const DISPOSITION_PARAM_NAME = 'name'
+export const DISPOSITION_PARAM_FILENAME = 'filename'
+
+/**
+ * @deprecated
+ * @see {@link ContentDisposition.parse}
+ * @param {string|undefined} contentDispositionHeader
+ * @returns {Disposition|undefined}
+ */
+export function parseContentDisposition(contentDispositionHeader) {
+	return ContentDisposition.parse(contentDispositionHeader)
+}
+
+export class ContentDisposition {
+	/**
+	 * @param {string|undefined} header
+	 * @returns {Disposition|undefined}
+	 */
+	static parse(header) {
+		if(header === undefined) { return undefined }
+
+		const { name: disposition, parameters } = KVP.parse(header) ?? { parameters: new Map() }
+		if(disposition === undefined) { return undefined }
+
+		const name = parameters.get(DISPOSITION_PARAM_NAME)
+		const filename = parameters.get(DISPOSITION_PARAM_FILENAME)
+
+		return {
+			disposition,
+			parameters,
+			name, filename
+		}
+	}
+}

package/src/{content-range.js → headers/content-range.js}

@@ -1,4 +1,4 @@
-import { RANGE_UNITS_BYTES } from "./response/defs.js"
+import { RANGE_UNITS_BYTES } from '../defs.js'
 
 export const CONTENT_RANGE_UNKNOWN = '*'
 export const CONTENT_RANGE_SEPARATOR = '-'
@@ -40,20 +40,3 @@ export class ContentRange {
 		return `${units} ${rangeStr}${CONTENT_RANGE_SIZE_SEPARATOR}${size}`
 	}
 }
-
-// console.log(ContentRange.encode({}))
-// console.log(ContentRange.encode({ size: '*' }))
-// console.log(ContentRange.encode({ units: 'bytes' }))
-// console.log(ContentRange.encode({ range: '*' }))
-// console.log(ContentRange.encode({ range: '*', size: '*' }))
-
-// console.log()
-// console.log(ContentRange.encode({ range: { start: 0, end: 1024 } }))
-// console.log(ContentRange.encode({ range: { start: 0, end: 1024 }, size: 1024  }))
-// console.log(ContentRange.encode({ range: '*', size: 1024 }))
-// console.log(ContentRange.encode({ size: 1024 }))
-
-// console.log()
-// console.log(ContentRange.encode({ units: 'bob' }))
-// console.log(ContentRange.encode({ range: 'bob' }))
-// console.log(ContentRange.encode({ size: 'bob' }))

package/src/headers/content-type.js

@@ -0,0 +1,101 @@
+import { KVP } from './util/kvp.js'
+import { MIME_ANY, Mime } from './util/mime.js'
+
+/** @import { MimeItem } from './util/mime.js' */
+
+export const MIME_TYPE_JSON = 'application/json'
+export const MIME_TYPE_TEXT = 'text/plain'
+export const MIME_TYPE_EVENT_STREAM = 'text/event-stream'
+export const MIME_TYPE_XML = 'application/xml'
+export const MIME_TYPE_URL_FORM_DATA = 'application/x-www-form-urlencoded'
+export const MIME_TYPE_MULTIPART_FORM_DATA = 'multipart/form-data'
+export const MIME_TYPE_MULTIPART_RANGE = 'multipart/byteranges'
+export const MIME_TYPE_OCTET_STREAM = 'application/octet-stream'
+export const MIME_TYPE_MESSAGE_HTTP = 'message/http'
+
+
+export const KNOWN_CONTENT_TYPES = [
+	'application', 'audio', 'image', 'message',
+	'multipart','text', 'video'
+]
+
+export const TYPE_X_TOKEN_PREFIX = 'X-'
+
+/**
+ * @typedef {Object} ContentTypeExtension
+ * @property {string} name
+ * @property {string} [charset]
+ * @property {Map<string, string>} parameters
+ */
+
+/** @typedef {MimeItem & ContentTypeExtension} ContentTypeItem */
+
+export const CONTENT_TYPE_SEPARATOR = {
+	SUBTYPE: '/',
+	PARAMETER: ';',
+	KVP: '='
+}
+
+export const CHARSET_UTF8 = 'utf8'
+export const CHARSET = 'charset'
+export const PARAMETER_CHARSET_UTF8 = `${CHARSET}${CONTENT_TYPE_SEPARATOR.KVP}${CHARSET_UTF8}`
+export const CONTENT_TYPE_JSON = `${MIME_TYPE_JSON}${CONTENT_TYPE_SEPARATOR.PARAMETER}${PARAMETER_CHARSET_UTF8}`
+export const CONTENT_TYPE_TEXT = `${MIME_TYPE_TEXT}${CONTENT_TYPE_SEPARATOR.PARAMETER}${PARAMETER_CHARSET_UTF8}`
+export const CONTENT_TYPE_MESSAGE_HTTP = `${MIME_TYPE_MESSAGE_HTTP}${CONTENT_TYPE_SEPARATOR.PARAMETER}${PARAMETER_CHARSET_UTF8}`
+
+/** @type {ContentTypeItem} */
+export const WELL_KNOWN_JSON = {
+	mimetype: MIME_TYPE_JSON,
+	name: MIME_TYPE_JSON,
+	type: 'application',
+	subtype: 'json',
+	charset: 'utf8',
+	parameters: new Map()
+}
+
+export const WELL_KNOWN_CONTENT_TYPES = new Map([
+	[ 'application/json', WELL_KNOWN_JSON ],
+	[ 'application/json;charset=utf8', WELL_KNOWN_JSON ]
+])
+
+/**
+ * @deprecated
+ * @see {@link ContentType.parse}
+ * @param {string|undefined} contentTypeHeader
+ * @returns {ContentTypeItem|undefined}
+ */
+export function parseContentType(contentTypeHeader) {
+	return ContentType.parse(contentTypeHeader)
+}
+
+export class ContentType {
+	/**
+	 * @param {string|undefined} header
+	 * @returns {ContentTypeItem|undefined}
+	 */
+	static parse(header) {
+		if(header === undefined) { return undefined }
+		if(header === null) { return undefined }
+
+		const wellKnown = WELL_KNOWN_CONTENT_TYPES.get(header)
+		if(wellKnown !== undefined) { return wellKnown }
+
+		const { name, parameters } = KVP.parse(header) ?? { parameters: new Map() }
+		if(name === undefined) { return undefined }
+
+		const mimetype = Mime.parse(name)
+		if(mimetype === undefined) { return undefined }
+
+		if(mimetype.type === MIME_ANY) { return undefined }
+		if(mimetype.subtype === MIME_ANY) { return undefined }
+
+		const charset = parameters?.get(CHARSET)
+
+		return {
+			...mimetype,
+			name,
+			charset,
+			parameters
+		}
+	}
+}

package/src/{forwarded.js → headers/forwarded.js}

@@ -1,3 +1,5 @@
+import { KVP } from './util/kvp.js'
+
 export const FORWARDED_KEY_BY = 'by'
 export const FORWARDED_KEY_FOR = 'for'
 export const FORWARDED_KEY_HOST = 'host'
@@ -13,11 +15,8 @@ export const KNOWN_FORWARDED_KEYS = [
 export const SKIP_ANY = '*'
 
 export const FORWARDED_SEPARATOR = {
-	ITEM: ',',
-	ELEMENT: ';',
-	KVP: '='
+	ITEM: ','
 }
-
 export class Forwarded {
 	/**
 	 * @param {string|undefined} header
@@ -30,26 +29,10 @@ export class Forwarded {
 		return header
 			.trim()
 			.split(FORWARDED_SEPARATOR.ITEM)
-			.map(single => new Map(single
-					.trim()
-					.split(FORWARDED_SEPARATOR.ELEMENT)
-					.map(kvp => {
-						const [ rawKey, rawValue ] = kvp.trim().split(FORWARDED_SEPARATOR.KVP)
-
-						const key = rawKey?.trim()?.toLowerCase()
-						if (key === undefined || !acceptedKeys.includes(key)) { return undefined }
-
-						const value = rawValue?.trim()
-						if(value === undefined) { return undefined }
-						if(value.length <= 0) { return undefined }
-
-						/** @type {[string, string]} */
-						const result = [ key, value ]
-						return result
-					})
-					.filter(item => item !== undefined))
-			)
+			.map(single => KVP.parseParameters(single, acceptedKeys)?.parameters)
+			.filter(m => m !== undefined)
 			.filter(m => m.size > 0)
+			.filter(m => m.get(FORWARDED_KEY_FOR) !== undefined)
 	}
 
 	/**
@@ -58,6 +41,8 @@ export class Forwarded {
 	 * @returns {Map<string, string>|undefined}
 	 */
 	static selectRightMost(forwardedList, skipList = []) {
+		if(forwardedList === undefined) { return undefined }
+
 		const iter = skipList[Symbol.iterator]()
 
 		for(const forwarded of forwardedList.toReversed()) {
@@ -71,39 +56,6 @@ export class Forwarded {
 	}
 }
 
-
-/*
-const examples = [
-	{ f: [], s: [], ef: undefined },
-
-	{ f: [], s: [ '1.1.1.1' ] , ef: undefined },
-	{ f: [], s: [ '*' ] , ef: undefined },
-
-	{ f: [ { for: '1.1.1.1' } ], s: [], ef: '1.1.1.1' },
-	{ f: [ { for: '1.1.1.1' } ], s: [ '*' ], ef: undefined },
-	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' } ], s: [], ef: '2.2.2.2' },
-	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' } ], s: [ '2.2.2.2' ], ef: '1.1.1.1' },
-	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' }, { for: '3.3.3.3' } ], s: [ '3.3.3.3', '2.2.2.2' ], ef: '1.1.1.1' },
-	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' }, { for: '3.3.3.3' } ], s: [ '3.3.3.3', '*' ], ef: '1.1.1.1' },
-	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' }, { for: '3.3.3.3' } ], s: [ '*', '*' ], ef: '1.1.1.1' },
-	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' }, { for: '3.3.3.3' } ], s: [ '*', '*', '*' ], ef: undefined },
-
-	{ f: [ { for: '1.1.1.1' } ], s: [ '*', '*' ], ef: undefined },
-
-	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' }, { for: '3.3.3.3' } ], s: [ '3.3.3.3'], ef: '2.2.2.2' },
-	{ f: [ { for: '1.1.1.1' }, { for: '2.2.2.2' }, { for: '3.3.3.3' } ], s: [ '*'], ef: '2.2.2.2' },
-]
-
-for(const { f, s, ef } of examples) {
-	const result = Forwarded.selectRightMost(f.map(i => new Map(Object.entries(i))), s)
-	const resultFor = result?.get('for')
-	if(resultFor !== ef) {
-		console.log(`mismatch ${ef} !== ${resultFor}`)
-	}
-}
-*/
-
-
 /*
 	const examples = [
 		null,

package/src/{index.js → headers/index.js}

@@ -3,18 +3,20 @@
 export * from './accept.js'
 export * from './accept-encoding.js'
 export * from './accept-language.js'
-export * from './accept-util.js'
 export * from './cache-control.js'
 export * from './clear-site-data.js'
+export * from './client-hints.js'
 export * from './conditional.js'
 export * from './content-disposition.js'
 export * from './content-range.js'
 export * from './content-type.js'
-export * from './forwarded.js'
 export * from './fetch-metadata.js'
+export * from './forwarded.js'
+export * from './link.js'
 export * from './multipart.js'
 export * from './preference.js'
 export * from './range.js'
 export * from './rate-limit.js'
 export * from './server-timing.js'
+export * from './strict-transport-security.js'
 export * from './www-authenticate.js'