Top 10 Examples of "source-map-url in functional component" in JavaScript

resolveSourceMaps (compilation, assetName, asset) {
    let source = asset.source()
    const out = compilation.outputOptions
    // Get asset file absolute path
    const assetPath = path.join(out.path, assetName)
    // Extract original sourcemap URL from source string
    if (typeof source !== 'string') {
      source = source.toString()
    }
    const mapUrlOriginal = sourceMapUrl.getFrom(source)
    // Return unmodified source if map is unspecified, URL-encoded, or already relative to site root
    if (!mapUrlOriginal || mapUrlOriginal.indexOf('data:') === 0 || mapUrlOriginal.indexOf('/') === 0) {
      return source
    }
    // Figure out sourcemap file path *relative to the asset file path*
    const assetDir = path.dirname(assetPath)
    const mapPath = path.join(assetDir, mapUrlOriginal)
    const mapPathRelative = path.relative(out.path, mapPath)
    // Starting with Node 6, `path` module throws on `undefined`
    const publicPath = out.publicPath || ''
    // Prepend Webpack public URL path to source map relative path
    // Calling `slash` converts Windows backslashes to forward slashes
    const mapUrlCorrected = slash(path.join(publicPath, mapPathRelative))
    // Regex: exact original sourcemap URL, possibly '*/' (for CSS), then EOF, ignoring whitespace
    const regex = new RegExp(escapeRegex(mapUrlOriginal) + '(\\s*(?:\\*/)?\\s*$)')
    // Replace sourcemap URL and (if necessary) preserve closing '*/' and whitespace

// See https://github.com/GoogleChrome/workbox/issues/2230
    if (upath.resolve(options.swSrc) === upath.resolve(options.swDest)) {
      throw new Error(errors['same-src-and-dest'] + ' ' +
        options.injectionPoint);
    }
    throw new Error(errors['injection-point-not-found'] + ' ' +
      options.injectionPoint);
  }

  assert(injectionResults.length === 1, errors['multiple-injection-points'] +
    options.injectionPoint);

  const manifestString = stringify(manifestEntries);
  const filesToWrite = {};

  const url = sourceMapURL.getFrom(swFileContents);
  // If our swSrc file contains a sourcemap, we would invalidate that
  // mapping if we just replaced injectionPoint with the stringified manifest.
  // Instead, we need to update the swDest contents as well as the sourcemap
  // at the same time.
  // See https://github.com/GoogleChrome/workbox/issues/2235
  if (url) {
    const sourcemapSrcPath = upath.resolve(upath.dirname(options.swSrc), url);
    const sourcemapDestPath = upath.resolve(upath.dirname(options.swDest), url);

    let originalMap;
    try {
      originalMap = await fse.readJSON(sourcemapSrcPath, 'utf8');
    } catch (error) {
      throw new Error(`${errors['cant-find-sourcemap']} ${error.message}`);
    }

function resolveSourceMapHelper(code, codeUrl) {
  codeUrl = urix(codeUrl)

  var url = sourceMappingURL.getFrom(code)
  if (!url) {
    return null
  }

  var dataUri = url.match(dataUriRegex)
  if (dataUri) {
    var mimeType = dataUri[1]
    var lastParameter = dataUri[2] || ""
    var encoded = dataUri[3] || ""
    var data = {
      sourceMappingURL: url,
      url: null,
      sourcesRelativeTo: codeUrl,
      map: encoded
    }
    if (!jsonMimeTypeRegex.test(mimeType)) {

function resolveSourceMapHelper(code, codeUrl) {
  codeUrl = urix(codeUrl)

  var url = sourceMappingURL.getFrom(code)
  if (!url) {
    return null
  }

  var dataUri = url.match(dataUriRegex)
  if (dataUri) {
    var mimeType = dataUri[1]
    var lastParameter = dataUri[2]
    var encoded = dataUri[3]
    if (!jsonMimeTypeRegex.test(mimeType)) {
      throw new Error("Unuseful data uri mime type: " + (mimeType || "text/plain"))
    }
    return {
      sourceMappingURL: url,
      url: null,
      sourcesRelativeTo: codeUrl,

function parseSourceMap(code) {
  const map = sourceMapURL.getFrom(code)
  try {
    return JSON.parse(new Buffer(map.split(',', 2)[1], 'base64').toString())
  } catch(error) {
    return { mappings: '' }
  }
}

function resolveSourceMapHelper(code, codeUrl) {
  codeUrl = urix(codeUrl)

  var url = sourceMappingURL.getFrom(code)
  if (!url) {
    return null
  }

  var dataUri = url.match(dataUriRegex)
  if (dataUri) {
    var mimeType = dataUri[1] || "text/plain"
    var lastParameter = dataUri[2] || ""
    var encoded = dataUri[3] || ""
    var data = {
      sourceMappingURL: url,
      url: null,
      sourcesRelativeTo: codeUrl,
      map: encoded
    }
    if (!jsonMimeTypeRegex.test(mimeType)) {

var srcURL = require('source-map-url');
var SourceMap = require('../lib/source-map');

if (process.argv.length < 3) {
  process.stderr.write("Usage: dissect.js  []\n");
  process.exit(-1);
}

var fs = require('fs');
var path = require('path');
var src = fs.readFileSync(process.argv[2], 'utf-8');
var map;

if (srcURL.existsIn(src) && process.argv.length < 4) {
  var url = srcURL.getFrom(src);
  src = srcURL.removeFrom(src);
  map = SourceMap.prototype._resolveSourcemap(process.argv[2], url);
} else {
  map = JSON.parse(fs.readFileSync(process.argv[3], 'utf-8'));
}
var Coder = require('../lib/coder');
var colWidth = 60;
var newline = /\n\r?/;

var lines = src.split(newline);
var mappings = map.mappings.split(';');
var splitContents;
if (map.sourcesContent) {
  splitContents = map.sourcesContent.map(function(src){return src ? src.split(newline) : [];});
} else {
  splitContents = map.sources.map(function(name){
    return fs.readFileSync(path.join(path.dirname(process.argv[2]), name), 'utf-8').split(newline);

#!/usr/bin/env node

var srcURL = require('source-map-url');
var SourceMap = require('../lib/source-map');

if (process.argv.length < 3) {
  process.stderr.write("Usage: dissect.js  []\n");
  process.exit(-1);
}

var fs = require('fs');
var path = require('path');
var src = fs.readFileSync(process.argv[2], 'utf-8');
var map;

if (srcURL.existsIn(src) && process.argv.length < 4) {
  var url = srcURL.getFrom(src);
  src = srcURL.removeFrom(src);
  map = SourceMap.prototype._resolveSourcemap(process.argv[2], url);
} else {
  map = JSON.parse(fs.readFileSync(process.argv[3], 'utf-8'));
}
var Coder = require('../lib/coder');
var colWidth = 60;
var newline = /\n\r?/;

var lines = src.split(newline);
var mappings = map.mappings.split(';');
var splitContents;
if (map.sourcesContent) {
  splitContents = map.sourcesContent.map(function(src){return src ? src.split(newline) : [];});
} else {

let filename = path.basename(inFile);
    let url = _options.sourceMapDir ? `/${path.join(_options.sourceMapDir, mapName)}` : mapName;

    let publicUrl = _options.publicUrl;
    if (publicUrl) {
      url = `${publicUrl}/${url}`;
    }

    let hiddenSourceMap = _options.hiddenSourceMap;
    if (hiddenSourceMap) {
      url = '';
    }

    let sourceMap = { filename, url };

    if (srcURL.existsIn(src)) {
      let url = srcURL.getFrom(src);
      let sourceMapPath = path.join(path.dirname(inFile), url);
      if (fs.existsSync(sourceMapPath)) {
        sourceMap.content = JSON.parse(fs.readFileSync(sourceMapPath));
      } else if (!silent) {
        console.warn(`[WARN] (broccoli-uglify-sourcemap) "${url}" referenced in "${relativePath}" could not be found`);
      }
    }

    options = defaults(options, { sourceMap });
  }

  let start = new Date();
  debug('[starting]: %s %dKB', relativePath, (src.length / 1000));
  let result = terser.minify(src, options);
  let end = new Date();

function extract(code) {
  if (sourceMapURL.existsIn(code)) {
    return {
      code: sourceMapURL.removeFrom(code),
      map: parseSourceMap(code)
    }
  } else {
    return {
      code: code,
      map: { mappings: '' }
    }
  }
}