Tolles Community-Modul

Quellkarte

Build-Status

NPM

Dies ist eine Bibliothek zum Generieren und Verwenden des hier beschriebenen Quellkartenformats .

Verwendung mit Knoten

1
$ npm install source-map

Im Web verwenden

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>

Inhaltsverzeichnis

Beispiele

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

Ausführliche Anleitung: Kompilieren in JavaScript und Debuggen mit Quellzuordnungen

Mit SourceNode (High-Level-API)

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] }

Mit SourceMapGenerator (Low-Level-API)

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

Holen Sie sich einen Verweis auf das Modul:

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

Eine SourceMapConsumerInstanz stellt eine geparste Quellzuordnung dar, die wir nach Informationen über die ursprünglichen Dateipositionen abfragen können, indem wir ihr eine Dateiposition in der generierten Quelle zuweisen.

SourceMapConsumer.initialize(Optionen)

Bei Verwendung SourceMapConsumeraußerhalb von node.js, beispielsweise im Web, muss es wissen, von welcher URL geladen werden soll lib/mappings.wasm. Sie müssen es durch Aufrufen informieren, initializebevor Sie SourceMapConsumers erstellen.

Das Optionsobjekt hat die folgenden Eigenschaften:

  • "lib/mappings.wasm": A Stringenthält die URL der lib/mappings.wasmDatei.
1 2 3
sourceMap.SourceMapConsumer.initialize({ "lib/mappings.wasm": "https://example.com/source-map/lib/mappings.wasm" });

neuer SourceMapConsumer(rawSourceMap)

