Tolles Community-Modul
  1. Titelseite
  2. Community-Modul
  3. Quellkarte

Quellkarte

Build-Status

NPM

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

Verwendung mit Node

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ührlicher Leitfaden: 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

Rufen Sie einen Verweis auf das Modul ab:

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 analysierte Quellkarte 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 der Verwendung SourceMapConsumeraußerhalb von node.js, beispielsweise im Web, muss es wissen, von welcher URL es geladen werden soll lib/mappings.wasm. Sie müssen es durch einen Aufruf informieren initialize, bevor Sie SourceMapConsumers erstellen.

Das Optionsobjekt hat die folgenden Eigenschaften:

  • "lib/mappings.wasm": A, das Stringdie URL der lib/mappings.wasmDatei 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 rohe Quellzuordnung (entweder als String, der JSON.parse„d“ sein kann, oder als Objekt). Gemäß der Spezifikation haben Quellzuordnungen die folgenden Attribute:

  • 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, mit dem diese Quellkarte verknüpft ist.

Das Versprechen des erstellten Quellkartenkonsumenten wird zurückgegeben.

Wenn die SourceMapConsumernicht mehr verwendet wird, müssen Sie ihre destroyMethode aufrufen.

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

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

SourceMapConsumer.with

Erstellen Sie ein neues SourceMapConsumerfrom rawSourceMapand ( Einzelheiten sourceMapUrl finden Sie im Konstruktor. Rufen Sie dann den mit dem neu erstellten Verbraucher auf, warten Sie , bis er abgeschlossen ist , rufen Sie den Verbraucher auf und geben Sie den Rückgabewert zurück.SourceMapConsumerasync function f(SourceMapConsumer) -> Tfdestroyf

Sie dürfen den Consumer nach fAbschluss nicht mehr verwenden!

Wenn Sie verwenden with, müssen Sie nicht daran denken, destroyden Verbraucher manuell aufzurufen, da er nach Abschluss automatisch aufgerufen 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 diesem Quellkartenverbraucher zugeordneten WASM-Daten frei, die manuell verwaltet werden.

1
consumer.destroy();

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

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(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 basieren auf 1 (beachten Sie, dass die zugrunde liegende Quellkartenspezifikation Zeilennummern auf Nullbasis 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_BOUNDoder SourceMapConsumer.LEAST_UPPER_BOUND. Gibt an, ob das nächstgelegene Element zurückgegeben werden soll, das kleiner bzw. größer als das gesuchte Element ist, wenn das genaue Element nicht gefunden werden kann. Standardmäßig ist 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 bereitgestellten 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ü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. Andernfalls wird zurückgegeben alle Zuordnungen, die der angegebenen Zeile und entweder der gesuchten Spalte oder der nächstliegenden 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 es wird ein Array von Objekten zurückgegeben, jedes mit den folgenden Eigenschaften:

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

Gibt „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ückgibt true, ist sie für jede Quelle in consumer.sourceContentFor(s)erfolgreich .sconsumer.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 bereitgestellte 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 stattdessen trueden zweiten Parameter, der nullzurü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, 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 jeder Zuordnung aufgerufen wird. Zuordnungen haben die Form{ source, generatedLine, generatedColumn, originalLine, originalColumn, name }

  • context: Optional. Wenn angegeben, ist dieses Objekt der Wert jedes this Aufrufs callback.

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

  • skipValidation: Optional. Wenn true, wird die Validierung von Zuordnungen beim Hinzufügen deaktiviert. Dies kann die Leistung verbessern, sollte aber als letztes Mittel mit Bedacht verwendet werden. Selbst dann sollte man die Verwendung dieses Flags 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.

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

SourceMapGenerator.prototype.addMapping(mapping)

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

  • sourceFiledie URL der ursprünglichen Quelldatei.

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

  • sourceMapConsumer: Die anzuwendende SourceMap.

  • sourceFile: Optional. Der Dateiname der Quelldatei. Wenn er weggelassen wird, 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. Wenn dies der Fall ist, müssen diese relativen Quellpfade relativ zur SourceMap neu geschrieben werden.

    Wenn es weggelassen wird, wird davon ausgegangen, dass sich beide SourceMaps im selben Verzeichnis befinden und daher kein Umschreiben erforderlich ist. (Die Bereitstellung '.'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, über Interpolation und/oder Verkettung von Snippets des generierten JavaScript-Quellcodes zu abstrahieren und gleichzeitig die zwischen diesen Snippets und dem ursprünglichen Quellcode verknüpften Zeilen- und Spalteninformationen beizubehalten. Dies ist nützlich als endgültige Zwischendarstellung, die ein Compiler vor der Ausgabe verwenden könnte 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 wird.

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

  • name: Optional. Der ursprüngliche Bezeichner.

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 einen SourceMapConsumer.

  • code:Der generierte Code

  • sourceMapConsumerDie SourceMap für den generierten Code

  • relativePathDer optionale Pfad, zu dem relative Quellen sourceMapConsumer relativ 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 des generierten JS-Codes, 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)

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

  • chunk: Ein String-Snippet des generierten JS-Codes, 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 SourceMapFeld hinzugefügt 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 durch den Baum der JS-Snippets in diesem Knoten und seinen untergeordneten Knoten. Die Walking-Funktion wird einmal für jeden JS-Snippet aufgerufen und erhält diesen Snippet und die Zeilen-/Spaltenposition seiner ursprünglichen zugehörigen Quelle.

  • 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 durch den Baum der SourceNodes. Die Walking-Funktion wird für jeden Quelldateiinhalt aufgerufen und erhält 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.joinmit Ausnahme von SourceNodes. Fügt das Trennzeichen zwischen jedem untergeordneten Knoten 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, Ersatz)

Rufen Sie String.prototype.replaceden Quellausschnitt ganz rechts auf. Nützlich zum Entfernen von Leerraum am Ende eines Quellknotens 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 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 sowie einen SourceMapGenerator zurück, 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] }
© Copyright 2012-2024 fibjs.org | Unterstützen Sie uns