Fantastisches Community-Modul

Quellkarte

Build-Status

NPM

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

Mit Knoten verwenden

1
$ npm install source-map

Verwendung im Web

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 mit 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

Erhalten Sie 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 SourceMapConsumer Instanz stellt eine analysierte SourceMapConsumer dar, die wir nach Informationen zu den ursprünglichen SourceMapConsumer abfragen können, indem wir ihr eine SourceMapConsumer in der generierten Quelle SourceMapConsumer .

SourceMapConsumer.initialize (Optionen)

Wenn Sie SourceMapConsumer außerhalb von node.js verwenden, z. B. im Web, muss bekannt sein, von welcher URL lib/mappings.wasm geladen werden soll. Sie müssen dies durch Aufrufen von initialize mitteilen, bevor Sie SourceMapConsumer .

Das Optionsobjekt hat die folgenden Eigenschaften:

  • "lib/mappings.wasm" : Ein String , der die URL der Datei lib/mappings.wasm enthält.
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 JSON.parse (entweder als Zeichenfolge, die JSON.parse , oder als Objekt). Gemäß der Spezifikation weisen JSON.parse die folgenden Attribute auf:

  • version : Welcher Version der Quellkartenspezifikation folgt diese Karte?

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

  • names : Ein Array von Bezeichnern, auf die durch einzelne 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, dem diese Quellzuordnung zugeordnet ist.

Das Versprechen des konstruierten Quellkartenkonsumenten wird zurückgegeben.

Wenn der SourceMapConsumer nicht mehr verwendet wird, müssen Sie seine destroy Methode aufrufen.

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

Alternativ können Sie SourceMapConsumer.with , um zu vermeiden, dass Sie daran denken müssen, destroy aufzurufen.

SourceMapConsumer.with

Konstruieren Sie einen neuen neuen SourceMapConsumer aus rawSourceMap und sourceMapUrl ( rawSourceMap sourceMapUrl Sie unter Der SourceMapConsumer Konstruktor. sourceMapUrl Sie dann die SourceMapConsumer async function f(SourceMapConsumer) -> T mit dem neu erstellten Consumer auf, warten Sie, bis f abgeschlossen ist, rufen Sie destroy ON The Consumer auf und geben Sie f Rückgabewert.

Sie dürfen den Verbraucher nach Abschluss von f nicht mehr benutzen!

Bei Verwendung von with müssen Sie nicht daran denken, den Benutzer manuell auf destroy zu rufen, da er nach Abschluss von f automatisch aufgerufen wird.

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 zugehörigen Wasm-Daten des Quellkarten-Verbrauchers frei, die manuell verwaltet werden.

1
consumer.destroy();

Alternativ können Sie SourceMapConsumer.with , um zu vermeiden, dass Sie daran denken müssen, destroy aufzurufen.

SourceMapConsumer.prototype.computeColumnSpans ()

Berechnen Sie die letzte Spalte für jede generierte Zuordnung. 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 (generatePosition)

Gibt die ursprünglichen Quell-, Zeilen- und Spalteninformationen für die angegebenen 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. Die Zeilennummern in dieser Bibliothek basieren auf 1 (beachten Sie, dass die zugrunde liegende Quellkartenspezifikation 0-basierte Zeilennummern verwendet - diese Bibliothek übernimmt die Übersetzung).

  • column : Die Spaltennummer in der generierten Quelle. Die Spaltennummern in dieser Bibliothek basieren auf 0.

  • bias : Entweder SourceMapConsumer.GREATEST_LOWER_BOUND oder SourceMapConsumer.LEAST_UPPER_BOUND . Gibt an, ob das nächste Element zurückgegeben werden soll, das kleiner oder größer als das SourceMapConsumer.GREATEST_LOWER_BOUND , wenn das genaue Element nicht gefunden werden kann. Der SourceMapConsumer.GREATEST_LOWER_BOUND .

und ein Objekt wird 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 : Die ursprüngliche Kennung 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 ursprünglich angegebenen 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 basiert auf 1.

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

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

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

  • 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ünglich bereitgestellte 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. Andernfalls wird zurückgegeben 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 basiert auf 1.

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

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

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

  • 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, andernfalls false.

Mit anderen Worten, wenn diese Methode zurückkehrt true , dann consumer.sourceContentFor(s) wird für jede Quelle gelingen s in 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 Quellinhalt für die angegebene Quelle nicht gefunden wird, wird ein Fehler ausgegeben. Übergeben Sie optional true als zweiten Parameter, um stattdessen null .

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, Reihenfolge)

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 bei jedem Aufruf des callback der Wert this .

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

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

  • skipValidation : Optional. Wenn true , wird die Validierung von Zuordnungen beim Hinzufügen deaktiviert. Dies kann die Leistung verbessern, sollte jedoch als letztes Mittel mit Diskretion verwendet werden. Selbst dann sollte die Verwendung dieses Flags beim Ausführen von Tests nach Möglichkeit vermieden werden.

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 einen neuen SourceMapGenerator aus einer vorhandenen SourceMapConsumer Instanz.

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

