jiapengyu
556 lines
14 KiB
JavaScript
556 lines
14 KiB
JavaScript
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
|
* Copyright 2011 Mozilla Foundation and contributors
|
|
* Licensed under the New BSD license. See LICENSE or:
|
|
* http://opensource.org/licenses/BSD-3-Clause
|
|
*/
|
|
|
|
/**
|
|
* This is a helper function for getting values from parameter/options
|
|
* objects.
|
|
*
|
|
* @param args The object we are extracting values from
|
|
* @param name The name of the property we are getting.
|
|
* @param defaultValue An optional value to return if the property is missing
|
|
* from the object. If this is not specified and the property is missing, an
|
|
* error will be thrown.
|
|
*/
|
|
function getArg(aArgs, aName, aDefaultValue) {
|
|
if (aName in aArgs) {
|
|
return aArgs[aName]
|
|
} else if (arguments.length === 3) {
|
|
return aDefaultValue
|
|
}
|
|
throw new Error('"' + aName + '" is a required argument.')
|
|
}
|
|
exports.getArg = getArg
|
|
|
|
const urlRegexp =
|
|
/^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/
|
|
const dataUrlRegexp = /^data:.+\,.+$/
|
|
|
|
function urlParse(aUrl) {
|
|
const match = aUrl.match(urlRegexp)
|
|
if (!match) {
|
|
return null
|
|
}
|
|
return {
|
|
scheme: match[1],
|
|
auth: match[2],
|
|
host: match[3],
|
|
port: match[4],
|
|
path: match[5],
|
|
}
|
|
}
|
|
exports.urlParse = urlParse
|
|
|
|
function urlGenerate(aParsedUrl) {
|
|
let url = ''
|
|
if (aParsedUrl.scheme) {
|
|
url += aParsedUrl.scheme + ':'
|
|
}
|
|
url += '//'
|
|
if (aParsedUrl.auth) {
|
|
url += aParsedUrl.auth + '@'
|
|
}
|
|
if (aParsedUrl.host) {
|
|
url += aParsedUrl.host
|
|
}
|
|
if (aParsedUrl.port) {
|
|
url += ':' + aParsedUrl.port
|
|
}
|
|
if (aParsedUrl.path) {
|
|
url += aParsedUrl.path
|
|
}
|
|
return url
|
|
}
|
|
exports.urlGenerate = urlGenerate
|
|
|
|
const MAX_CACHED_INPUTS = 32
|
|
|
|
/**
|
|
* Takes some function `f(input) -> result` and returns a memoized version of
|
|
* `f`.
|
|
*
|
|
* We keep at most `MAX_CACHED_INPUTS` memoized results of `f` alive. The
|
|
* memoization is a dumb-simple, linear least-recently-used cache.
|
|
*/
|
|
function lruMemoize(f) {
|
|
const cache = []
|
|
|
|
return function (input) {
|
|
for (let i = 0; i < cache.length; i++) {
|
|
if (cache[i].input === input) {
|
|
const temp = cache[0]
|
|
cache[0] = cache[i]
|
|
cache[i] = temp
|
|
return cache[0].result
|
|
}
|
|
}
|
|
|
|
const result = f(input)
|
|
|
|
cache.unshift({
|
|
input,
|
|
result,
|
|
})
|
|
|
|
if (cache.length > MAX_CACHED_INPUTS) {
|
|
cache.pop()
|
|
}
|
|
|
|
return result
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Normalizes a path, or the path portion of a URL:
|
|
*
|
|
* - Replaces consecutive slashes with one slash.
|
|
* - Removes unnecessary '.' parts.
|
|
* - Removes unnecessary '<dir>/..' parts.
|
|
*
|
|
* Based on code in the Node.js 'path' core module.
|
|
*
|
|
* @param aPath The path or url to normalize.
|
|
*/
|
|
const normalize = lruMemoize(function normalize(aPath) {
|
|
let path = aPath
|
|
const url = urlParse(aPath)
|
|
if (url) {
|
|
if (!url.path) {
|
|
return aPath
|
|
}
|
|
path = url.path
|
|
}
|
|
const isAbsolute = exports.isAbsolute(path)
|
|
|
|
// Split the path into parts between `/` characters. This is much faster than
|
|
// using `.split(/\/+/g)`.
|
|
const parts = []
|
|
let start = 0
|
|
let i = 0
|
|
while (true) {
|
|
start = i
|
|
i = path.indexOf('/', start)
|
|
if (i === -1) {
|
|
parts.push(path.slice(start))
|
|
break
|
|
} else {
|
|
parts.push(path.slice(start, i))
|
|
while (i < path.length && path[i] === '/') {
|
|
i++
|
|
}
|
|
}
|
|
}
|
|
|
|
let up = 0
|
|
for (i = parts.length - 1; i >= 0; i--) {
|
|
const part = parts[i]
|
|
if (part === '.') {
|
|
parts.splice(i, 1)
|
|
} else if (part === '..') {
|
|
up++
|
|
} else if (up > 0) {
|
|
if (part === '') {
|
|
// The first part is blank if the path is absolute. Trying to go
|
|
// above the root is a no-op. Therefore we can remove all '..' parts
|
|
// directly after the root.
|
|
parts.splice(i + 1, up)
|
|
up = 0
|
|
} else {
|
|
parts.splice(i, 2)
|
|
up--
|
|
}
|
|
}
|
|
}
|
|
path = parts.join('/')
|
|
|
|
if (path === '') {
|
|
path = isAbsolute ? '/' : '.'
|
|
}
|
|
|
|
if (url) {
|
|
url.path = path
|
|
return urlGenerate(url)
|
|
}
|
|
return path
|
|
})
|
|
exports.normalize = normalize
|
|
|
|
/**
|
|
* Joins two paths/URLs.
|
|
*
|
|
* @param aRoot The root path or URL.
|
|
* @param aPath The path or URL to be joined with the root.
|
|
*
|
|
* - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
|
|
* scheme-relative URL: Then the scheme of aRoot, if any, is prepended
|
|
* first.
|
|
* - Otherwise aPath is a path. If aRoot is a URL, then its path portion
|
|
* is updated with the result and aRoot is returned. Otherwise the result
|
|
* is returned.
|
|
* - If aPath is absolute, the result is aPath.
|
|
* - Otherwise the two paths are joined with a slash.
|
|
* - Joining for example 'http://' and 'www.example.com' is also supported.
|
|
*/
|
|
function join(aRoot, aPath) {
|
|
if (aRoot === '') {
|
|
aRoot = '.'
|
|
}
|
|
if (aPath === '') {
|
|
aPath = '.'
|
|
}
|
|
const aPathUrl = urlParse(aPath)
|
|
const aRootUrl = urlParse(aRoot)
|
|
if (aRootUrl) {
|
|
aRoot = aRootUrl.path || '/'
|
|
}
|
|
|
|
// `join(foo, '//www.example.org')`
|
|
if (aPathUrl && !aPathUrl.scheme) {
|
|
if (aRootUrl) {
|
|
aPathUrl.scheme = aRootUrl.scheme
|
|
}
|
|
return urlGenerate(aPathUrl)
|
|
}
|
|
|
|
if (aPathUrl || aPath.match(dataUrlRegexp)) {
|
|
return aPath
|
|
}
|
|
|
|
// `join('http://', 'www.example.com')`
|
|
if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
|
|
aRootUrl.host = aPath
|
|
return urlGenerate(aRootUrl)
|
|
}
|
|
|
|
const joined =
|
|
aPath.charAt(0) === '/'
|
|
? aPath
|
|
: normalize(aRoot.replace(/\/+$/, '') + '/' + aPath)
|
|
|
|
if (aRootUrl) {
|
|
aRootUrl.path = joined
|
|
return urlGenerate(aRootUrl)
|
|
}
|
|
return joined
|
|
}
|
|
exports.join = join
|
|
|
|
exports.isAbsolute = function (aPath) {
|
|
return aPath.charAt(0) === '/' || urlRegexp.test(aPath)
|
|
}
|
|
|
|
/**
|
|
* Make a path relative to a URL or another path.
|
|
*
|
|
* @param aRoot The root path or URL.
|
|
* @param aPath The path or URL to be made relative to aRoot.
|
|
*/
|
|
function relative(aRoot, aPath) {
|
|
if (aRoot === '') {
|
|
aRoot = '.'
|
|
}
|
|
|
|
aRoot = aRoot.replace(/\/$/, '')
|
|
|
|
// It is possible for the path to be above the root. In this case, simply
|
|
// checking whether the root is a prefix of the path won't work. Instead, we
|
|
// need to remove components from the root one by one, until either we find
|
|
// a prefix that fits, or we run out of components to remove.
|
|
let level = 0
|
|
while (aPath.indexOf(aRoot + '/') !== 0) {
|
|
const index = aRoot.lastIndexOf('/')
|
|
if (index < 0) {
|
|
return aPath
|
|
}
|
|
|
|
// If the only part of the root that is left is the scheme (i.e. http://,
|
|
// file:///, etc.), one or more slashes (/), or simply nothing at all, we
|
|
// have exhausted all components, so the path is not relative to the root.
|
|
aRoot = aRoot.slice(0, index)
|
|
if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
|
|
return aPath
|
|
}
|
|
|
|
++level
|
|
}
|
|
|
|
// Make sure we add a "../" for each component we removed from the root.
|
|
return Array(level + 1).join('../') + aPath.substr(aRoot.length + 1)
|
|
}
|
|
exports.relative = relative
|
|
|
|
const supportsNullProto = (function () {
|
|
const obj = Object.create(null)
|
|
return !('__proto__' in obj)
|
|
})()
|
|
|
|
function identity(s) {
|
|
return s
|
|
}
|
|
|
|
/**
|
|
* Because behavior goes wacky when you set `__proto__` on objects, we
|
|
* have to prefix all the strings in our set with an arbitrary character.
|
|
*
|
|
* See https://github.com/mozilla/source-map/pull/31 and
|
|
* https://github.com/mozilla/source-map/issues/30
|
|
*
|
|
* @param String aStr
|
|
*/
|
|
function toSetString(aStr) {
|
|
if (isProtoString(aStr)) {
|
|
return '$' + aStr
|
|
}
|
|
|
|
return aStr
|
|
}
|
|
exports.toSetString = supportsNullProto ? identity : toSetString
|
|
|
|
function fromSetString(aStr) {
|
|
if (isProtoString(aStr)) {
|
|
return aStr.slice(1)
|
|
}
|
|
|
|
return aStr
|
|
}
|
|
exports.fromSetString = supportsNullProto ? identity : fromSetString
|
|
|
|
function isProtoString(s) {
|
|
if (!s) {
|
|
return false
|
|
}
|
|
|
|
const length = s.length
|
|
|
|
if (length < 9 /* "__proto__".length */) {
|
|
return false
|
|
}
|
|
|
|
/* eslint-disable no-multi-spaces */
|
|
if (
|
|
s.charCodeAt(length - 1) !== 95 /* '_' */ ||
|
|
s.charCodeAt(length - 2) !== 95 /* '_' */ ||
|
|
s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
|
|
s.charCodeAt(length - 4) !== 116 /* 't' */ ||
|
|
s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
|
|
s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
|
|
s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
|
|
s.charCodeAt(length - 8) !== 95 /* '_' */ ||
|
|
s.charCodeAt(length - 9) !== 95 /* '_' */
|
|
) {
|
|
return false
|
|
}
|
|
/* eslint-enable no-multi-spaces */
|
|
|
|
for (let i = length - 10; i >= 0; i--) {
|
|
if (s.charCodeAt(i) !== 36 /* '$' */) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* Comparator between two mappings where the original positions are compared.
|
|
*
|
|
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
|
|
* mappings with the same original source/line/column, but different generated
|
|
* line and column the same. Useful when searching for a mapping with a
|
|
* stubbed out mapping.
|
|
*/
|
|
function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
|
|
let cmp = strcmp(mappingA.source, mappingB.source)
|
|
if (cmp !== 0) {
|
|
return cmp
|
|
}
|
|
|
|
cmp = mappingA.originalLine - mappingB.originalLine
|
|
if (cmp !== 0) {
|
|
return cmp
|
|
}
|
|
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn
|
|
if (cmp !== 0 || onlyCompareOriginal) {
|
|
return cmp
|
|
}
|
|
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn
|
|
if (cmp !== 0) {
|
|
return cmp
|
|
}
|
|
|
|
cmp = mappingA.generatedLine - mappingB.generatedLine
|
|
if (cmp !== 0) {
|
|
return cmp
|
|
}
|
|
|
|
return strcmp(mappingA.name, mappingB.name)
|
|
}
|
|
exports.compareByOriginalPositions = compareByOriginalPositions
|
|
|
|
/**
|
|
* Comparator between two mappings with deflated source and name indices where
|
|
* the generated positions are compared.
|
|
*
|
|
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
|
|
* mappings with the same generated line and column, but different
|
|
* source/name/original line and column the same. Useful when searching for a
|
|
* mapping with a stubbed out mapping.
|
|
*/
|
|
function compareByGeneratedPositionsDeflated(
|
|
mappingA,
|
|
mappingB,
|
|
onlyCompareGenerated
|
|
) {
|
|
let cmp = mappingA.generatedLine - mappingB.generatedLine
|
|
if (cmp !== 0) {
|
|
return cmp
|
|
}
|
|
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn
|
|
if (cmp !== 0 || onlyCompareGenerated) {
|
|
return cmp
|
|
}
|
|
|
|
cmp = strcmp(mappingA.source, mappingB.source)
|
|
if (cmp !== 0) {
|
|
return cmp
|
|
}
|
|
|
|
cmp = mappingA.originalLine - mappingB.originalLine
|
|
if (cmp !== 0) {
|
|
return cmp
|
|
}
|
|
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn
|
|
if (cmp !== 0) {
|
|
return cmp
|
|
}
|
|
|
|
return strcmp(mappingA.name, mappingB.name)
|
|
}
|
|
exports.compareByGeneratedPositionsDeflated =
|
|
compareByGeneratedPositionsDeflated
|
|
|
|
function strcmp(aStr1, aStr2) {
|
|
if (aStr1 === aStr2) {
|
|
return 0
|
|
}
|
|
|
|
if (aStr1 === null) {
|
|
return 1 // aStr2 !== null
|
|
}
|
|
|
|
if (aStr2 === null) {
|
|
return -1 // aStr1 !== null
|
|
}
|
|
|
|
if (aStr1 > aStr2) {
|
|
return 1
|
|
}
|
|
|
|
return -1
|
|
}
|
|
|
|
/**
|
|
* Comparator between two mappings with inflated source and name strings where
|
|
* the generated positions are compared.
|
|
*/
|
|
function compareByGeneratedPositionsInflated(mappingA, mappingB) {
|
|
let cmp = mappingA.generatedLine - mappingB.generatedLine
|
|
if (cmp !== 0) {
|
|
return cmp
|
|
}
|
|
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn
|
|
if (cmp !== 0) {
|
|
return cmp
|
|
}
|
|
|
|
cmp = strcmp(mappingA.source, mappingB.source)
|
|
if (cmp !== 0) {
|
|
return cmp
|
|
}
|
|
|
|
cmp = mappingA.originalLine - mappingB.originalLine
|
|
if (cmp !== 0) {
|
|
return cmp
|
|
}
|
|
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn
|
|
if (cmp !== 0) {
|
|
return cmp
|
|
}
|
|
|
|
return strcmp(mappingA.name, mappingB.name)
|
|
}
|
|
exports.compareByGeneratedPositionsInflated =
|
|
compareByGeneratedPositionsInflated
|
|
|
|
/**
|
|
* Strip any JSON XSSI avoidance prefix from the string (as documented
|
|
* in the source maps specification), and then parse the string as
|
|
* JSON.
|
|
*/
|
|
function parseSourceMapInput(str) {
|
|
return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''))
|
|
}
|
|
exports.parseSourceMapInput = parseSourceMapInput
|
|
|
|
/**
|
|
* Compute the URL of a source given the the source root, the source's
|
|
* URL, and the source map's URL.
|
|
*/
|
|
function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
|
|
sourceURL = sourceURL || ''
|
|
|
|
if (sourceRoot) {
|
|
// This follows what Chrome does.
|
|
if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
|
|
sourceRoot += '/'
|
|
}
|
|
// The spec says:
|
|
// Line 4: An optional source root, useful for relocating source
|
|
// files on a server or removing repeated values in the
|
|
// “sources” entry. This value is prepended to the individual
|
|
// entries in the “source” field.
|
|
sourceURL = sourceRoot + sourceURL
|
|
}
|
|
|
|
// Historically, SourceMapConsumer did not take the sourceMapURL as
|
|
// a parameter. This mode is still somewhat supported, which is why
|
|
// this code block is conditional. However, it's preferable to pass
|
|
// the source map URL to SourceMapConsumer, so that this function
|
|
// can implement the source URL resolution algorithm as outlined in
|
|
// the spec. This block is basically the equivalent of:
|
|
// new URL(sourceURL, sourceMapURL).toString()
|
|
// ... except it avoids using URL, which wasn't available in the
|
|
// older releases of node still supported by this library.
|
|
//
|
|
// The spec says:
|
|
// If the sources are not absolute URLs after prepending of the
|
|
// “sourceRoot”, the sources are resolved relative to the
|
|
// SourceMap (like resolving script src in a html document).
|
|
if (sourceMapURL) {
|
|
const parsed = urlParse(sourceMapURL)
|
|
if (!parsed) {
|
|
throw new Error('sourceMapURL could not be parsed')
|
|
}
|
|
if (parsed.path) {
|
|
// Strip the last path component, but keep the "/".
|
|
const index = parsed.path.lastIndexOf('/')
|
|
if (index >= 0) {
|
|
parsed.path = parsed.path.substring(0, index + 1)
|
|
}
|
|
}
|
|
sourceURL = join(urlGenerate(parsed), sourceURL)
|
|
}
|
|
|
|
return normalize(sourceURL)
|
|
}
|
|
exports.computeSourceURL = computeSourceURL
|