Der einzige Parameter ist die rohe Quellzuordnung (entweder als Zeichenfolge, die be'd sein kann JSON.parse, oder als Objekt). Laut Spezifikation haben Quellzuordnungen die folgenden Attribute:

  • version: Welche Version der Quell-Map-Spezifikation diese Map befolgt.

  • sources: Ein Array von URLs zu den ursprünglichen Quelldateien.

  • names: Ein Array von Bezeichnern, auf die durch individuelle Zuordnungen verwiesen werden kann.

  • sourceRoot: Optional Der URL-Stamm, von dem alle Quellen relativ sind.

  • sourcesContent: Optional Ein Array mit Inhalten der ursprünglichen Quelldateien.

  • mappings: Eine Zeichenfolge von base64-VLQs, die die tatsächlichen Zuordnungen enthalten.

  • file: Optional Der generierte Dateiname, mit dem diese Quellzuordnung verknüpft ist.

Das Promise des konstruierten Quellkartenverbrauchers wird zurückgegeben.

Wenn der SourceMapConsumernicht mehr verwendet wird, müssen Sie seine destroyMethode aufrufen .

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

Alternativ können Sie auch verwenden SourceMapConsumer.with, um nicht daran denken zu müssen, anzurufen destroy.

SourceMapConsumer.with

Konstruieren Sie ein neues SourceMapConsumerfrom rawSourceMapund sourceMapUrl ( SourceMapConsumerDetails finden Sie im Konstruktor. Rufen Sie dann das async function f(SourceMapConsumer) -> Tmit dem neu konstruierten Consumer auf, warten Sie auf fden Abschluss, rufen Sie destroyden Consumer auf und geben Sie den Rückgabewert von fzurück.

Sie dürfen den Verbraucher nach fAbschluss nicht verwenden !

Wenn Sie verwenden with, müssen Sie nicht daran denken, destroyden Verbraucher manuell anzurufen , da er nach Abschluss automatisch angerufen wird 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()

Geben Sie die zugeordneten Wasm-Daten dieses Quellkartenverbrauchers frei, die manuell verwaltet werden.

1
consumer.destroy();

Alternativ können Sie auch verwenden SourceMapConsumer.with, um nicht daran denken zu müssen, anzurufen destroy.

SourceMapConsumer.prototype.computeColumnSpans()

Berechnen Sie die letzte Spalte für jedes generierte Mapping. Die letzte Spalte ist inklusive.

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(generatedPosition)

Gibt die ursprünglichen Quell-, Zeilen- und Spalteninformationen für die bereitgestellten Zeilen- und Spaltenpositionen der generierten Quelle zurück. Das einzige Argument ist ein Objekt mit den folgenden Eigenschaften:

  • line: Die Zeilennummer in der generierten Quelle Zeilennummern in dieser Bibliothek sind 1-basiert (beachten Sie, dass die zugrunde liegende Quellzuordnungsspezifikation 0-basierte Zeilennummern verwendet - diese Bibliothek übernimmt die Übersetzung).

  • column: Die Spaltennummer in der generierten Quelle Spaltennummern in dieser Bibliothek sind 0-basiert.

  • bias: Entweder SourceMapConsumer.GREATEST_LOWER_BOUNDoder SourceMapConsumer.LEAST_UPPER_BOUNDGibt an, ob das nächste Element zurückgegeben wird, das kleiner oder größer als das gesuchte ist, wenn das genaue Element nicht gefunden werden kann SourceMapConsumer.GREATEST_LOWER_BOUND.

und es wird ein Objekt mit den folgenden Eigenschaften zurückgegeben:

  • source: Die ursprüngliche Quelldatei oder null, wenn diese Informationen nicht verfügbar sind.

  • line: Die Zeilennummer in der Originalquelle oder null, wenn diese Informationen nicht verfügbar sind.Die Zeilennummer basiert auf 1.

  • column: Die Spaltennummer in der Originalquelle oder null, wenn diese Informationen nicht verfügbar sind. Die Spaltennummer basiert auf 0.

  • name: Der ursprüngliche Bezeichner oder null, wenn diese Informationen nicht verfügbar sind.

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(originalPosition)

Gibt die generierten Zeilen- und Spalteninformationen für die bereitgestellten ursprünglichen Quell-, Zeilen- und Spaltenpositionen zurück. Das einzige Argument ist ein Objekt mit den folgenden Eigenschaften:

  • source: Der Dateiname der Originalquelle.

  • line: Die Zeilennummer in der Originalquelle Die Zeilennummer ist 1-basiert.

  • column: Die Spaltennummer in der Originalquelle Die Spaltennummer basiert auf 0.

und es wird ein Objekt mit den folgenden Eigenschaften zurückgegeben:

  • line: Die Zeilennummer in der generierten Quelle oder null. Die Zeilennummer ist 1-basiert.

  • column: Die Spaltennummer in der generierten Quelle oder null. Die Spaltennummer basiert auf 0.

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

SourceMapConsumer.prototype.allGeneratedPositionsFor(originalPosition)

Gibt alle generierten Zeilen- und Spalteninformationen für die ursprüngliche Quelle, Zeile und Spalte zurück. Wenn keine Spalte angegeben ist, werden alle Zuordnungen zurückgegeben, die entweder der gesuchten Zeile oder der nächstgelegenen Zeile mit Zuordnungen entsprechen alle Zuordnungen, die der angegebenen Zeile und entweder der gesuchten Spalte oder der nächstgelegenen Spalte mit Offsets entsprechen.

Das einzige Argument ist ein Objekt mit den folgenden Eigenschaften:

  • source: Der Dateiname der Originalquelle.

  • line: Die Zeilennummer in der Originalquelle Die Zeilennummer ist 1-basiert.

  • column: Optional. Die Spaltennummer in der Originalquelle. Die Spaltennummer basiert auf 0.

und ein Array von Objekten wird zurückgegeben, jedes mit den folgenden Eigenschaften:

  • line: Die Zeilennummer in der generierten Quelle oder null. Die Zeilennummer ist 1-basiert.

  • column: Die Spaltennummer in der generierten Quelle oder null. Die Spaltennummer basiert auf 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()

Geben Sie true zurück, wenn wir den eingebetteten Quellinhalt für jede in der Quellzuordnung aufgeführte Quelle haben, ansonsten false.

Mit anderen Worten, wenn diese Methode zurückgibt true, consumer.sourceContentFor(s)wird für jede Quelle sin erfolgreich sein consumer.sources.

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

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

Gibt den ursprünglichen Quellinhalt für die angegebene Quelle zurück. Das einzige Argument ist die URL der ursprünglichen Quelldatei.

Wenn der trueQuellinhalt für die angegebene Quelle nicht gefunden wird, wird ein Fehler ausgegeben. Übergeben Sie optional als zweiten Parameter, der nullstattdessen zurückgegeben werden soll.

1 2 3 4 5 6 7 8 9 10 11
consumer.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(Rückruf, Kontext, Auftrag)

Durchlaufen Sie jede Zuordnung zwischen einer ursprünglichen Quelle/Zeile/Spalte und einer generierten Zeile/Spalte in dieser Quellzuordnung.

  • callback: Die Funktion, die bei jedem Mapping aufgerufen wird Mappings haben die Form { source, generatedLine, generatedColumn, originalLine, originalColumn, name }

  • context: Optional.Wenn angegeben, ist dieses Objekt der Wert bei this jedem callbackAufruf.

  • order: Entweder SourceMapConsumer.GENERATED_ORDERoder SourceMapConsumer.ORIGINAL_ORDER.Gibt an, ob Sie die Zuordnungen durchlaufen möchten, sortiert nach der Zeilen-/Spaltenreihenfolge der generierten Datei bzw. der Quell-/Zeilen-/Spaltenreihenfolge des Originals 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

Eine Instanz des SourceMapGenerator stellt eine Quellzuordnung dar, die inkrementell erstellt wird.

neuer SourceMapGenerator([startOfSourceMap])

Sie können ein Objekt mit den folgenden Eigenschaften übergeben:

  • file: Der Dateiname der generierten Quelle, mit der diese Quellzuordnung verknüpft ist.

  • sourceRoot: Ein Stamm für alle relativen URLs in dieser Quellzuordnung.

  • skipValidation: Optional. Wenn truedeaktiviert die Validierung von Mappings, wenn diese hinzugefügt werden. Dies kann die Leistung verbessern, sollte jedoch als letztes Mittel mit Bedacht verwendet werden. Selbst dann sollte man dieses Flag beim Ausführen von Tests nach Möglichkeit vermeiden.

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

SourceMapGenerator.fromSourceMap(sourceMapConsumer)

Erstellt eine neue SourceMapGeneratoraus einer vorhandenen SourceMapConsumerInstanz.

  • sourceMapConsumer Die SourceMap.
1
var generator = sourceMap.SourceMapGenerator.fromSourceMap(consumer);

SourceMapGenerator.prototype.addMapping(Mapping)

Fügen Sie der Zeile und Spalte der generierten Quelle für diese zu erstellende Quellzuordnung eine einzelne Zuordnung aus der ursprünglichen Quellzeile und -spalte hinzu. Das Zuordnungsobjekt sollte die folgenden Eigenschaften haben:

  • generated: Ein Objekt mit den generierten Zeilen- und Spaltenpositionen.

  • original: Ein Objekt mit den ursprünglichen Zeilen- und Spaltenpositionen.

  • source: Die ursprüngliche Quelldatei (relativ zum sourceRoot).

  • name: Ein optionaler ursprünglicher Tokenname für diese Zuordnung.

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

SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)

Legen Sie den Quellinhalt für eine ursprüngliche Quelldatei fest.

  • sourceFile die URL der ursprünglichen Quelldatei.

  • sourceContent den Inhalt der Quelldatei.

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

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

Wendet eine SourceMap für eine Quelldatei auf die SourceMap an. Jedes Mapping auf die bereitgestellte Quelldatei wird mit der bereitgestellten SourceMap neu geschrieben. Hinweis: Die Auflösung für die resultierenden Mappings ist das Minimum dieser Map und der bereitgestellten Map

  • sourceMapConsumer: Die anzuwendende SourceMap.

  • sourceFile: Optional. Der Dateiname der Quelldatei. Wenn nicht angegeben, wird sourceMapConsumer.file verwendet, falls vorhanden. Andernfalls wird ein Fehler ausgegeben.

  • sourceMapPath: Optional. Der Dirname des Pfads zur anzuwendenden SourceMap. Wenn relativ, ist er relativ zur SourceMap.

    Dieser Parameter wird benötigt, wenn sich die beiden SourceMaps nicht im selben Verzeichnis befinden und die anzuwendende SourceMap relative Quellpfade enthält.Wenn ja, müssen diese relativen Quellpfade relativ zur SourceMap neu geschrieben werden.

    Falls weggelassen, wird davon ausgegangen, dass sich beide SourceMaps im selben Verzeichnis befinden und somit kein Umschreiben erforderlich ist (Lieferung '.'hat den gleichen Effekt).

SourceMapGenerator.prototype.toString()

Rendert die generierte Quellzuordnung in eine Zeichenfolge.

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

SourceNode

SourceNodes stellen eine Möglichkeit dar, Snippets von generiertem JavaScript-Quellcode zu abstrahieren und/oder zu verketten, während die Zeilen- und Spalteninformationen zwischen diesen Snippets und dem ursprünglichen Quellcode beibehalten werden.Dies ist nützlich als endgültige Zwischendarstellung, die ein Compiler vor der Ausgabe verwenden könnte die generierte JS- und Quellzuordnung.

new SourceNode([Zeile, Spalte, Quelle[, Chunk[, Name]]])

  • line: Die ursprüngliche Zeilennummer, die diesem Quellknoten zugeordnet ist, oder null, wenn sie keiner ursprünglichen Zeile zugeordnet ist. Die Zeilennummer basiert auf 1.

  • column: Die ursprüngliche Spaltennummer, die diesem Quellknoten zugeordnet ist, oder null, wenn sie keiner ursprünglichen Spalte zugeordnet ist. Die Spaltennummer basiert auf 0.

  • source: Der Dateiname der Originalquelle; null, wenn kein Dateiname angegeben wird.

  • chunk: Optional, wird sofort an übergeben SourceNode.prototype.add, siehe unten.

  • name: Optional Die ursprüngliche Kennung.

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[, relativePath])

