Bron kaart

Dit is een bibliotheek voor het genereren en gebruiken van het bronkaartformaat dat hier wordt beschreven .

Gebruik met knooppunt

1
$ npm install source-map

Gebruik op internet

1
2
3
4
5
6
<script src="https://unpkg.com/source-map@0.7.2/dist/source-map.js"></script>
<script>
    sourceMap.SourceMapConsumer.initialize({
        "lib/mappings.wasm": "https://unpkg.com/source-map@0.7.2/lib/mappings.wasm"
    });
</script>

Inhoudsopgave

Voorbeelden
- Een bronkaart gebruiken
- Het genereren van een bronkaart
  - Met SourceNode (API op hoog niveau)
  - Met SourceMapGenerator (API op laag niveau)
API

Voorbeelden

Consuming a source map

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
const rawSourceMap = {
  version: 3,
  file: 'min.js',
  names: ['bar', 'baz', 'n'],
  sources: ['one.js', 'two.js'],
  sourceRoot: 'http://example.com/www/js/',
  mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA'
};

const whatever = await SourceMapConsumer.with(rawSourceMap, null, consumer => {

  console.log(consumer.sources);
  // [ 'http://example.com/www/js/one.js',
  //   'http://example.com/www/js/two.js' ]

  console.log(consumer.originalPositionFor({
    line: 2,
    column: 28
  }));
  // { source: 'http://example.com/www/js/two.js',
  //   line: 2,
  //   column: 10,
  //   name: 'n' }

  console.log(consumer.generatedPositionFor({
    source: 'http://example.com/www/js/two.js',
    line: 2,
    column: 10
  }));
  // { line: 2, column: 28 }

  consumer.eachMapping(function (m) {
    // ...
  });

  return computeWhatever();
});

Generating a source map

Uitgebreide handleiding: compileren naar JavaScript en debuggen met bronkaarten

Met SourceNode (API op hoog niveau)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
function compile(ast) {
  switch (ast.type) {
  case 'BinaryExpression':
    return new SourceNode(
      ast.location.line,
      ast.location.column,
      ast.location.source,
      [compile(ast.left), " + ", compile(ast.right)]
    );
  case 'Literal':
    return new SourceNode(
      ast.location.line,
      ast.location.column,
      ast.location.source,
      String(ast.value)
    );
  // ...
  default:
    throw new Error("Bad AST");
  }
}

var ast = parse("40 + 2", "add.js");
console.log(compile(ast).toStringWithSourceMap({
  file: 'add.js'
}));
// { code: '40 + 2',
//   map: [object SourceMapGenerator] }

Met SourceMapGenerator (API op laag niveau)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
var map = new SourceMapGenerator({
  file: "source-mapped.js"
});

map.addMapping({
  generated: {
    line: 10,
    column: 35
  },
  source: "foo.js",
  original: {
    line: 33,
    column: 2
  },
  name: "christopher"
});

console.log(map.toString());
// '{"version":3,"file":"source-mapped.js","sources":["foo.js"],"names":["christopher"],"mappings":";;;;;;;;;mCAgCEA"}'

API

Krijg een referentie naar de module:

1
2
3
4
5
6
7
8
// Node.js
var sourceMap = require('source-map');

// Browser builds
var sourceMap = window.sourceMap;

// Inside Firefox
const sourceMap = require("devtools/toolkit/sourcemap/source-map.js");

SourceMapConsumer

Een SourceMapConsumerinstance vertegenwoordigt een geparseerde bronkaart die we kunnen opvragen voor informatie over de oorspronkelijke bestandsposities door deze een bestandspositie in de gegenereerde bron te geven.

SourceMapConsumer.initialize(opties)

Bij gebruik SourceMapConsumerbuiten node.js, bijvoorbeeld op internet, moet het weten vanaf welke URL het moet laden lib/mappings.wasm. U moet het informeren door het aan te roepen initializevoordat u SourceMapConsumers.

Het optieobject heeft de volgende eigenschappen:

"lib/mappings.wasm": Een Stringmet de URL van het lib/mappings.wasmbestand.

1
2
3sourceMap.SourceMapConsumer.initialize({
  "lib/mappings.wasm": "https://example.com/source-map/lib/mappings.wasm"
});

nieuwe SourceMapConsumer(rawSourceMap)

De enige parameter is de onbewerkte bronkaart (ofwel als een string die JSON.parse'd' kan zijn, ofwel als een object). Volgens de specificatie hebben bronkaarten de volgende attributen:

