File Explorer

/proc/2/root/var/runtime/node_modules/@aws-sdk/node_modules/axios/lib/core

This explorer reads the filesystem of the server it runs on, so /workspace/user isn't present here. Browsing and the terminal still work against this server's own disk from /.

AxiosHeaders.js10.1 KB · 475 lines
'use strict'; import utils from '../utils.js';import parseHeaders from '../helpers/parseHeaders.js';import { sanitizeHeaderValue } from '../helpers/sanitizeHeaderValue.js'; const $internals = Symbol('internals'); function normalizeHeader(header) {  return header && String(header).trim().toLowerCase();} function normalizeValue(value) {  if (value === false || value == null) {    return value;  }   return utils.isArray(value) ? value.map(normalizeValue) : sanitizeHeaderValue(String(value));} function parseTokens(str) {  const tokens = Object.create(null);  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;  let match;   while ((match = tokensRE.exec(str))) {    tokens[match[1]] = match[2];  }   return tokens;} const parameterNameRE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/; function trimOWS(value) {  let start = 0;  let end = value.length;   while (start < end) {    const code = value.charCodeAt(start);     if (code !== 0x09 && code !== 0x20) {      break;    }     start += 1;  }   while (end > start) {    const code = value.charCodeAt(end - 1);     if (code !== 0x09 && code !== 0x20) {      break;    }     end -= 1;  }   return start === 0 && end === value.length ? value : value.slice(start, end);} function decodeQuotedString(value) {  const last = value.length - 1;   if (last < 1 || value.charCodeAt(0) !== 0x22 || value.charCodeAt(last) !== 0x22) {    return value;  }   let decoded = '';   for (let i = 1; i < last; i++) {    const code = value.charCodeAt(i);     if (code === 0x22) {      return value;    }     if (code === 0x5c) {      i += 1;       if (i >= last) {        return value;      }    }     decoded += value[i];  }   return decoded;} function parseParameters(value) {  const parameters = Object.create(null);  const str = String(value);  let start = 0;  let quoted = false;  let escaped = false;   function parseParameter(end) {    const part = trimOWS(str.slice(start, end));    const equals = part.indexOf('=');     if (equals < 1) {      return;    }     const name = trimOWS(part.slice(0, equals));     if (!parameterNameRE.test(name)) {      return;    }     const normalizedName = name.toLowerCase();     if (      normalizedName === '__proto__' ||      normalizedName === 'constructor' ||      normalizedName === 'prototype'    ) {      return;    }     const parameterValue = trimOWS(part.slice(equals + 1));    parameters[normalizedName] = decodeQuotedString(parameterValue);  }   for (let i = 0; i < str.length; i++) {    const code = str.charCodeAt(i);     if (quoted) {      if (escaped) {        escaped = false;      } else if (code === 0x5c) {        escaped = true;      } else if (code === 0x22) {        quoted = false;      }    } else if (code === 0x22) {      quoted = true;    } else if (code === 0x2c || code === 0x3b) {      parseParameter(i);      start = i + 1;    }  }   parseParameter(str.length);   return parameters;} const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim()); function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {  if (utils.isFunction(filter)) {    return filter.call(this, value, header);  }   if (isHeaderNameFilter) {    value = header;  }   if (!utils.isString(value)) return;   if (utils.isString(filter)) {    return value.indexOf(filter) !== -1;  }   if (utils.isRegExp(filter)) {    return filter.test(value);  }} function formatHeader(header) {  return header    .trim()    .toLowerCase()    .replace(/([a-z\d])(\w*)/g, (w, char, str) => {      return char.toUpperCase() + str;    });} function buildAccessors(obj, header) {  const accessorName = utils.toCamelCase(' ' + header);   ['get', 'set', 'has'].forEach((methodName) => {    Object.defineProperty(obj, methodName + accessorName, {      // Null-proto descriptor so a polluted Object.prototype.get cannot turn      // this data descriptor into an accessor descriptor on the way in.      __proto__: null,      value: function (arg1, arg2, arg3) {        return this[methodName].call(this, header, arg1, arg2, arg3);      },      configurable: true,    });  });} class AxiosHeaders {  constructor(headers) {    headers && this.set(headers);  }   set(header, valueOrRewrite, rewrite) {    const self = this;     function setHeader(_value, _header, _rewrite) {      const lHeader = normalizeHeader(_header);       if (!lHeader) {        return;      }       const key = utils.findKey(self, lHeader);       if (        !key ||        self[key] === undefined ||        _rewrite === true ||        (_rewrite === undefined && self[key] !== false)      ) {        self[key || _header] = normalizeValue(_value);      }    }     const setHeaders = (headers, _rewrite) =>      utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));     if (utils.isPlainObject(header) || header instanceof this.constructor) {      setHeaders(header, valueOrRewrite);    } else if (utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {      setHeaders(parseHeaders(header), valueOrRewrite);    } else if (utils.isObject(header) && utils.isSafeIterable(header)) {      let obj = Object.create(null),        dest,        key;      for (const entry of header) {        if (!utils.isArray(entry)) {          throw new TypeError('Object iterator must return a key-value pair');        }         key = entry[0];         if (utils.hasOwnProp(obj, key)) {          dest = obj[key];          obj[key] = utils.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]];        } else {          obj[key] = entry[1];        }      }       setHeaders(obj, valueOrRewrite);    } else {      header != null && setHeader(valueOrRewrite, header, rewrite);    }     return this;  }   get(header, parser) {    header = normalizeHeader(header);     if (header) {      const key = utils.findKey(this, header);       if (key) {        const value = this[key];         if (!parser) {          return value;        }         if (parser === true) {          return parseTokens(value);        }         if (utils.isFunction(parser)) {          return parser.call(this, value, key);        }         if (utils.isRegExp(parser)) {          return parser.exec(value);        }         throw new TypeError('parser must be boolean|regexp|function');      }    }  }   has(header, matcher) {    header = normalizeHeader(header);     if (header) {      const key = utils.findKey(this, header);       return !!(        key &&        this[key] !== undefined &&        (!matcher || matchHeaderValue(this, this[key], key, matcher))      );    }     return false;  }   delete(header, matcher) {    const self = this;    let deleted = false;     function deleteHeader(_header) {      _header = normalizeHeader(_header);       if (_header) {        const key = utils.findKey(self, _header);         if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {          delete self[key];           deleted = true;        }      }    }     if (utils.isArray(header)) {      header.forEach(deleteHeader);    } else {      deleteHeader(header);    }     return deleted;  }   clear(matcher) {    const keys = Object.keys(this);    let i = keys.length;    let deleted = false;     while (i--) {      const key = keys[i];      if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {        delete this[key];        deleted = true;      }    }     return deleted;  }   normalize(format) {    const self = this;    const headers = {};     utils.forEach(this, (value, header) => {      const key = utils.findKey(headers, header);       if (key) {        self[key] = normalizeValue(value);        delete self[header];        return;      }       const normalized = format ? formatHeader(header) : String(header).trim();       if (normalized !== header) {        delete self[header];      }       self[normalized] = normalizeValue(value);       headers[normalized] = true;    });     return this;  }   concat(...targets) {    return this.constructor.concat(this, ...targets);  }   toJSON(asStrings) {    const obj = Object.create(null);     utils.forEach(this, (value, header) => {      value != null &&        value !== false &&        (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);    });     return obj;  }   [Symbol.iterator]() {    return Object.entries(this.toJSON())[Symbol.iterator]();  }   toString() {    return Object.entries(this.toJSON())      .map(([header, value]) => header + ': ' + value)      .join('\n');  }   getSetCookie() {    const value = this.get('set-cookie');    return utils.isArray(value) ? value : value == null || value === false ? [] : [value];  }   get [Symbol.toStringTag]() {    return 'AxiosHeaders';  }   static from(thing) {    return thing instanceof this ? thing : new this(thing);  }   static parseParameters(value) {    return parseParameters(value);  }   static concat(first, ...targets) {    const computed = new this(first);     targets.forEach((target) => computed.set(target));     return computed;  }   static accessor(header) {    const internals =      (this[$internals] =      this[$internals] =        {          accessors: {},        });     const accessors = internals.accessors;    const prototype = this.prototype;     function defineAccessor(_header) {      const lHeader = normalizeHeader(_header);       if (!accessors[lHeader]) {        buildAccessors(prototype, _header);        accessors[lHeader] = true;      }    }     utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);     return this;  }} AxiosHeaders.accessor([  'Content-Type',  'Content-Length',  'Accept',  'Accept-Encoding',  'User-Agent',  'Authorization',]); // reserved names hotfixutils.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {  let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`  return {    get: () => value,    set(headerValue) {      this[mapped] = headerValue;    },  };}); utils.freezeMethods(AxiosHeaders); export default AxiosHeaders;