@johntalton/http-util 4.1.1 → 5.0.1

package/src/content-range.js

@@ -0,0 +1,59 @@
+import { RANGE_UNITS_BYTES } from "./response/defs.js"
+
+export const CONTENT_RANGE_UNKNOWN = '*'
+export const CONTENT_RANGE_SEPARATOR = '-'
+export const CONTENT_RANGE_SIZE_SEPARATOR = '/'
+
+export const DEFAULT_CONTENT_RANGE_DIRECTIVE = {
+	units: RANGE_UNITS_BYTES,
+	range: CONTENT_RANGE_UNKNOWN,
+	size: CONTENT_RANGE_UNKNOWN
+}
+/**
+ * @typedef {Object} ContentRangeDirective
+ * @property {RANGE_UNITS_BYTES|undefined} [units]
+ * @property {{ start: number, end: number }|CONTENT_RANGE_UNKNOWN|undefined} [range]
+ * @property {number|CONTENT_RANGE_UNKNOWN|undefined} [size]
+ */
+
+export class ContentRange {
+	/**
+	 * @param {ContentRangeDirective|undefined} rangeDirective
+	 * @returns {string|undefined}
+	 */
+	static encode(rangeDirective) {
+		if(rangeDirective === undefined) { return undefined }
+
+		const units = rangeDirective.units ?? DEFAULT_CONTENT_RANGE_DIRECTIVE.units
+		const size = rangeDirective.size ?? DEFAULT_CONTENT_RANGE_DIRECTIVE.size
+		const range = rangeDirective.range ?? DEFAULT_CONTENT_RANGE_DIRECTIVE.range
+
+		if(units !== RANGE_UNITS_BYTES) { return undefined }
+		if(size !== CONTENT_RANGE_UNKNOWN && !Number.isInteger(size)) { return undefined }
+
+		if((typeof range === 'string')) {
+			if(range !== CONTENT_RANGE_UNKNOWN) { return undefined }
+			return `${units} ${CONTENT_RANGE_UNKNOWN}${CONTENT_RANGE_SIZE_SEPARATOR}${size}`
+		}
+
+		const rangeStr = `${range.start}${CONTENT_RANGE_SEPARATOR}${range.end}`
+		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/content-type.js

@@ -5,9 +5,11 @@ 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'
@@ -27,10 +29,12 @@ export const SPECIAL_CHARS = [
 	'\n', '\r', '\t'
 ]
 
+export const WHITESPACE_REGEX = /\s/
+
 /**
  * @param {string} c
  */
-export function isWhitespace(c){ return /\s/.test(c) }
+export function isWhitespace(c){ return WHITESPACE_REGEX.test(c) }
 
 /**
  * @param {string|undefined} value
@@ -114,22 +118,21 @@ export function parseContentType(contentTypeHeader) {
 
 	const parameters = new Map()
 
-	parameterSet
-			.forEach(parameter => {
-				const [ key, value ] = parameter.split(CONTENT_TYPE_SEPARATOR.KVP)
-				if(key === undefined || key === '') { return }
-				if(value === undefined || value === '') { return }
-				if(hasSpecialChar(key)) { return }
+	for(const parameter of parameterSet) {
+		const [ key, value ] = parameter.split(CONTENT_TYPE_SEPARATOR.KVP)
+		if(key === undefined || key === '') { return }
+		if(value === undefined || value === '') { return }
+		if(hasSpecialChar(key)) { return }
 
-				const actualKey = key?.trim().toLowerCase()
+		const actualKey = key?.trim().toLowerCase()
 
-				const quoted = (value.charAt(0) === '"' && value.charAt(value.length - 1) === '"')
-				const actualValue = quoted ? value.substring(1, value.length - 1) : value
+		const quoted = (value.at(0) === '"' && value.at(-1) === '"')
+		const actualValue = quoted ? value.substring(1, value.length - 1) : value
 
-				if(!parameters.has(actualKey)) {
-					parameters.set(actualKey, actualValue)
-				}
-			})
+		if(!parameters.has(actualKey)) {
+			parameters.set(actualKey, actualValue)
+		}
+	}
 
 	const charset = parameters.get(CHARSET)
 

package/src/forwarded.js

@@ -49,7 +49,7 @@ export class Forwarded {
 					})
 					.filter(item => item !== undefined))
 			)
-			.filter(m => m.size !== 0)
+			.filter(m => m.size > 0)
 	}
 
 	/**

package/src/index.js

@@ -1,11 +1,16 @@
+/** biome-ignore-all lint/performance/noBarrelFile: entry point */
+/** biome-ignore-all lint/performance/noReExportAll: entry point */
+export * from './accept.js'
 export * from './accept-encoding.js'
 export * from './accept-language.js'
 export * from './accept-util.js'
-export * from './accept.js'
+export * from './cache-control.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 './multipart.js'
+export * from './range.js'
 export * from './rate-limit.js'
 export * from './server-timing.js'

package/src/multipart.js

@@ -1,6 +1,18 @@
+import { ReadableStream } from 'node:stream/web'
+
 import { parseContentDisposition } from './content-disposition.js'
+import { ContentRange } from './content-range.js'
 import { parseContentType } from './content-type.js'
 
+/** @import { ContentRangeDirective } from './content-range.js' */
+/** @import { SendBody } from './response/send-util.js' */
+
+/**
+ * @typedef {Object} MultipartBytePart
+ * @property {SendBody} obj
+ * @property {ContentRangeDirective} range
+ */
+
 export const DISPOSITION_FORM_DATA = 'form-data'
 
 export const BOUNDARY_MARK = '--'
@@ -12,7 +24,8 @@ export const EMPTY = ''
 
 export const MULTIPART_HEADER = {
 	CONTENT_DISPOSITION: 'content-disposition',
-	CONTENT_TYPE: 'content-type'
+	CONTENT_TYPE: 'content-type',
+	CONTENT_RANGE: 'content-range'
 }
 
 export const MULTIPART_STATE = {
@@ -29,6 +42,15 @@ export class Multipart {
 	 * @param {string} [charset='utf8']
 	 */
 	static parse(text, boundary, charset = 'utf8') {
+		return Multipart.parse_FormData(text, boundary, charset)
+	}
+
+	/**
+	 * @param {string} text
+	 * @param {string} boundary
+	 * @param {string} [_charset='utf8']
+	 */
+	static parse_FormData(text, boundary, _charset = 'utf8') {
 		// console.log({ boundary, text })
 		const formData = new FormData()
 
@@ -69,10 +91,10 @@ export class Multipart {
 				if(line === EMPTY) { state = MULTIPART_STATE.VALUE }
 				else {
 					const [ rawName, value ] = line.split(HEADER_SEPARATOR)
-					const name = rawName.toLowerCase()
+					const name = rawName?.toLowerCase()
 					// console.log('header', name, value)
 					if(name === MULTIPART_HEADER.CONTENT_TYPE) {
-						const contentType = parseContentType(value)
+						const _contentType = parseContentType(value)
 						// console.log({ contentType })
 					}
 					else if(name === MULTIPART_HEADER.CONTENT_DISPOSITION) {
@@ -114,36 +136,62 @@ export class Multipart {
 
 		return formData
 	}
-}
 
+	/**
+	 * @param {string} contentType
+	 * @param {Array<MultipartBytePart>} parts
+	 * @param {number|undefined} contentLength
+	 * @param {string} boundary
+	 * @returns {ReadableStream<Uint8Array>}
+	 */
+	static encode_Bytes(contentType, parts, contentLength, boundary) {
+		const boundaryBegin = `${BOUNDARY_MARK}${boundary}`
+		const boundaryEnd = `${BOUNDARY_MARK}${boundary}${BOUNDARY_MARK}`
 
+		return new ReadableStream({
+			type: 'bytes',
+			async start(controller) {
+				const encoder = new TextEncoder()
+
+				for (const part of parts) {
+					controller.enqueue(encoder.encode(`${boundaryBegin}${MULTIPART_SEPARATOR}`))
+					controller.enqueue(encoder.encode(`${MULTIPART_HEADER.CONTENT_TYPE}: ${contentType}${MULTIPART_SEPARATOR}`))
+					controller.enqueue(encoder.encode(`${MULTIPART_HEADER.CONTENT_RANGE}: ${ContentRange.encode({ ...part.range, size: contentLength })}${MULTIPART_SEPARATOR}`))
+					controller.enqueue(encoder.encode(MULTIPART_SEPARATOR))
+					// controller.enqueue(encoder.encode(MULTIPART_SEPARATOR))
+
+					if(part.obj instanceof ReadableStream) {
+						for await (const chunk of part.obj) {
+							if(chunk instanceof ArrayBuffer || ArrayBuffer.isView(chunk)) {
+								controller.enqueue(chunk)
+							}
+							else if(typeof chunk === 'string'){
+								controller.enqueue(encoder.encode(chunk))
+							}
+							else {
+								// console.log('chunk type', typeof chunk)
+								controller.enqueue(Uint8Array.from([ chunk ]))
+							}
+						}
+					}
+					else if(part.obj instanceof ArrayBuffer || ArrayBuffer.isView(part.obj)) {
+						controller.enqueue(part.obj)
+					}
+					else if(typeof part.obj === 'string'){
+						controller.enqueue(encoder.encode(part.obj))
+					}
+					else {
+						// console.log('error', typeof part.obj, part.obj)
+						throw new Error('unknown part type')
+					}
 
-// const test = '--X-INSOMNIA-BOUNDARY\r\n' +
-//     'Content-Disposition: form-data; name="u"\r\n' +
-//     '\r\n' +
-//     'alice\r\n' +
-//     '--X-INSOMNIA-BOUNDARY\r\n' +
-//     'Content-Disposition: form-data; name="user"\r\n' +
-//     '\r\n' +
-//     'jeff\r\n' +
-//     '--X-INSOMNIA-BOUNDARY--\r\n'
-// const result = Multipart.parse(test, 'X-INSOMNIA-BOUNDARY')
-// console.log(result)
-
-
-// const test = [
-// 	'-----------------------------paZqsnEHRufoShdX6fh0lUhXBP4k',
-//  'Content-Disposition: form-data; '
-//    + 'name="upload_file_0"; filename="テスト.dat"',
-//  'Content-Type: application/octet-stream',
-//  '',
-//  'A'.repeat(1023),
-//  '-----------------------------paZqsnEHRufoShdX6fh0lUhXBP4k--'
-// ].join('\r\n')
-// const result = Multipart.parse(test, '---------------------------paZqsnEHRufoShdX6fh0lUhXBP4k')
-// console.log(result)
-
-
-// const test = '--X-INSOMNIA-BOUNDARY--\r\n'
-// const result = Multipart.parse(test, 'X-INSOMNIA-BOUNDARY')
-// console.log(result)
+					controller.enqueue(encoder.encode(MULTIPART_SEPARATOR))
+				}
+
+				controller.enqueue(encoder.encode(boundaryEnd))
+
+      	controller.close()
+			}
+		})
+	}
+}

package/src/preference.js

@@ -0,0 +1,205 @@
+// https://datatracker.ietf.org/doc/html/rfc7240
+// https://www.rfc-editor.org/rfc/rfc7240#section-3
+
+export const SEPARATOR = {
+	PREFERENCE: ',',
+	PARAMS: ';',
+	PARAM_KVP: '=',
+	KVP: '='
+}
+
+export const QUOTE = '"'
+
+export const DIRECTIVE_RESPOND_ASYNC = 'respond-async'
+export const DIRECTIVE_WAIT = 'wait'
+export const DIRECTIVE_HANDLING = 'handling'
+export const DIRECTIVE_REPRESENTATION = 'return'
+export const DIRECTIVE_TIMEZONE = 'timezone'
+
+export const DIRECTIVE_HANDLING_STRICT = 'strict'
+export const DIRECTIVE_HANDLING_LENIENT = 'lenient'
+
+export const DIRECTIVE_REPRESENTATION_MINIMAL = 'minimal'
+export const DIRECTIVE_REPRESENTATION_HEADERS_ONLY = 'headers-only'
+export const DIRECTIVE_REPRESENTATION_FULL = 'representation'
+
+
+/**
+ * @param {string|undefined} value
+ */
+export function stripQuotes(value) {
+	if(value === undefined) { return undefined }
+	return value.substring(1, value.length - 1)
+}
+
+/**
+ * @param {string|undefined} value
+ */
+export function isQuoted(value) {
+	if(value === undefined) { return false }
+	if(value.length < 2) { return false }
+	if(!value.startsWith(QUOTE)) { return false }
+	if(!value.endsWith(QUOTE)) { return false }
+	return true
+}
+
+/**
+ * @typedef {Object} Preference
+ * @property {string|undefined} value
+ * @property {Map<string, string|undefined>} parameters
+ */
+
+/**
+ * @template P
+ * @typedef {Object} RequestPreferencesBase
+ * @property {boolean|undefined} [asynchronous]
+ * @property {string|undefined} [representation]
+ * @property {string|undefined} [handling]
+ * @property {number|undefined} [wait]
+ * @property {string|undefined} [timezone]
+ * @property {Map<string, P>} preferences
+ */
+
+/** @typedef {RequestPreferencesBase<Preference>} RequestPreferences */
+/** @typedef {RequestPreferencesBase<Partial<Omit<Preference,'parameters'>>|undefined>} AppliedRequestPreferences */
+
+export class Preferences {
+	/**
+	 * @param {string|undefined} header
+	 * @returns {RequestPreferences|undefined}
+	 */
+	static parse(header) {
+		if(header === undefined) { return undefined }
+
+		const preferences = new Map(header.split(SEPARATOR.PREFERENCE)
+			.map(pref => {
+				const [ kvp, ...params ] = pref.trim().split(SEPARATOR.PARAMS)
+				const [ key, rawValue ] = kvp?.split(SEPARATOR.KVP) ?? []
+
+				if(key === undefined) { return {} }
+				const valueOrEmpty = isQuoted(rawValue) ? stripQuotes(rawValue) : rawValue
+				const value = (valueOrEmpty !== '') ? valueOrEmpty : undefined
+
+				const parameters = new Map(params
+					.map(param => {
+						const [ pKey, rawPValue ] = param.split(SEPARATOR.PARAM_KVP)
+						if(pKey === undefined) { return {} }
+						const trimmedRawPValue = rawPValue?.trim()
+						const pValueOrEmpty = isQuoted(trimmedRawPValue) ? stripQuotes(trimmedRawPValue) : trimmedRawPValue
+						const pValue = (pValueOrEmpty !== '') ? pValueOrEmpty : undefined
+						return { key: pKey.trim(), value: pValue }
+					})
+					.filter(item => item.key !== undefined)
+					.map(item => ([ item.key, item.value ]))
+				)
+
+				return { key, value, parameters }
+			})
+			.filter(item => item.key !== undefined)
+			.map(item => ([
+				item.key,
+				{ value: item.value, parameters: item.parameters }
+			]))
+		)
+
+		//
+		const asynchronous = preferences.get(DIRECTIVE_RESPOND_ASYNC) !== undefined
+		const representation = preferences.get(DIRECTIVE_REPRESENTATION)?.value
+		const handling = preferences.get(DIRECTIVE_HANDLING)?.value
+		const wait = Number.parseInt(preferences.get(DIRECTIVE_WAIT)?.value ?? '')
+		const timezone = preferences.get(DIRECTIVE_TIMEZONE)?.value
+
+		return {
+			asynchronous,
+			representation,
+			handling,
+			wait: Number.isFinite(wait) ? wait : undefined,
+			timezone,
+			preferences
+		}
+	}
+}
+
+export class AppliedPreferences {
+
+	/**
+	 * @param {Map<string, string|undefined>} preferences
+	 */
+	static #encode_Map(preferences) {
+		return [ ...preferences.entries()
+			.map(([ key, value ]) => {
+				// todo check if value should be quoted
+				if(value !== undefined) { return `${key}${SEPARATOR.KVP}${value}` }
+				return key
+			}) ]
+			.join(SEPARATOR.PREFERENCE)
+	}
+
+	/**
+	 * @param {Partial<AppliedRequestPreferences>|Map<string, string|undefined>|undefined} preferences
+	 */
+	static encode(preferences) {
+		if(preferences === undefined) { return undefined}
+		if(preferences instanceof Map) {
+			return AppliedPreferences.#encode_Map(preferences)
+		}
+
+		const applied = new Map()
+
+		for(const [ key, pref ] of preferences.preferences?.entries() ?? []) {
+			applied.set(key, pref?.value)
+		}
+
+		if(preferences.asynchronous === true) { applied.set(DIRECTIVE_RESPOND_ASYNC, undefined) }
+		if(preferences.asynchronous === false) { applied.delete(DIRECTIVE_RESPOND_ASYNC) }
+		if(preferences.representation !== undefined) { applied.set(DIRECTIVE_REPRESENTATION, preferences.representation) }
+		if(preferences.handling !== undefined) { applied.set(DIRECTIVE_HANDLING, preferences.handling) }
+		if(preferences.wait !== undefined) { applied.set(DIRECTIVE_WAIT, preferences.wait) }
+		if(preferences.timezone !== undefined) { applied.set(DIRECTIVE_TIMEZONE, preferences.timezone) }
+
+		return AppliedPreferences.#encode_Map(applied)
+	}
+}
+
+
+// console.log(AppliedPreferences.encode(undefined))
+// console.log(AppliedPreferences.encode({ }))
+// console.log(AppliedPreferences.encode({ wait: 10 }))
+// console.log(AppliedPreferences.encode({ asynchronous: undefined }))
+// console.log(AppliedPreferences.encode({ asynchronous: false }))
+// console.log(AppliedPreferences.encode({ asynchronous: true }))
+// console.log(AppliedPreferences.encode({ preferences: new Map([
+// 	[ 'respond-async', { value: undefined } ]
+// ]) }))
+// console.log(AppliedPreferences.encode({
+// 	asynchronous: false,
+// 	preferences: new Map([
+// 	[ 'respond-async', { value: 'fake' } ]
+// ]) }))
+// console.log(AppliedPreferences.encode({ asynchronous: true, wait: 100 }))
+// console.log(AppliedPreferences.encode({
+// 	representation: DIRECTIVE_REPRESENTATION_MINIMAL,
+// 	preferences: new Map([
+// 		['foo', { value: 'bar', parameters: new Map([ [ 'biz', 'bang' ] ]) } ],
+// 		[ 'fake', undefined ]
+// 	])
+// }))
+
+// console.log(Preferences.parse('handling=lenient, wait=100, respond-async'))
+// console.log(Preferences.parse(' foo; bar')?.preferences)
+// console.log(Preferences.parse(' foo; bar=""')?.preferences)
+// console.log(Preferences.parse(' foo=""; bar')?.preferences)
+// console.log(Preferences.parse(' foo =""; bar;biz; bang ')?.preferences)
+// console.log(Preferences.parse('return=minimal; foo="some parameter"')?.preferences)
+
+// console.log(Preferences.parse('timezone=America/Los_Angeles'))
+// console.log(Preferences.parse('return=headers-only'))
+// console.log(Preferences.parse('return=minimal'))
+// console.log(Preferences.parse('return=representation'))
+// console.log(Preferences.parse('respond-async, wait=10`'))
+// console.log(Preferences.parse('priority=5'))
+// console.log(Preferences.parse('foo; bar'))
+// console.log(Preferences.parse('foo; bar=""'))
+// console.log(Preferences.parse('foo=""; bar'))
+// console.log(Preferences.parse('handling=lenient, wait=100, respond-async'))
+// console.log(Preferences.parse('return=minimal; foo="some parameter"'))

package/src/range.js

@@ -0,0 +1,154 @@
+import { RANGE_UNITS_BYTES } from "./response/defs.js"
+
+export const RANGE_EQUAL = '='
+export const RANGE_SEPARATOR = '-'
+export const RANGE_LIST_SEPARATOR = ','
+
+/** @type {''} */
+export const RANGE_EMPTY = ''
+
+/**
+ * @typedef {Object} RangeValueFixed
+ * @property {number} start
+ * @property {number} end
+ */
+
+/**
+ * @typedef {Object} RangeValueOpenEnded
+ * @property {number} start
+ * @property {''} end
+ */
+
+/**
+ * @typedef {Object} RangeValueFromEnd
+ * @property {''} start
+ * @property {number} end
+ */
+
+/** @typedef {RangeValueFixed | RangeValueOpenEnded | RangeValueFromEnd} RangeValue */
+
+/** @typedef {RangeValueFixed} NormalizedRangeValue */
+
+/**
+ * @template RV
+ * @typedef {Object} RangeDirective
+ * @property {'bytes'|'none'|undefined} units
+ * @property {Array<RV>} ranges
+ */
+
+/**
+ * @typedef {Object} RangeDirectiveInfo
+ * @property {boolean} exceeds
+ * @property {boolean} overlap
+ */
+
+
+export class Range {
+	/**
+	 * @param {string|undefined} rangeHeader
+	 * @returns {RangeDirective<RangeValue>|undefined}
+	 */
+	static parse(rangeHeader) {
+		if(rangeHeader === undefined) { return undefined }
+		if(!rangeHeader.startsWith(RANGE_UNITS_BYTES)) { return undefined }
+		if(!(rangeHeader.substring(RANGE_UNITS_BYTES.length, RANGE_UNITS_BYTES.length + 1) === RANGE_EQUAL)) { return undefined }
+		const rangeStr = rangeHeader.substring(RANGE_UNITS_BYTES.length + RANGE_EQUAL.length).trim()
+		if(rangeStr === '') { return undefined }
+
+		const ranges = rangeStr.split(RANGE_LIST_SEPARATOR)
+			.map(range => range.trim())
+			.map(range => {
+				const [ startStr, endStr ] = range.split(RANGE_SEPARATOR)
+				if(startStr === undefined) { return undefined }
+				if(endStr === undefined) { return undefined }
+				if(startStr === RANGE_EMPTY && endStr === RANGE_EMPTY) { return undefined }
+
+				const start = Number.parseInt(startStr, 10)
+				const end = Number.parseInt(endStr, 10)
+
+				if(startStr === RANGE_EMPTY) {
+					if(!Number.isInteger(end)) { return undefined }
+					if(end === 0) { return undefined }
+					return { start: RANGE_EMPTY, end }
+				}
+
+				if(endStr === RANGE_EMPTY) {
+					if(!Number.isInteger(start)) { return undefined }
+					return { start, end: RANGE_EMPTY }
+				}
+
+				if(!(Number.isInteger(start) && Number.isInteger(end))) { return undefined }
+				return { start, end }
+			})
+			.filter(range => range !== undefined)
+
+		if(ranges.length === 0) { return undefined }
+
+		return {
+			units: RANGE_UNITS_BYTES,
+			ranges
+		}
+	}
+
+	/**
+	 * @param {RangeDirective<RangeValue>|undefined} directive
+	 * @param {number} contentLength
+	 * @returns {RangeDirectiveInfo & RangeDirective<NormalizedRangeValue>|undefined}
+	 */
+	static normalize(directive, contentLength) {
+		if(directive === undefined) { return undefined }
+
+		/** @type {Array<NormalizedRangeValue>} */
+		const normalizedRanges = directive.ranges.map(({ start, end }) => {
+			if(end === RANGE_EMPTY) { return { start, end: contentLength - 1 } }
+			if(start === RANGE_EMPTY) { return { start: contentLength - end, end: contentLength - 1 } }
+			return { start, end }
+		})
+
+		const exceeds = normalizedRanges.reduce((acc, value) => (acc || (value.start >= contentLength) || (value.end >= contentLength)), false)
+
+		const { overlap } = normalizedRanges
+			.toSorted((a, b) => a.start - b.start)
+			.reduce((acc, item) => ({
+					overlap: acc.overlap || acc.end > item.start,
+					end: item.end
+				}), { overlap: false, end: 0 })
+
+		return {
+			units: directive.units,
+			overlap,
+			exceeds,
+			ranges: normalizedRanges
+		}
+	}
+}
+
+// console.log(Range.parse(''))
+// console.log(Range.parse('='))
+// console.log(Range.parse('foo'))
+// console.log(Range.parse('bytes'))
+// console.log(Range.parse('bytes='))
+// console.log(Range.parse('bytes=-'))
+// console.log(Range.parse('bytes=foo'))
+// console.log(Range.parse('bytes=0-foo'))
+// console.log(Range.parse('bytes=0-0xff'))
+// console.log()
+// console.log(Range.parse('bytes=1024-'))
+// console.log(Range.parse('bytes=-1024'))
+// console.log(Range.parse('bytes=0-1024'))
+// console.log()
+// console.log(Range.parse('bytes=0-0,-1'))
+// console.log(Range.parse('bytes=0-1024, -1024'))
+// console.log(Range.parse('bytes= 0-999, 4500-5499, -1000'))
+// console.log(Range.parse('bytes=500-600,601-999'))
+
+// console.log('------')
+// console.log(Range.normalize(Range.parse('bytes=1024-'), 5000))
+// console.log(Range.normalize(Range.parse('bytes=-1024'), 5000))
+// console.log(Range.normalize(Range.parse('bytes=0-1024'), 5000))
+// console.log(Range.normalize(Range.parse('bytes=0-0,-1'), 10000)) // 0 and 9999
+// console.log(Range.normalize(Range.parse('bytes=0-1024, -1024'), 5000))
+// console.log(Range.normalize(Range.parse('bytes= 0-999, 4500-5499, -1000'), 5000))
+// console.log(Range.normalize(Range.parse('bytes=500-600,601-999'), 5000))
+
+// console.log(Range.normalize(Range.parse('bytes=-500'), 10000)) // 9500-9999

package/src/response/accepted.js

@@ -1,4 +1,5 @@
 import http2 from 'node:http2'
+
 import { send } from './send-util.js'
 
 /** @import { ServerHttp2Stream } from 'node:http2' */