version: Welke versie van de bronkaartspecificatie deze kaart volgt.
sources: een reeks URL's naar de originele bronbestanden.
names: Een reeks identificatiegegevens waarnaar kan worden verwezen door individuele toewijzingen.
sourceRoot: Optioneel. De URL-hoofdmap van waaruit alle bronnen relatief zijn.
sourcesContent: Optioneel. Een array met inhoud van de originele bronbestanden.
mappings: Een reeks base64 VLQ's die de daadwerkelijke toewijzingen bevatten.
file: Optioneel. De gegenereerde bestandsnaam waaraan deze brontoewijzing is gekoppeld.

De belofte van de geconstrueerde bronkaartconsument wordt beantwoord.

Wanneer het SourceMapConsumerniet langer meer wordt gebruikt, moet u de destroymethode ervan aanroepen.

1
2
3
const consumer = await new sourceMap.SourceMapConsumer(rawSourceMapJsonData);
doStuffWith(consumer);
consumer.destroy();

Als alternatief kunt u gebruiken SourceMapConsumer.withom te voorkomen dat u hoeft te bellen destroy.

SourceMapConsumer.with

Construeer een nieuwe SourceMapConsumervan rawSourceMapen sourceMapUrl (zie de SourceMapConsumerconstructor voor details. Roep vervolgens de aan async function f(SourceMapConsumer) -> Tmet de nieuw geconstrueerde consument, wacht tot deze fis voltooid, roep destroyde consument aan en retourneer fde geretourneerde waarde.

U mag de consument niet gebruiken nadat fdeze is voltooid!

Door te gebruiken withhoeft u er niet aan te denken destroyde consument handmatig op te bellen, aangezien deze na voltooiing automatisch wordt gebeld f.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
const xSquared = await SourceMapConsumer.with(
  myRawSourceMap,
  null,
  async function (consumer) {
    // Use `consumer` inside here and don't worry about remembering
    // to call `destroy`.

    const x = await whatever(consumer);
    return x * x;
  }
);

// You may not use that `consumer` anymore out here; it has
// been destroyed. But you can use `xSquared`.
console.log(xSquared);

SourceMapConsumer.prototype.destroy()

Bevrijd de bijbehorende wasm-gegevens van deze bronkaartconsument die handmatig worden beheerd.

1consumer.destroy();

Als alternatief kunt u gebruiken SourceMapConsumer.withom te voorkomen dat u hoeft te bellen destroy.

SourceMapConsumer.prototype.computeColumnSpans()

Bereken de laatste kolom voor elke gegenereerde toewijzing. De laatste kolom is inclusief.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// Before:
consumer.allGeneratedPositionsFor({ line: 2, source: "foo.coffee" })
// [ { line: 2,
//     column: 1 },
//   { line: 2,
//     column: 10 },
//   { line: 2,
//     column: 20 } ]

consumer.computeColumnSpans();

// After:
consumer.allGeneratedPositionsFor({ line: 2, source: "foo.coffee" })
// [ { line: 2,
//     column: 1,
//     lastColumn: 9 },
//   { line: 2,
//     column: 10,
//     lastColumn: 19 },
//   { line: 2,
//     column: 20,
//     lastColumn: Infinity } ]

SourceMapConsumer.prototype.originalPositionFor(gegenereerdePositie)

Retourneert de oorspronkelijke bron-, regel- en kolominformatie voor de opgegeven regel- en kolomposities van de gegenereerde bron. Het enige argument is een object met de volgende eigenschappen:

line: Het regelnummer in de gegenereerde bron. Regelnummers in deze bibliotheek zijn op 1 gebaseerd (merk op dat de onderliggende bronkaartspecificatie op 0 gebaseerde regelnummers gebruikt - deze bibliotheek zorgt voor de vertaling).
column: Het kolomnummer in de gegenereerde bron. Kolomnummers in deze bibliotheek zijn op 0 gebaseerd.
bias: Ofwel SourceMapConsumer.GREATEST_LOWER_BOUNDof SourceMapConsumer.LEAST_UPPER_BOUNDSpecificeert of het dichtstbijzijnde element moet worden geretourneerd dat respectievelijk kleiner of groter is dan het element waarnaar we zoeken, als het exacte element niet kan worden gevonden SourceMapConsumer.GREATEST_LOWER_BOUND.

en er wordt een object geretourneerd met de volgende eigenschappen:

source: Het originele bronbestand, of null als deze informatie niet beschikbaar is.
line: Het regelnummer in de oorspronkelijke bron, of null als deze informatie niet beschikbaar is. Het regelnummer is gebaseerd op 1.
column: Het kolomnummer in de oorspronkelijke bron, of null als deze informatie niet beschikbaar is. Het kolomnummer is gebaseerd op 0.
name: De oorspronkelijke identificatie, of null als deze informatie niet beschikbaar is.

1
2
3
4
5
6
7
8
9
10
11
consumer.originalPositionFor({ line: 2, column: 10 })
// { source: 'foo.coffee',
//   line: 2,
//   column: 2,
//   name: null }

consumer.originalPositionFor({ line: 99999999999999999, column: 999999999999999 })
// { source: null,
//   line: null,
//   column: null,
//   name: null }

SourceMapConsumer.prototype.generatedPositionFor(originelepositie)

Retourneert de gegenereerde regel- en kolominformatie voor de oorspronkelijke opgegeven bron-, regel- en kolomposities. Het enige argument is een object met de volgende eigenschappen:

source: De bestandsnaam van de originele bron.
line: Het regelnummer in de oorspronkelijke bron. Het regelnummer is gebaseerd op 1.
column: Het kolomnummer in de oorspronkelijke bron. Het kolomnummer is gebaseerd op 0.

en er wordt een object geretourneerd met de volgende eigenschappen:

line: Het regelnummer in de gegenereerde bron, of null. Het regelnummer is gebaseerd op 1.
column: Het kolomnummer in de gegenereerde bron, of null. Het kolomnummer is gebaseerd op 0.

1
2
3
consumer.generatedPositionFor({ source: "example.js", line: 2, column: 10 })
// { line: 1,
//   column: 56 }

SourceMapConsumer.prototype.allGeneratedPositionsFor(originelepositie)

Retourneert alle gegenereerde regel- en kolominformatie voor de oorspronkelijke bron, regel en kolom. Als er geen kolom is opgegeven, worden alle toewijzingen geretourneerd die overeenkomen met de regel waarnaar we zoeken, of met de volgende dichtstbijzijnde regel die koppelingen heeft. Anders wordt er geretourneerd alle toewijzingen die overeenkomen met de gegeven lijn en ofwel de kolom waarnaar we zoeken, ofwel de volgende dichtstbijzijnde kolom die eventuele offsets heeft.

Het enige argument is een object met de volgende eigenschappen:

source: De bestandsnaam van de originele bron.
line: Het regelnummer in de oorspronkelijke bron. Het regelnummer is gebaseerd op 1.
column: Optioneel. Het kolomnummer in de oorspronkelijke bron. Het kolomnummer is gebaseerd op 0.

en er wordt een array met objecten geretourneerd, elk met de volgende eigenschappen:

line: Het regelnummer in de gegenereerde bron, of null. Het regelnummer is gebaseerd op 1.
column: Het kolomnummer in de gegenereerde bron, of null. Het kolomnummer is gebaseerd op 0.

1
2
3
4
5
6
7
consumer.allGeneratedpositionsfor({ line: 2, source: "foo.coffee" })
// [ { line: 2,
//     column: 1 },
//   { line: 2,
//     column: 10 },
//   { line: 2,
//     column: 20 } ]

SourceMapConsumer.prototype.hasContentsOfAllSources()

Retourneert true als we de ingesloten broninhoud hebben voor elke bron die in de bronkaart wordt vermeld, anders false.

Met andere woorden: als deze methode retourneert true, consumer.sourceContentFor(s)zal deze voor elke bron sin consumer.sources.

1
2
3
4
5
6
7
// ...
if (consumer.hasContentsOfAllSources()) {
  consumerReadyCallback(consumer);
} else {
  fetchSources(consumer, consumerReadyCallback);
}
// ...

SourceMapConsumer.prototype.sourceContentFor(bron[, returnNullOnMissing])

Retourneert de oorspronkelijke broninhoud voor de opgegeven bron. Het enige argument is de URL van het oorspronkelijke bronbestand.

Als de broninhoud voor de opgegeven bron niet wordt gevonden, wordt er een fout gegenereerd. Geef desgewenst door trueals de tweede parameter die moet worden nullgeretourneerd.

1
2
3
4
5
6
7
8
9
10
11consumer.sources
// [ "my-cool-lib.clj" ]

consumer.sourceContentFor("my-cool-lib.clj")
// "..."

consumer.sourceContentFor("this is not in the source map");
// Error: "this is not in the source map" is not in the source map

consumer.sourceContentFor("this is not in the source map", true);
// null

SourceMapConsumer.prototype.eachMapping (callback, context, volgorde)

Herhaal elke toewijzing tussen een originele bron/lijn/kolom en een gegenereerde regel/kolom in deze bronkaart.

callback: De functie die bij elke toewijzing wordt aangeroepen. Toewijzingen hebben de vorm{ source, generatedLine, generatedColumn, originalLine, originalColumn, name }
context: Optioneel. Indien opgegeven, zal dit object de waarde zijn van this elke keer dat callbackwordt aangeroepen.
order: Ofwel SourceMapConsumer.GENERATED_ORDERof SourceMapConsumer.ORIGINAL_ORDER. Geeft aan of u de toewijzingen wilt doorlopen, gesorteerd op respectievelijk de regel-/kolomvolgorde van het gegenereerde bestand of de bron-/regel-/kolomvolgorde van het origineel. Standaard ingesteld op SourceMapConsumer.GENERATED_ORDER.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
consumer.eachMapping(function (m) { console.log(m); })
// ...
// { source: 'illmatic.js',
//   generatedLine: 1,
//   generatedColumn: 0,
//   originalLine: 1,
//   originalColumn: 0,
//   name: null }
// { source: 'illmatic.js',
//   generatedLine: 2,
//   generatedColumn: 0,
//   originalLine: 2,
//   originalColumn: 0,
//   name: null }
// ...

SourceMapGenerator

Een exemplaar van de SourceMapGenerator vertegenwoordigt een bronkaart die stapsgewijs wordt opgebouwd.

nieuwe SourceMapGenerator([startOfSourceMap])

U kunt een object doorgeven met de volgende eigenschappen:

file: De bestandsnaam van de gegenereerde bron waaraan deze brontoewijzing is gekoppeld.
sourceRoot: Een hoofdmap voor alle relatieve URL's in deze bronkaart.
skipValidation: Optioneel. Wanneer truewordt de validatie van toewijzingen uitgeschakeld wanneer ze worden toegevoegd. Dit kan de prestaties verbeteren, maar moet als laatste redmiddel met discretie worden gebruikt. Zelfs dan moet men, indien mogelijk, het gebruik van deze vlag vermijden bij het uitvoeren van tests.

1
2
3
4
var generator = new sourceMap.SourceMapGenerator({
  file: "my-generated-javascript-file.js",
  sourceRoot: "http://example.com/app/js/"
});

SourceMapGenerator.fromSourceMap(sourceMapConsumer)

Creëert een nieuwe SourceMapGeneratorvan een bestaande SourceMapConsumerinstantie.

sourceMapConsumerDe Bronkaart.

1
var generator = sourceMap.SourceMapGenerator.fromSourceMap(consumer);

SourceMapGenerator.prototype.addMapping(toewijzing)

Voeg een enkele toewijzing van de oorspronkelijke bronregel en -kolom toe aan de gegenereerde bronregel en -kolom voor deze bronkaart die wordt gemaakt. Het toewijzingsobject moet de volgende eigenschappen hebben:

generated: Een object met de gegenereerde lijn- en kolomposities.
original: Een object met de originele lijn- en kolomposities.
source: Het originele bronbestand (ten opzichte van de sourceRoot).
name: Een optionele originele tokennaam voor deze toewijzing.

1
2
3
4
5generator.addMapping({
  source: "module-one.scm",
  original: { line: 128, column: 0 },
  generated: { line: 3, column: 456 }
})

SourceMapGenerator.prototype.setSourceContent(bronbestand, broninhoud)

Stel de broninhoud voor een origineel bronbestand in.

sourceFilede URL van het originele bronbestand.
sourceContentde inhoud van het bronbestand.

1
2
generator.setSourceContent("module-one.scm",
                           fs.readFileSync("path/to/module-one.scm"))

SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile[, sourceMapPath]])

