How to use source-map-url - 10 common examples

To help you get started, we’ve selected a few source-map-url examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github vuejs / vue-cli / packages / @vue / cli-service / lib / webpack / InlineSourcePlugin.js View on Github external
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
github GoogleChrome / workbox / packages / workbox-build / src / inject-manifest.js View on Github external
// 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}`);
    }
github DagonMetric / angular-build / src / plugins / html-inject-webpack-plugin / src / index.ts View on Github external
const content = HtmlInjectWebpackPlugin.createHtmlTag(tagDefinition);
                        scriptTags.push(content);
                    }
                }
            }

            // Runtime chunk
            let runtimeTagRawContent = '';
            if (this._options.runtimeChunkInline && runtimeFileName &&
                compilation.assets[runtimeFileName]) {
                const asset = compilation.assets[runtimeFileName];
                let source = asset.source();
                if (typeof source !== 'string') {
                    source = source.toString();
                }
                source = `\n${sourceMapUrl.removeFrom(source)}\n`;

                const tagDefinition: TagDefinition = {
                    tagName: 'script',
                    attributes: {
                        type: 'text/javascript'
                    },
                    innerHtml: source,
                    closeTag: true
                };

                runtimeTagRawContent = HtmlInjectWebpackPlugin.createHtmlTag(tagDefinition);

                if (headElement) {
                    const attributes = Object.keys(tagDefinition.attributes).map(key => {
                        return {
                            name: key,
github sx1989827 / DOClever / node_modules / source-map-resolve / lib / source-map-resolve-node.js View on Github external
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)) {
github wheeyls / critical-css-server / node_modules / source-map-resolve / lib / source-map-resolve-node.js View on Github external
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,
github lautis / rollup-plugin-browserify-transform / src / index.js View on Github external
function parseSourceMap(code) {
  const map = sourceMapURL.getFrom(code)
  try {
    return JSON.parse(new Buffer(map.split(',', 2)[1], 'base64').toString())
  } catch(error) {
    return { mappings: '' }
  }
}
github lydell / source-map-resolve / lib / source-map-resolve-node.js View on Github external
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)) {
github ef4 / fast-sourcemap-concat / tools / dissect.js View on Github external
var srcURL = require('source-map-url');
var SourceMap = require('../lib/source-map');

if (process.argv.length < 3) {
  process.stderr.write("Usage: dissect.js <javascript_file> [<sourcemap>]\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);
github ef4 / fast-sourcemap-concat / tools / dissect.js View on Github external
#!/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 <javascript_file> [<sourcemap>]\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 {
github ember-cli / broccoli-uglify-sourcemap / lib / process-file.js View on Github external
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();

source-map-url

Tools for working with sourceMappingURL comments.

MIT
Latest version published 2 years ago

Package Health Score

52 / 100
Full package analysis

Popular JavaScript code snippets

Find secure code to use in your application or website