SourceMapGenerator.prototype.addMapping (Zuordnung)

Fügen Sie eine einzelne Zuordnung von der ursprünglichen Quellzeile und -spalte zur Zeile und Spalte der generierten Quelle für diese zu erstellende Quellzuordnung 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 Token-Name 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 Originalquelldatei fest.

  • sourceFile Die URL der ursprünglichen Quelldatei.

  • sourceContent der 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. Jede Zuordnung zur bereitgestellten Quelldatei wird mit der mitgelieferten SourceMap neu geschrieben. Hinweis: Die Auflösung für die resultierenden Zuordnungen ist das Minimum dieser Zuordnung und der mitgelieferten Zuordnung.

  • sourceMapConsumer : Die anzuwendende SourceMap.

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

  • sourceMapPath : Optional. Der Verzeichnisname 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. In diesem Fall müssen diese relativen Quellpfade relativ zur SourceMap neu geschrieben werden.

    Wenn dies weggelassen wird, wird davon ausgegangen, dass sich beide SourceMaps im selben Verzeichnis befinden und daher nicht neu geschrieben werden müssen. (Die Angabe von '.' 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 bieten eine Möglichkeit, das Interpolieren und / oder Verketten von Snippets des generierten JavaScript-Quellcodes zu abstrahieren, während die zwischen diesen Snippets und dem ursprünglichen Quellcode verknüpften Zeilen- und Spalteninformationen beibehalten werden. Dies ist nützlich als endgültige Zwischendarstellung, die ein Compiler möglicherweise vor der Ausgabe verwendet die generierte JS- und Quellkarte.

neuer SourceNode ([Zeile, Spalte, Quelle [, Block [, 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 ist.

  • chunk : Optional. Wird sofort an 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

  • relativePath Der optionale Pfad, zu dem relative Quellen in sourceMapConsumer relativ sourceMapConsumer sollten.

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 des generierten JS-Codes, eine andere Instanz von SourceNode oder 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 einen Teil des generierten JS voran.

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

SourceNode.prototype.setSourceContent (sourceFile, sourceContent)

SourceMap den sourcesContent für eine Quelldatei fest. Dieser wird der SourceMap im Feld SourceMap sourcesContent .

  • 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 untergeordneten Knoten. Die Walking-Funktion wird einmal für jedes JS-Snippet aufgerufen und an dieses Snippet und die Zeilen- / Spaltenposition der ursprünglich zugeordneten Quelle übergeben.

  • fn : Die Traversalfunktion.
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 von SourceNodes. Die Walking-Funktion wird für jeden Quelldateiinhalt aufgerufen und übergibt den Dateinamen und den Quellinhalt.

  • fn : Die Traversalfunktion.
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 Array.prototype.join Ausnahme von SourceNodes. Fügt das Trennzeichen zwischen den Array.prototype.join Elementen dieses Quellknotens ein.

  • sep : Der Separator.
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, Ersatz)

Rufen Sie String.prototype.replace im Quell-Snippet ganz rechts auf. Nützlich zum Trimmen von Leerzeichen vom Ende eines String.prototype.replace usw.

  • pattern : Das zu ersetzende Muster.

  • replacement : Das Ding, durch das das Muster ersetzt werden soll.

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

SourceNode.prototype.toString ()

Gibt die Zeichenfolgendarstellung dieses Quellknotens zurück. Geht über den Baum und verkettet alle verschiedenen Snippets zu einer Zeichenfolge.

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 sowie einen SourceMapGenerator zurück, der alle Zuordnungen zwischen der generierten und der ursprünglichen Quelle enthält.

Die Argumente sind die gleichen wie für den 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] }