Past een SourceMap voor een bronbestand toe op de SourceMap. Elke toewijzing aan het meegeleverde bronbestand wordt herschreven met behulp van de meegeleverde SourceMap. Opmerking: de resolutie voor de resulterende toewijzingen is het minimum van deze kaart en de meegeleverde kaart.

sourceMapConsumer: De SourceMap die moet worden toegepast.
sourceFile: Optioneel. De bestandsnaam van het bronbestand. Als u dit weglaat, wordt sourceMapConsumer.file gebruikt, als dit bestaat. Anders wordt er een fout gegenereerd.
sourceMapPath: Optioneel. De mapnaam van het pad naar de SourceMap dat moet worden toegepast. Indien relatief, is het relatief ten opzichte van de SourceMap.

Deze parameter is nodig als de twee SourceMaps zich niet in dezelfde map bevinden en de toe te passen SourceMap relatieve bronpaden bevat. Als dat het geval is, moeten deze relatieve bronpaden worden herschreven ten opzichte van de SourceMap.

Als u dit weglaat, wordt ervan uitgegaan dat beide SourceMaps zich in dezelfde map bevinden en dus niet opnieuw hoeven te worden geschreven (aanleveren '.'heeft hetzelfde effect).

SourceMapGenerator.prototype.toString()

