/* -*- 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