2023-01-02 16:00:42 -05:00
|
|
|
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
|
2021-04-18 19:00:13 -04:00
|
|
|
|
|
|
|
// @ts-check
|
|
|
|
/// <reference path="../webidl/internal.d.ts" />
|
|
|
|
/// <reference path="../web/internal.d.ts" />
|
2021-06-10 09:26:10 -04:00
|
|
|
/// <reference path="../web/lib.deno_web.d.ts" />
|
2021-04-18 19:00:13 -04:00
|
|
|
/// <reference path="./internal.d.ts" />
|
2021-06-14 07:51:02 -04:00
|
|
|
/// <reference path="../web/06_streams_types.d.ts" />
|
2021-04-18 19:00:13 -04:00
|
|
|
/// <reference path="./lib.deno_fetch.d.ts" />
|
|
|
|
/// <reference lib="esnext" />
|
2020-07-19 13:49:44 -04:00
|
|
|
|
2023-03-08 06:44:54 -05:00
|
|
|
import * as webidl from "ext:deno_webidl/00_webidl.js";
|
2023-02-07 14:22:46 -05:00
|
|
|
import {
|
|
|
|
byteLowerCase,
|
|
|
|
collectHttpQuotedString,
|
|
|
|
collectSequenceOfCodepoints,
|
|
|
|
HTTP_TAB_OR_SPACE_PREFIX_RE,
|
|
|
|
HTTP_TAB_OR_SPACE_SUFFIX_RE,
|
|
|
|
HTTP_TOKEN_CODE_POINT_RE,
|
|
|
|
httpTrim,
|
2023-03-08 06:44:54 -05:00
|
|
|
} from "ext:deno_web/00_infra.js";
|
2023-02-07 14:22:46 -05:00
|
|
|
const primordials = globalThis.__bootstrap.primordials;
|
|
|
|
const {
|
|
|
|
ArrayIsArray,
|
|
|
|
ArrayPrototypeMap,
|
|
|
|
ArrayPrototypePush,
|
|
|
|
ArrayPrototypeSort,
|
|
|
|
ArrayPrototypeJoin,
|
|
|
|
ArrayPrototypeSplice,
|
|
|
|
ArrayPrototypeFilter,
|
|
|
|
ObjectEntries,
|
2023-05-02 06:15:45 -04:00
|
|
|
ObjectHasOwn,
|
2023-06-05 04:52:40 -04:00
|
|
|
RegExpPrototypeExec,
|
2023-02-07 14:22:46 -05:00
|
|
|
SafeArrayIterator,
|
2023-06-13 15:13:34 -04:00
|
|
|
SafeMap,
|
|
|
|
MapPrototypeGet,
|
|
|
|
MapPrototypeHas,
|
|
|
|
MapPrototypeSet,
|
|
|
|
MapPrototypeClear,
|
2023-02-07 14:22:46 -05:00
|
|
|
Symbol,
|
|
|
|
SymbolFor,
|
|
|
|
SymbolIterator,
|
|
|
|
StringPrototypeReplaceAll,
|
2023-06-13 15:13:34 -04:00
|
|
|
StringPrototypeCharCodeAt,
|
2023-02-07 14:22:46 -05:00
|
|
|
TypeError,
|
|
|
|
} = primordials;
|
|
|
|
|
|
|
|
const _headerList = Symbol("header list");
|
|
|
|
const _iterableHeaders = Symbol("iterable headers");
|
|
|
|
const _guard = Symbol("guard");
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @typedef Header
|
|
|
|
* @type {[string, string]}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @typedef HeaderList
|
|
|
|
* @type {Header[]}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param {string} potentialValue
|
|
|
|
* @returns {string}
|
|
|
|
*/
|
|
|
|
function normalizeHeaderValue(potentialValue) {
|
|
|
|
return httpTrim(potentialValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param {Headers} headers
|
|
|
|
* @param {HeadersInit} object
|
|
|
|
*/
|
|
|
|
function fillHeaders(headers, object) {
|
|
|
|
if (ArrayIsArray(object)) {
|
|
|
|
for (let i = 0; i < object.length; ++i) {
|
|
|
|
const header = object[i];
|
|
|
|
if (header.length !== 2) {
|
|
|
|
throw new TypeError(
|
|
|
|
`Invalid header. Length must be 2, but is ${header.length}`,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
appendHeader(headers, header[0], header[1]);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (const key in object) {
|
2023-05-02 06:15:45 -04:00
|
|
|
if (!ObjectHasOwn(object, key)) {
|
2023-02-07 14:22:46 -05:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
appendHeader(headers, key, object[key]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-06-13 15:13:34 -04:00
|
|
|
function checkForInvalidValueChars(value) {
|
|
|
|
for (let i = 0; i < value.length; i++) {
|
|
|
|
const c = StringPrototypeCharCodeAt(value, i);
|
|
|
|
|
|
|
|
if (c === 0x0a || c === 0x0d || c === 0x00) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
const HEADER_NAME_CACHE = new SafeMap();
|
2023-06-15 12:27:21 -04:00
|
|
|
const HEADER_NAME_CACHE_SIZE_BOUNDARY = 4096;
|
2023-06-13 15:13:34 -04:00
|
|
|
function checkHeaderNameForHttpTokenCodePoint(name) {
|
|
|
|
if (MapPrototypeHas(HEADER_NAME_CACHE, name)) {
|
|
|
|
return MapPrototypeGet(HEADER_NAME_CACHE, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
const valid = RegExpPrototypeExec(HTTP_TOKEN_CODE_POINT_RE, name) !== null;
|
|
|
|
|
2023-06-15 12:27:21 -04:00
|
|
|
if (HEADER_NAME_CACHE.size > HEADER_NAME_CACHE_SIZE_BOUNDARY) {
|
2023-06-13 15:13:34 -04:00
|
|
|
MapPrototypeClear(HEADER_NAME_CACHE);
|
|
|
|
}
|
|
|
|
MapPrototypeSet(HEADER_NAME_CACHE, name, valid);
|
|
|
|
|
|
|
|
return valid;
|
|
|
|
}
|
2023-02-07 14:22:46 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
* https://fetch.spec.whatwg.org/#concept-headers-append
|
|
|
|
* @param {Headers} headers
|
|
|
|
* @param {string} name
|
|
|
|
* @param {string} value
|
|
|
|
*/
|
|
|
|
function appendHeader(headers, name, value) {
|
|
|
|
// 1.
|
|
|
|
value = normalizeHeaderValue(value);
|
|
|
|
|
|
|
|
// 2.
|
2023-06-13 15:13:34 -04:00
|
|
|
if (!checkHeaderNameForHttpTokenCodePoint(name)) {
|
2023-02-07 14:22:46 -05:00
|
|
|
throw new TypeError("Header name is not valid.");
|
|
|
|
}
|
2023-06-13 15:13:34 -04:00
|
|
|
if (!checkForInvalidValueChars(value)) {
|
2023-02-07 14:22:46 -05:00
|
|
|
throw new TypeError("Header value is not valid.");
|
|
|
|
}
|
2020-07-19 13:49:44 -04:00
|
|
|
|
2023-02-07 14:22:46 -05:00
|
|
|
// 3.
|
|
|
|
if (headers[_guard] == "immutable") {
|
|
|
|
throw new TypeError("Headers are immutable.");
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
|
|
|
|
2023-02-07 14:22:46 -05:00
|
|
|
// 7.
|
|
|
|
const list = headers[_headerList];
|
|
|
|
const lowercaseName = byteLowerCase(name);
|
|
|
|
for (let i = 0; i < list.length; i++) {
|
|
|
|
if (byteLowerCase(list[i][0]) === lowercaseName) {
|
|
|
|
name = list[i][0];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ArrayPrototypePush(list, [name, value]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* https://fetch.spec.whatwg.org/#concept-header-list-get
|
|
|
|
* @param {HeaderList} list
|
|
|
|
* @param {string} name
|
|
|
|
*/
|
|
|
|
function getHeader(list, name) {
|
|
|
|
const lowercaseName = byteLowerCase(name);
|
|
|
|
const entries = ArrayPrototypeMap(
|
|
|
|
ArrayPrototypeFilter(
|
|
|
|
list,
|
|
|
|
(entry) => byteLowerCase(entry[0]) === lowercaseName,
|
|
|
|
),
|
|
|
|
(entry) => entry[1],
|
|
|
|
);
|
|
|
|
if (entries.length === 0) {
|
|
|
|
return null;
|
|
|
|
} else {
|
|
|
|
return ArrayPrototypeJoin(entries, "\x2C\x20");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* https://fetch.spec.whatwg.org/#concept-header-list-get-decode-split
|
|
|
|
* @param {HeaderList} list
|
|
|
|
* @param {string} name
|
|
|
|
* @returns {string[] | null}
|
|
|
|
*/
|
|
|
|
function getDecodeSplitHeader(list, name) {
|
|
|
|
const initialValue = getHeader(list, name);
|
|
|
|
if (initialValue === null) return null;
|
|
|
|
const input = initialValue;
|
|
|
|
let position = 0;
|
|
|
|
const values = [];
|
|
|
|
let value = "";
|
|
|
|
while (position < initialValue.length) {
|
|
|
|
// 7.1. collect up to " or ,
|
|
|
|
const res = collectSequenceOfCodepoints(
|
|
|
|
initialValue,
|
|
|
|
position,
|
|
|
|
(c) => c !== "\u0022" && c !== "\u002C",
|
|
|
|
);
|
|
|
|
value += res.result;
|
|
|
|
position = res.position;
|
|
|
|
|
|
|
|
if (position < initialValue.length) {
|
|
|
|
if (input[position] === "\u0022") {
|
|
|
|
const res = collectHttpQuotedString(input, position, false);
|
|
|
|
value += res.result;
|
|
|
|
position = res.position;
|
|
|
|
if (position < initialValue.length) {
|
|
|
|
continue;
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
2023-02-07 14:22:46 -05:00
|
|
|
} else {
|
|
|
|
if (input[position] !== "\u002C") throw new TypeError("Unreachable");
|
|
|
|
position += 1;
|
2021-04-18 19:00:13 -04:00
|
|
|
}
|
2023-02-07 14:22:46 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
value = StringPrototypeReplaceAll(value, HTTP_TAB_OR_SPACE_PREFIX_RE, "");
|
|
|
|
value = StringPrototypeReplaceAll(value, HTTP_TAB_OR_SPACE_SUFFIX_RE, "");
|
|
|
|
|
|
|
|
ArrayPrototypePush(values, value);
|
|
|
|
value = "";
|
|
|
|
}
|
|
|
|
return values;
|
|
|
|
}
|
|
|
|
|
|
|
|
class Headers {
|
|
|
|
/** @type {HeaderList} */
|
|
|
|
[_headerList] = [];
|
|
|
|
/** @type {"immutable" | "request" | "request-no-cors" | "response" | "none"} */
|
|
|
|
[_guard];
|
|
|
|
|
|
|
|
get [_iterableHeaders]() {
|
|
|
|
const list = this[_headerList];
|
|
|
|
|
|
|
|
// The order of steps are not similar to the ones suggested by the
|
|
|
|
// spec but produce the same result.
|
|
|
|
const headers = {};
|
|
|
|
const cookies = [];
|
|
|
|
for (let i = 0; i < list.length; ++i) {
|
|
|
|
const entry = list[i];
|
|
|
|
const name = byteLowerCase(entry[0]);
|
|
|
|
const value = entry[1];
|
|
|
|
if (value === null) throw new TypeError("Unreachable");
|
|
|
|
// The following if statement is not spec compliant.
|
|
|
|
// `set-cookie` is the only header that can not be concatenated,
|
|
|
|
// so must be given to the user as multiple headers.
|
|
|
|
// The else block of the if statement is spec compliant again.
|
|
|
|
if (name === "set-cookie") {
|
|
|
|
ArrayPrototypePush(cookies, [name, value]);
|
|
|
|
} else {
|
|
|
|
// The following code has the same behaviour as getHeader()
|
|
|
|
// at the end of loop. But it avoids looping through the entire
|
|
|
|
// list to combine multiple values with same header name. It
|
|
|
|
// instead gradually combines them as they are found.
|
|
|
|
let header = headers[name];
|
|
|
|
if (header && header.length > 0) {
|
|
|
|
header += "\x2C\x20" + value;
|
|
|
|
} else {
|
|
|
|
header = value;
|
2021-10-01 06:17:16 -04:00
|
|
|
}
|
2023-02-07 14:22:46 -05:00
|
|
|
headers[name] = header;
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
|
|
|
}
|
2023-02-07 14:22:46 -05:00
|
|
|
|
|
|
|
return ArrayPrototypeSort(
|
|
|
|
[
|
|
|
|
...new SafeArrayIterator(ObjectEntries(headers)),
|
|
|
|
...new SafeArrayIterator(cookies),
|
|
|
|
],
|
|
|
|
(a, b) => {
|
|
|
|
const akey = a[0];
|
|
|
|
const bkey = b[0];
|
|
|
|
if (akey > bkey) return 1;
|
|
|
|
if (akey < bkey) return -1;
|
|
|
|
return 0;
|
|
|
|
},
|
|
|
|
);
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
|
|
|
|
2023-02-07 14:22:46 -05:00
|
|
|
/** @param {HeadersInit} [init] */
|
|
|
|
constructor(init = undefined) {
|
|
|
|
const prefix = "Failed to construct 'Headers'";
|
|
|
|
if (init !== undefined) {
|
2023-05-01 06:47:13 -04:00
|
|
|
init = webidl.converters["HeadersInit"](init, prefix, "Argument 1");
|
2023-02-07 14:22:46 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
this[webidl.brand] = webidl.brand;
|
|
|
|
this[_guard] = "none";
|
|
|
|
if (init !== undefined) {
|
|
|
|
fillHeaders(this, init);
|
|
|
|
}
|
|
|
|
}
|
2021-09-26 14:19:02 -04:00
|
|
|
|
2021-04-18 19:00:13 -04:00
|
|
|
/**
|
2021-04-28 10:08:51 -04:00
|
|
|
* @param {string} name
|
|
|
|
* @param {string} value
|
2021-04-18 19:00:13 -04:00
|
|
|
*/
|
2023-02-07 14:22:46 -05:00
|
|
|
append(name, value) {
|
|
|
|
webidl.assertBranded(this, HeadersPrototype);
|
|
|
|
const prefix = "Failed to execute 'append' on 'Headers'";
|
2023-04-12 15:58:57 -04:00
|
|
|
webidl.requiredArguments(arguments.length, 2, prefix);
|
2023-05-01 06:47:13 -04:00
|
|
|
name = webidl.converters["ByteString"](name, prefix, "Argument 1");
|
|
|
|
value = webidl.converters["ByteString"](value, prefix, "Argument 2");
|
2023-02-07 14:22:46 -05:00
|
|
|
appendHeader(this, name, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param {string} name
|
|
|
|
*/
|
|
|
|
delete(name) {
|
|
|
|
const prefix = "Failed to execute 'delete' on 'Headers'";
|
2023-04-12 15:58:57 -04:00
|
|
|
webidl.requiredArguments(arguments.length, 1, prefix);
|
2023-05-01 06:47:13 -04:00
|
|
|
name = webidl.converters["ByteString"](name, prefix, "Argument 1");
|
2021-04-18 19:00:13 -04:00
|
|
|
|
2023-06-13 15:13:34 -04:00
|
|
|
if (!checkHeaderNameForHttpTokenCodePoint(name)) {
|
2021-04-18 19:00:13 -04:00
|
|
|
throw new TypeError("Header name is not valid.");
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
2023-02-07 14:22:46 -05:00
|
|
|
if (this[_guard] == "immutable") {
|
2021-04-18 19:00:13 -04:00
|
|
|
throw new TypeError("Headers are immutable.");
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
|
|
|
|
2023-02-07 14:22:46 -05:00
|
|
|
const list = this[_headerList];
|
2021-11-22 19:23:11 -05:00
|
|
|
const lowercaseName = byteLowerCase(name);
|
|
|
|
for (let i = 0; i < list.length; i++) {
|
|
|
|
if (byteLowerCase(list[i][0]) === lowercaseName) {
|
2023-02-07 14:22:46 -05:00
|
|
|
ArrayPrototypeSplice(list, i, 1);
|
|
|
|
i--;
|
2021-11-22 19:23:11 -05:00
|
|
|
}
|
|
|
|
}
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
|
|
|
|
2021-04-18 19:00:13 -04:00
|
|
|
/**
|
|
|
|
* @param {string} name
|
|
|
|
*/
|
2023-02-07 14:22:46 -05:00
|
|
|
get(name) {
|
|
|
|
const prefix = "Failed to execute 'get' on 'Headers'";
|
2023-04-12 15:58:57 -04:00
|
|
|
webidl.requiredArguments(arguments.length, 1, prefix);
|
2023-05-01 06:47:13 -04:00
|
|
|
name = webidl.converters["ByteString"](name, prefix, "Argument 1");
|
2023-02-07 14:22:46 -05:00
|
|
|
|
2023-06-13 15:13:34 -04:00
|
|
|
if (!checkHeaderNameForHttpTokenCodePoint(name)) {
|
2023-02-07 14:22:46 -05:00
|
|
|
throw new TypeError("Header name is not valid.");
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
2023-02-07 14:22:46 -05:00
|
|
|
|
|
|
|
const list = this[_headerList];
|
|
|
|
return getHeader(list, name);
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
|
|
|
|
2021-04-20 08:47:22 -04:00
|
|
|
/**
|
|
|
|
* @param {string} name
|
|
|
|
*/
|
2023-02-07 14:22:46 -05:00
|
|
|
has(name) {
|
|
|
|
const prefix = "Failed to execute 'has' on 'Headers'";
|
2023-04-12 15:58:57 -04:00
|
|
|
webidl.requiredArguments(arguments.length, 1, prefix);
|
2023-05-01 06:47:13 -04:00
|
|
|
name = webidl.converters["ByteString"](name, prefix, "Argument 1");
|
2021-04-20 08:47:22 -04:00
|
|
|
|
2023-06-13 15:13:34 -04:00
|
|
|
if (!checkHeaderNameForHttpTokenCodePoint(name)) {
|
2023-02-07 14:22:46 -05:00
|
|
|
throw new TypeError("Header name is not valid.");
|
2021-04-20 08:47:22 -04:00
|
|
|
}
|
|
|
|
|
2023-02-07 14:22:46 -05:00
|
|
|
const list = this[_headerList];
|
|
|
|
const lowercaseName = byteLowerCase(name);
|
|
|
|
for (let i = 0; i < list.length; i++) {
|
|
|
|
if (byteLowerCase(list[i][0]) === lowercaseName) {
|
|
|
|
return true;
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
|
|
|
}
|
2023-02-07 14:22:46 -05:00
|
|
|
return false;
|
|
|
|
}
|
2020-07-19 13:49:44 -04:00
|
|
|
|
2023-02-07 14:22:46 -05:00
|
|
|
/**
|
|
|
|
* @param {string} name
|
|
|
|
* @param {string} value
|
|
|
|
*/
|
|
|
|
set(name, value) {
|
|
|
|
webidl.assertBranded(this, HeadersPrototype);
|
|
|
|
const prefix = "Failed to execute 'set' on 'Headers'";
|
2023-04-12 15:58:57 -04:00
|
|
|
webidl.requiredArguments(arguments.length, 2, prefix);
|
2023-05-01 06:47:13 -04:00
|
|
|
name = webidl.converters["ByteString"](name, prefix, "Argument 1");
|
|
|
|
value = webidl.converters["ByteString"](value, prefix, "Argument 2");
|
2021-04-18 19:00:13 -04:00
|
|
|
|
2023-02-07 14:22:46 -05:00
|
|
|
value = normalizeHeaderValue(value);
|
2020-07-19 13:49:44 -04:00
|
|
|
|
2023-02-07 14:22:46 -05:00
|
|
|
// 2.
|
2023-06-13 15:13:34 -04:00
|
|
|
if (!checkHeaderNameForHttpTokenCodePoint(name)) {
|
2023-02-07 14:22:46 -05:00
|
|
|
throw new TypeError("Header name is not valid.");
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
2023-06-13 15:13:34 -04:00
|
|
|
if (!checkForInvalidValueChars(value)) {
|
2023-02-07 14:22:46 -05:00
|
|
|
throw new TypeError("Header value is not valid.");
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
|
|
|
|
2023-02-07 14:22:46 -05:00
|
|
|
if (this[_guard] == "immutable") {
|
|
|
|
throw new TypeError("Headers are immutable.");
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
|
|
|
|
2023-02-07 14:22:46 -05:00
|
|
|
const list = this[_headerList];
|
|
|
|
const lowercaseName = byteLowerCase(name);
|
|
|
|
let added = false;
|
|
|
|
for (let i = 0; i < list.length; i++) {
|
|
|
|
if (byteLowerCase(list[i][0]) === lowercaseName) {
|
|
|
|
if (!added) {
|
|
|
|
list[i][1] = value;
|
|
|
|
added = true;
|
|
|
|
} else {
|
|
|
|
ArrayPrototypeSplice(list, i, 1);
|
|
|
|
i--;
|
2021-04-18 19:00:13 -04:00
|
|
|
}
|
|
|
|
}
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
2023-02-07 14:22:46 -05:00
|
|
|
if (!added) {
|
|
|
|
ArrayPrototypePush(list, [name, value]);
|
2021-04-18 19:00:13 -04:00
|
|
|
}
|
2023-02-07 14:22:46 -05:00
|
|
|
}
|
2021-04-18 19:00:13 -04:00
|
|
|
|
2023-02-07 14:22:46 -05:00
|
|
|
[SymbolFor("Deno.privateCustomInspect")](inspect) {
|
|
|
|
const headers = {};
|
|
|
|
// deno-lint-ignore prefer-primordials
|
|
|
|
for (const header of this) {
|
|
|
|
headers[header[0]] = header[1];
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
2023-02-07 14:22:46 -05:00
|
|
|
return `Headers ${inspect(headers)}`;
|
2020-07-19 13:49:44 -04:00
|
|
|
}
|
2023-02-07 14:22:46 -05:00
|
|
|
}
|
2020-07-19 13:49:44 -04:00
|
|
|
|
2023-02-07 14:22:46 -05:00
|
|
|
webidl.mixinPairIterable("Headers", Headers, _iterableHeaders, 0, 1);
|
2021-04-18 19:00:13 -04:00
|
|
|
|
2023-02-07 14:22:46 -05:00
|
|
|
webidl.configurePrototype(Headers);
|
|
|
|
const HeadersPrototype = Headers.prototype;
|
2021-06-07 04:04:10 -04:00
|
|
|
|
2023-05-01 06:47:13 -04:00
|
|
|
webidl.converters["HeadersInit"] = (V, prefix, context, opts) => {
|
2023-02-07 14:22:46 -05:00
|
|
|
// Union for (sequence<sequence<ByteString>> or record<ByteString, ByteString>)
|
|
|
|
if (webidl.type(V) === "Object" && V !== null) {
|
|
|
|
if (V[SymbolIterator] !== undefined) {
|
2023-05-01 06:47:13 -04:00
|
|
|
return webidl.converters["sequence<sequence<ByteString>>"](
|
|
|
|
V,
|
|
|
|
prefix,
|
|
|
|
context,
|
|
|
|
opts,
|
|
|
|
);
|
2021-04-18 19:00:13 -04:00
|
|
|
}
|
2023-05-01 06:47:13 -04:00
|
|
|
return webidl.converters["record<ByteString, ByteString>"](
|
|
|
|
V,
|
|
|
|
prefix,
|
|
|
|
context,
|
|
|
|
opts,
|
|
|
|
);
|
2021-04-20 08:47:22 -04:00
|
|
|
}
|
2023-02-07 14:22:46 -05:00
|
|
|
throw webidl.makeException(
|
|
|
|
TypeError,
|
|
|
|
"The provided value is not of type '(sequence<sequence<ByteString>> or record<ByteString, ByteString>)'",
|
2023-05-01 06:47:13 -04:00
|
|
|
prefix,
|
|
|
|
context,
|
2023-02-07 14:22:46 -05:00
|
|
|
);
|
|
|
|
};
|
|
|
|
webidl.converters["Headers"] = webidl.createInterfaceConverter(
|
|
|
|
"Headers",
|
|
|
|
Headers.prototype,
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param {HeaderList} list
|
|
|
|
* @param {"immutable" | "request" | "request-no-cors" | "response" | "none"} guard
|
|
|
|
* @returns {Headers}
|
|
|
|
*/
|
|
|
|
function headersFromHeaderList(list, guard) {
|
|
|
|
const headers = webidl.createBranded(Headers);
|
|
|
|
headers[_headerList] = list;
|
|
|
|
headers[_guard] = guard;
|
|
|
|
return headers;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param {Headers} headers
|
|
|
|
* @returns {HeaderList}
|
|
|
|
*/
|
|
|
|
function headerListFromHeaders(headers) {
|
|
|
|
return headers[_headerList];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param {Headers} headers
|
|
|
|
* @returns {"immutable" | "request" | "request-no-cors" | "response" | "none"}
|
|
|
|
*/
|
|
|
|
function guardFromHeaders(headers) {
|
|
|
|
return headers[_guard];
|
|
|
|
}
|
|
|
|
|
|
|
|
export {
|
|
|
|
fillHeaders,
|
|
|
|
getDecodeSplitHeader,
|
|
|
|
getHeader,
|
|
|
|
guardFromHeaders,
|
|
|
|
headerListFromHeaders,
|
|
|
|
Headers,
|
|
|
|
headersFromHeaderList,
|
|
|
|
};
|