Rendert de bronkaart die wordt gegenereerd naar een tekenreeks.

1
2generator.toString()
// '{"version":3,"sources":["module-one.scm"],"names":[],"mappings":"...snip...","file":"my-generated-javascript-file.js","sourceRoot":"http://example.com/app/js/"}'

SourceNode

SourceNodes bieden een manier om fragmenten van gegenereerde JavaScript-broncode te interpoleren en/of aan elkaar te koppelen, terwijl de regel- en kolominformatie die tussen die fragmenten en de originele broncode is gekoppeld, behouden blijft. Dit is handig als de laatste tussenrepresentatie die een compiler kan gebruiken voordat deze wordt uitgevoerd de gegenereerde JS en bronkaart.

new SourceNode([regel, kolom, bron[, chunk[, naam]]])

line: Het originele regelnummer dat aan dit bronknooppunt is gekoppeld, of null als het niet aan een originele regel is gekoppeld. Het regelnummer is gebaseerd op 1.
column: Het oorspronkelijke kolomnummer dat aan dit bronknooppunt is gekoppeld, of null als het niet aan een oorspronkelijke kolom is gekoppeld. Het kolomnummer is op 0 gebaseerd.
source: De bestandsnaam van de originele bron; null als er geen bestandsnaam is opgegeven.
chunk: Optioneel, wordt direct doorgegeven aan SourceNode.prototype.add, zie hieronder.
name: Optioneel. De originele ID.

