BLUE

Navigation

Breadcrumbs

/ / usr / share / nodejs / normalize-url

Create

Upload

Tip: You can also drag & drop files anywhere on this page to upload.

Edit File Size: 15.50 KB

//usr/share/nodejs/normalize-url/index.cjs

Text Base64

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = normalizeUrl;

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
var DATA_URL_DEFAULT_MIME_TYPE = 'text/plain';
var DATA_URL_DEFAULT_CHARSET = 'us-ascii';

var testParameter = function testParameter(name, filters) {
  return filters.some(function (filter) {
    return filter instanceof RegExp ? filter.test(name) : filter === name;
  });
};

var normalizeDataURL = function normalizeDataURL(urlString, _ref) {
  var stripHash = _ref.stripHash;

var match = /*#__PURE__*/_wrapRegExp(/^data:((?:(?!,)[\s\S])*?),((?:(?!#)[\s\S])*?)(?:#(.*))?$/, {
    type: 1,
    data: 2,
    hash: 3
  }).exec(urlString);

if (!match) {
    throw new Error("Invalid URL: ".concat(urlString));
  }

var _match$groups = match.groups,
      type = _match$groups.type,
      data = _match$groups.data,
      hash = _match$groups.hash;
  var mediaType = type.split(';');
  hash = stripHash ? '' : hash;
  var isBase64 = false;

if (mediaType[mediaType.length - 1] === 'base64') {
    mediaType.pop();
    isBase64 = true;
  } // Lowercase MIME type

var mimeType = (mediaType.shift() || '').toLowerCase();
  var attributes = mediaType.map(function (attribute) {
    var _attribute$split$map = attribute.split('=').map(function (string) {
      return string.trim();
    }),
        _attribute$split$map2 = _slicedToArray(_attribute$split$map, 2),
        key = _attribute$split$map2[0],
        _attribute$split$map3 = _attribute$split$map2[1],
        value = _attribute$split$map3 === void 0 ? '' : _attribute$split$map3; // Lowercase `charset`

if (key === 'charset') {
      value = value.toLowerCase();

if (value === DATA_URL_DEFAULT_CHARSET) {
        return '';
      }
    }

return "".concat(key).concat(value ? "=".concat(value) : '');
  }).filter(Boolean);

var normalizedMediaType = _toConsumableArray(attributes);

if (isBase64) {
    normalizedMediaType.push('base64');
  }

if (normalizedMediaType.length > 0 || mimeType && mimeType !== DATA_URL_DEFAULT_MIME_TYPE) {
    normalizedMediaType.unshift(mimeType);
  }

return "data:".concat(normalizedMediaType.join(';'), ",").concat(isBase64 ? data.trim() : data).concat(hash ? "#".concat(hash) : '');
};

function normalizeUrl(urlString, options) {
  options = _objectSpread({
    defaultProtocol: 'http:',
    normalizeProtocol: true,
    forceHttp: false,
    forceHttps: false,
    stripAuthentication: true,
    stripHash: false,
    stripTextFragment: true,
    stripWWW: true,
    removeQueryParameters: [/^utm_\w+/i],
    removeTrailingSlash: true,
    removeSingleSlash: true,
    removeDirectoryIndex: false,
    sortQueryParameters: true
  }, options);
  urlString = urlString.trim(); // Data URL

if (/^data:/i.test(urlString)) {
    return normalizeDataURL(urlString, options);
  }

if (/^view-source:/i.test(urlString)) {
    throw new Error('`view-source:` is not supported as it is a non-standard protocol');
  }

var hasRelativeProtocol = urlString.startsWith('//');
  var isRelativeUrl = !hasRelativeProtocol && /^\.*\//.test(urlString); // Prepend protocol

if (!isRelativeUrl) {
    urlString = urlString.replace(/^(?!(?:\w+:)?\/\/)|^\/\//, options.defaultProtocol);
  }

var urlObject = new URL(urlString);

if (options.forceHttp && options.forceHttps) {
    throw new Error('The `forceHttp` and `forceHttps` options cannot be used together');
  }

if (options.forceHttp && urlObject.protocol === 'https:') {
    urlObject.protocol = 'http:';
  }

if (options.forceHttps && urlObject.protocol === 'http:') {
    urlObject.protocol = 'https:';
  } // Remove auth

if (options.stripAuthentication) {
    urlObject.username = '';
    urlObject.password = '';
  } // Remove hash

if (options.stripHash) {
    urlObject.hash = '';
  } else if (options.stripTextFragment) {
    urlObject.hash = urlObject.hash.replace(/#?:~:text.*?$/i, '');
  } // Remove duplicate slashes if not preceded by a protocol
  // NOTE: This could be implemented using a single negative lookbehind
  // regex, but we avoid that to maintain compatibility with older js engines
  // which do not have support for that feature.

if (urlObject.pathname) {
    // TODO: Replace everything below with `urlObject.pathname = urlObject.pathname.replace(/(?<!\b[a-z][a-z\d+\-.]{1,50}:)\/{2,}/g, '/');` when Safari supports negative lookbehind.
    // Split the string by occurrences of this protocol regex, and perform
    // duplicate-slash replacement on the strings between those occurrences
    // (if any).
    var protocolRegex = /\b[a-z][a-z\d+\-.]{1,50}:\/\//g;
    var lastIndex = 0;
    var result = '';

for (;;) {
      var match = protocolRegex.exec(urlObject.pathname);

if (!match) {
        break;
      }

var protocol = match[0];
      var protocolAtIndex = match.index;
      var intermediate = urlObject.pathname.slice(lastIndex, protocolAtIndex);
      result += intermediate.replace(/\/{2,}/g, '/');
      result += protocol;
      lastIndex = protocolAtIndex + protocol.length;
    }

var remnant = urlObject.pathname.slice(lastIndex, urlObject.pathname.length);
    result += remnant.replace(/\/{2,}/g, '/');
    urlObject.pathname = result;
  } // Decode URI octets

if (urlObject.pathname) {
    try {
      urlObject.pathname = decodeURI(urlObject.pathname);
    } catch (_unused) {}
  } // Remove directory index

if (options.removeDirectoryIndex === true) {
    options.removeDirectoryIndex = [/^index\.[a-z]+$/];
  }

if (Array.isArray(options.removeDirectoryIndex) && options.removeDirectoryIndex.length > 0) {
    var pathComponents = urlObject.pathname.split('/');
    var lastComponent = pathComponents[pathComponents.length - 1];

if (testParameter(lastComponent, options.removeDirectoryIndex)) {
      pathComponents = pathComponents.slice(0, -1);
      urlObject.pathname = pathComponents.slice(1).join('/') + '/';
    }
  }

if (urlObject.hostname) {
    // Remove trailing dot
    urlObject.hostname = urlObject.hostname.replace(/\.$/, ''); // Remove `www.`

if (options.stripWWW && /^www\.(?!www\.)[a-z\-\d]{1,63}\.[a-z.\-\d]{2,63}$/.test(urlObject.hostname)) {
      // Each label should be max 63 at length (min: 1).
      // Source: https://en.wikipedia.org/wiki/Hostname#Restrictions_on_valid_host_names
      // Each TLD should be up to 63 characters long (min: 2).
      // It is technically possible to have a single character TLD, but none currently exist.
      urlObject.hostname = urlObject.hostname.replace(/^www\./, '');
    }
  } // Remove query unwanted parameters

if (Array.isArray(options.removeQueryParameters)) {
    for (var _i2 = 0, _arr2 = _toConsumableArray(urlObject.searchParams.keys()); _i2 < _arr2.length; _i2++) {
      var key = _arr2[_i2];

if (testParameter(key, options.removeQueryParameters)) {
        urlObject.searchParams["delete"](key);
      }
    }
  }

if (options.removeQueryParameters === true) {
    urlObject.search = '';
  } // Sort query parameters

if (options.sortQueryParameters) {
    urlObject.searchParams.sort();
  }

if (options.removeTrailingSlash) {
    urlObject.pathname = urlObject.pathname.replace(/\/$/, '');
  }

var oldUrlString = urlString; // Take advantage of many of the Node `url` normalizations

urlString = urlObject.toString();

if (!options.removeSingleSlash && urlObject.pathname === '/' && !oldUrlString.endsWith('/') && urlObject.hash === '') {
    urlString = urlString.replace(/\/$/, '');
  } // Remove ending `/` unless removeSingleSlash is false

if ((options.removeTrailingSlash || urlObject.pathname === '/') && urlObject.hash === '' && options.removeSingleSlash) {
    urlString = urlString.replace(/\/$/, '');
  } // Restore relative protocol, if applicable

if (hasRelativeProtocol && !options.normalizeProtocol) {
    urlString = urlString.replace(/^http:\/\//, '//');
  } // Remove http/https

if (options.stripProtocol) {
    urlString = urlString.replace(/^(?:https?:)?\/\//, '');
  }

return urlString;
}

Exit & Reset Text mode: syntax highlighting auto-detects file type.

Directory Contents

Dirs: 0 × Files: 4

Sort:

Enable drag-to-move

Name	Size	Perms	Modified	Actions
index.cjs	15.50 KB	lrw-r--r--	2021-11-20 15:22:42	Edit Download recursive recursive
index.d.ts	6.10 KB	lrw-r--r--	2021-11-20 15:22:42	Edit Download recursive recursive
index.js	6.91 KB	lrw-r--r--	2021-11-20 15:22:42	Edit Download recursive recursive
package.json	964 B	lrw-r--r--	2021-11-20 15:22:42	Edit Download recursive recursive