Erstellt einen SourceNode aus generiertem Code und einem SourceMapConsumer.

  • code: Der generierte Code

  • sourceMapConsumer Die SourceMap für den generierten Code

  • relativePathDer optionale Pfad, zu dem relative Quellen relativ sourceMapConsumer sein sollen.

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)

Fügen Sie diesem Quellknoten einen Teil des generierten JS hinzu.

  • chunk: Ein String-Snippet von generiertem JS-Code, eine andere Instanz von SourceNodeoder ein Array, in dem jedes Mitglied eines dieser Dinge ist.
1 2 3
node.add(" + "); node.add(otherNode); node.add([leftHandOperandNode, " + ", rightHandOperandNode]);

SourceNode.prototype.prepend(Chunk)

Stellen Sie diesem Quellknoten ein Stück generierten JS voran.

  • chunk: Ein String-Snippet von generiertem JS-Code, eine andere Instanz von SourceNodeoder ein Array, in dem jedes Mitglied eines dieser Dinge ist.
1
node.prepend("/** Build Id: f783haef86324gf **/\n\n");

SourceNode.prototype.setSourceContent(sourceFile, sourceContent)

Legen Sie den Quellinhalt für eine Quelldatei fest. Dieser wird dem SourceMapim sourcesContentFeld hinzugefügt .

  • sourceFile: Der Dateiname der Quelldatei

  • sourceContent: Der Inhalt der Quelldatei

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