1
2
3
4
5
var node = new SourceNode(1, 2, "a.cpp", [
  new SourceNode(3, 4, "b.cpp", "extern int status;\n"),
  new SourceNode(5, 6, "c.cpp", "std::string* make_string(size_t n);\n"),
  new SourceNode(7, 8, "d.cpp", "int main(int argc, char** argv) {}\n"),
]);

SourceNode.fromStringWithSourceMap(code, sourceMapConsumer[, relatievePath])

Creëert een SourceNode op basis van gegenereerde code en een SourceMapConsumer.

code:De gegenereerde code
sourceMapConsumerDe SourceMap voor de gegenereerde code
relativePathHet optionele pad waar relatieve bronnen in sourceMapConsumer relatief moeten zijn.

1
2
const consumer = await new SourceMapConsumer(fs.readFileSync("path/to/my-file.js.map", "utf8"));
const node = SourceNode.fromStringWithSourceMap(fs.readFileSync("path/to/my-file.js"), consumer);

SourceNode.prototype.add(chunk)

Voeg een deel van de gegenereerde JS toe aan dit bronknooppunt.

chunk: Een tekenreeksfragment van gegenereerde JS-code, een ander exemplaar van SourceNode, of een array waarbij elk lid een van die dingen is.

1
2
3
node.add(" + ");
node.add(otherNode);
node.add([leftHandOperandNode, " + ", rightHandOperandNode]);

SourceNode.prototype.prepend(stuk)

Voeg een deel van de gegenereerde JS toe aan dit bronknooppunt.

chunk: Een tekenreeksfragment van gegenereerde JS-code, een ander exemplaar van SourceNode, of een array waarbij elk lid een van die dingen is.

1
node.prepend("/** Build Id: f783haef86324gf **/\n\n");

SourceNode.prototype.setSourceContent(bronbestand, broninhoud)

Stel de broninhoud voor een bronbestand in. Deze wordt toegevoegd aan het SourceMapveld sourcesContent.

sourceFile: De bestandsnaam van het bronbestand
sourceContent: de inhoud van het bronbestand

1
2
node.setSourceContent("module-one.scm",
                      fs.readFileSync("path/to/module-one.scm"))

SourceNode.prototype.walk(fn)

Loop door de boom met JS-fragmenten in dit knooppunt en de onderliggende knooppunten. De wandelfunctie wordt één keer aangeroepen voor elk fragment van JS en wordt doorgegeven aan dat fragment en de oorspronkelijke regel-/kolomlocatie van de bijbehorende bron.

fn: De traversale functie.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var node = new SourceNode(1, 2, "a.js", [
  new SourceNode(3, 4, "b.js", "uno"),
  "dos",
  [
    "tres",
    new SourceNode(5, 6, "c.js", "quatro")
  ]
]);

node.walk(function (code, loc) { console.log("WALK:", code, loc); })
// WALK: uno { source: 'b.js', line: 3, column: 4, name: null }
// WALK: dos { source: 'a.js', line: 1, column: 2, name: null }
// WALK: tres { source: 'a.js', line: 1, column: 2, name: null }
// WALK: quatro { source: 'c.js', line: 5, column: 6, name: null }

SourceNode.prototype.walkSourceContents(fn)

Loop door de boomstructuur van SourceNodes. De wandelfunctie wordt aangeroepen voor elke bronbestandsinhoud en krijgt de bestandsnaam en broninhoud doorgegeven.

fn: De traversale functie.

1
2
3
4
5
6
7
8
9
10
11
12
var a = new SourceNode(1, 2, "a.js", "generated from a");
a.setSourceContent("a.js", "original a");
var b = new SourceNode(1, 2, "b.js", "generated from b");
b.setSourceContent("b.js", "original b");
var c = new SourceNode(1, 2, "c.js", "generated from c");
c.setSourceContent("c.js", "original c");

var node = new SourceNode(null, null, null, [a, b, c]);
node.walkSourceContents(function (source, contents) { console.log("WALK:", source, ":", contents); })
// WALK: a.js : original a
// WALK: b.js : original b
// WALK: c.js : original c

SourceNode.prototype.join(sep)

Zoals Array.prototype.join, behalve voor SourceNodes. Voegt het scheidingsteken in tussen elk van de onderliggende bronknooppunten.

sep: De scheidingsteken.

1
2
3
4
5
6
var lhs = new SourceNode(1, 2, "a.rs", "my_copy");
var operand = new SourceNode(3, 4, "a.rs", "=");
var rhs = new SourceNode(5, 6, "a.rs", "orig.clone()");

var node = new SourceNode(null, null, null, [ lhs, operand, rhs ]);
var joinedNode = node.join(" ");

SourceNode.prototype.replaceRight(patroon, vervanging)

Roep String.prototype.replacehet meest rechtse bronfragment aan. Handig voor het inkorten van witruimte vanaf het einde van een bronknooppunt, enz.

pattern: Het patroon dat moet worden vervangen.
replacement: Het ding waarmee het patroon moet worden vervangen.

1
2
// Trim trailing white space.
node.replaceRight(/\s*$/, "");

SourceNode.prototype.toString()

Retourneert de tekenreeksrepresentatie van dit bronknooppunt. Loopt door de boom en voegt alle verschillende fragmenten samen tot één tekenreeks.

1
2
3
4
5
6
7
8
9
10
11
var node = new SourceNode(1, 2, "a.js", [
  new SourceNode(3, 4, "b.js", "uno"),
  "dos",
  [
    "tres",
    new SourceNode(5, 6, "c.js", "quatro")
  ]
]);

node.toString()
// 'unodostresquatro'

SourceNode.prototype.toStringWithSourceMap([startOfSourceMap])

Retourneert de tekenreeksrepresentatie van deze boom met bronknooppunten, plus een SourceMapGenerator die alle toewijzingen tussen de gegenereerde en originele bronnen bevat.

De argumenten zijn dezelfde als die voor new SourceMapGenerator.

1
2
3
4
5
6
7
8
9
10
11
12
var node = new SourceNode(1, 2, "a.js", [
  new SourceNode(3, 4, "b.js", "uno"),
  "dos",
  [
    "tres",
    new SourceNode(5, 6, "c.js", "quatro")
  ]
]);

node.toStringWithSourceMap({ file: "my-output-file.js" })
// { code: 'unodostresquatro',
//   map: [object SourceMapGenerator] }

Ontwikkelingsgids

Basismodule

ingebouwde objecten

gemeenschapsmodule