SourceNode.prototype.walk(fn)

Gehen Sie über den Baum der JS-Snippets in diesem Knoten und seinen Kindern.Die Walking-Funktion wird einmal für jeden JS-Snippet aufgerufen und es wird dieserSnippet und die Position der Zeile/Spalte der ursprünglichen zugeordneten Quelle übergeben.

  • fn: Die Traversierungsfunktion.
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)

Gehen Sie über den Baum der SourceNodes.Die Walking-Funktion wird für jeden Quelldateiinhalt aufgerufen und bekommt den Dateinamen und den Quellinhalt übergeben.

  • fn: Die Traversierungsfunktion.
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)

Wie mit Array.prototype.joinAusnahme von SourceNodes.Fügt das Trennzeichen zwischen jedem Kind dieses Quellknotens ein.

  • sep: Das Trennzeichen.
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(Muster, Ersetzung)

Rufen Sie String.prototype.replacedas Quell-Snippet ganz rechts auf. Nützlich, um Leerräume am Ende eines Quellknotens usw. zu entfernen.

  • pattern: Das zu ersetzende Muster.

  • replacement: Das Ding, mit dem das Muster ersetzt wird.

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

SourceNode.prototype.toString()

Gibt die String-Darstellung dieses Quellknotens zurück Geht über den Baum und verkettet alle verschiedenen Snippets zu einem String.

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])

Gibt die Zeichenfolgendarstellung dieses Baums von Quellknoten zurück, plus einen SourceMapGenerator, der alle Zuordnungen zwischen den generierten und den ursprünglichen Quellen enthält.

Die Argumente sind die gleichen wie bei 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] }