You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
369 lines
13 KiB
369 lines
13 KiB
// Type definitions for source-map 0.7
|
|
// Project: https://github.com/mozilla/source-map
|
|
// Definitions by: Morten Houston Ludvigsen <https://github.com/MortenHoustonLudvigsen>,
|
|
// Ron Buckton <https://github.com/rbuckton>,
|
|
// John Vilk <https://github.com/jvilk>
|
|
// Definitions: https://github.com/mozilla/source-map
|
|
export type SourceMapUrl = string;
|
|
|
|
export interface StartOfSourceMap {
|
|
file?: string;
|
|
sourceRoot?: string;
|
|
skipValidation?: boolean;
|
|
}
|
|
|
|
export interface RawSourceMap {
|
|
version: number;
|
|
sources: string[];
|
|
names: string[];
|
|
sourceRoot?: string;
|
|
sourcesContent?: string[];
|
|
mappings: string;
|
|
file: string;
|
|
}
|
|
|
|
export interface RawIndexMap extends StartOfSourceMap {
|
|
version: number;
|
|
sections: RawSection[];
|
|
}
|
|
|
|
export interface RawSection {
|
|
offset: Position;
|
|
map: RawSourceMap;
|
|
}
|
|
|
|
export interface Position {
|
|
line: number;
|
|
column: number;
|
|
}
|
|
|
|
export interface NullablePosition {
|
|
line: number | null;
|
|
column: number | null;
|
|
lastColumn: number | null;
|
|
}
|
|
|
|
export interface MappedPosition {
|
|
source: string;
|
|
line: number;
|
|
column: number;
|
|
name?: string;
|
|
}
|
|
|
|
export interface NullableMappedPosition {
|
|
source: string | null;
|
|
line: number | null;
|
|
column: number | null;
|
|
name: string | null;
|
|
}
|
|
|
|
export interface MappingItem {
|
|
source: string;
|
|
generatedLine: number;
|
|
generatedColumn: number;
|
|
originalLine: number;
|
|
originalColumn: number;
|
|
name: string;
|
|
}
|
|
|
|
export interface Mapping {
|
|
generated: Position;
|
|
original: Position;
|
|
source: string;
|
|
name?: string;
|
|
}
|
|
|
|
export interface CodeWithSourceMap {
|
|
code: string;
|
|
map: SourceMapGenerator;
|
|
}
|
|
|
|
export interface SourceMapConsumer {
|
|
/**
|
|
* Compute the last column for each generated mapping. The last column is
|
|
* inclusive.
|
|
*/
|
|
computeColumnSpans(): void;
|
|
|
|
/**
|
|
* Returns the original source, line, and column information for the generated
|
|
* source's line and column positions provided. The only argument is an object
|
|
* with the following properties:
|
|
*
|
|
* - line: The line number in the generated source.
|
|
* - column: The column number in the generated source.
|
|
* - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
|
|
* 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
|
|
* closest element that is smaller than or greater than the one we are
|
|
* searching for, respectively, if the exact element cannot be found.
|
|
* Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
|
|
*
|
|
* and an object is returned with the following properties:
|
|
*
|
|
* - source: The original source file, or null.
|
|
* - line: The line number in the original source, or null.
|
|
* - column: The column number in the original source, or null.
|
|
* - name: The original identifier, or null.
|
|
*/
|
|
originalPositionFor(generatedPosition: Position & { bias?: number }): NullableMappedPosition;
|
|
|
|
/**
|
|
* Returns the generated line and column information for the original source,
|
|
* line, and column positions provided. The only argument is an object with
|
|
* the following properties:
|
|
*
|
|
* - source: The filename of the original source.
|
|
* - line: The line number in the original source.
|
|
* - column: The column number in the original source.
|
|
* - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
|
|
* 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
|
|
* closest element that is smaller than or greater than the one we are
|
|
* searching for, respectively, if the exact element cannot be found.
|
|
* Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
|
|
*
|
|
* and an object is returned with the following properties:
|
|
*
|
|
* - line: The line number in the generated source, or null.
|
|
* - column: The column number in the generated source, or null.
|
|
*/
|
|
generatedPositionFor(originalPosition: MappedPosition & { bias?: number }): NullablePosition;
|
|
|
|
/**
|
|
* Returns all generated line and column information for the original source,
|
|
* line, and column provided. If no column is provided, returns all mappings
|
|
* corresponding to a either the line we are searching for or the next
|
|
* closest line that has any mappings. Otherwise, returns all mappings
|
|
* corresponding to the given line and either the column we are searching for
|
|
* or the next closest column that has any offsets.
|
|
*
|
|
* The only argument is an object with the following properties:
|
|
*
|
|
* - source: The filename of the original source.
|
|
* - line: The line number in the original source.
|
|
* - column: Optional. the column number in the original source.
|
|
*
|
|
* and an array of objects is returned, each with the following properties:
|
|
*
|
|
* - line: The line number in the generated source, or null.
|
|
* - column: The column number in the generated source, or null.
|
|
*/
|
|
allGeneratedPositionsFor(originalPosition: MappedPosition): NullablePosition[];
|
|
|
|
/**
|
|
* Return true if we have the source content for every source in the source
|
|
* map, false otherwise.
|
|
*/
|
|
hasContentsOfAllSources(): boolean;
|
|
|
|
/**
|
|
* Returns the original source content. The only argument is the url of the
|
|
* original source file. Returns null if no original source content is
|
|
* available.
|
|
*/
|
|
sourceContentFor(source: string, returnNullOnMissing?: boolean): string | null;
|
|
|
|
/**
|
|
* Iterate over each mapping between an original source/line/column and a
|
|
* generated line/column in this source map.
|
|
*
|
|
* @param callback
|
|
* The function that is called with each mapping.
|
|
* @param context
|
|
* Optional. If specified, this object will be the value of `this` every
|
|
* time that `aCallback` is called.
|
|
* @param order
|
|
* Either `SourceMapConsumer.GENERATED_ORDER` or
|
|
* `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
|
|
* iterate over the mappings sorted by the generated file's line/column
|
|
* order or the original's source/line/column order, respectively. Defaults to
|
|
* `SourceMapConsumer.GENERATED_ORDER`.
|
|
*/
|
|
eachMapping(callback: (mapping: MappingItem) => void, context?: any, order?: number): void;
|
|
/**
|
|
* Free this source map consumer's associated wasm data that is manually-managed.
|
|
* Alternatively, you can use SourceMapConsumer.with to avoid needing to remember to call destroy.
|
|
*/
|
|
destroy(): void;
|
|
}
|
|
|
|
export interface SourceMapConsumerConstructor {
|
|
prototype: SourceMapConsumer;
|
|
|
|
GENERATED_ORDER: number;
|
|
ORIGINAL_ORDER: number;
|
|
GREATEST_LOWER_BOUND: number;
|
|
LEAST_UPPER_BOUND: number;
|
|
|
|
new (rawSourceMap: RawSourceMap, sourceMapUrl?: SourceMapUrl): Promise<BasicSourceMapConsumer>;
|
|
new (rawSourceMap: RawIndexMap, sourceMapUrl?: SourceMapUrl): Promise<IndexedSourceMapConsumer>;
|
|
new (rawSourceMap: RawSourceMap | RawIndexMap | string, sourceMapUrl?: SourceMapUrl): Promise<BasicSourceMapConsumer | IndexedSourceMapConsumer>;
|
|
|
|
/**
|
|
* Create a BasicSourceMapConsumer from a SourceMapGenerator.
|
|
*
|
|
* @param sourceMap
|
|
* The source map that will be consumed.
|
|
*/
|
|
fromSourceMap(sourceMap: SourceMapGenerator, sourceMapUrl?: SourceMapUrl): Promise<BasicSourceMapConsumer>;
|
|
|
|
/**
|
|
* Construct a new `SourceMapConsumer` from `rawSourceMap` and `sourceMapUrl`
|
|
* (see the `SourceMapConsumer` constructor for details. Then, invoke the `async
|
|
* function f(SourceMapConsumer) -> T` with the newly constructed consumer, wait
|
|
* for `f` to complete, call `destroy` on the consumer, and return `f`'s return
|
|
* value.
|
|
*
|
|
* You must not use the consumer after `f` completes!
|
|
*
|
|
* By using `with`, you do not have to remember to manually call `destroy` on
|
|
* the consumer, since it will be called automatically once `f` completes.
|
|
*
|
|
* ```js
|
|
* 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);
|
|
* ```
|
|
*/
|
|
with<T>(rawSourceMap: RawSourceMap | RawIndexMap | string, sourceMapUrl: SourceMapUrl | null | undefined, callback: (consumer: BasicSourceMapConsumer | IndexedSourceMapConsumer) => Promise<T> | T): Promise<T>;
|
|
}
|
|
|
|
export const SourceMapConsumer: SourceMapConsumerConstructor;
|
|
|
|
export interface BasicSourceMapConsumer extends SourceMapConsumer {
|
|
file: string;
|
|
sourceRoot: string;
|
|
sources: string[];
|
|
sourcesContent: string[];
|
|
}
|
|
|
|
export interface BasicSourceMapConsumerConstructor {
|
|
prototype: BasicSourceMapConsumer;
|
|
|
|
new (rawSourceMap: RawSourceMap | string): Promise<BasicSourceMapConsumer>;
|
|
|
|
/**
|
|
* Create a BasicSourceMapConsumer from a SourceMapGenerator.
|
|
*
|
|
* @param sourceMap
|
|
* The source map that will be consumed.
|
|
*/
|
|
fromSourceMap(sourceMap: SourceMapGenerator): Promise<BasicSourceMapConsumer>;
|
|
}
|
|
|
|
export const BasicSourceMapConsumer: BasicSourceMapConsumerConstructor;
|
|
|
|
export interface IndexedSourceMapConsumer extends SourceMapConsumer {
|
|
sources: string[];
|
|
}
|
|
|
|
export interface IndexedSourceMapConsumerConstructor {
|
|
prototype: IndexedSourceMapConsumer;
|
|
|
|
new (rawSourceMap: RawIndexMap | string): Promise<IndexedSourceMapConsumer>;
|
|
}
|
|
|
|
export const IndexedSourceMapConsumer: IndexedSourceMapConsumerConstructor;
|
|
|
|
export class SourceMapGenerator {
|
|
constructor(startOfSourceMap?: StartOfSourceMap);
|
|
|
|
/**
|
|
* Creates a new SourceMapGenerator based on a SourceMapConsumer
|
|
*
|
|
* @param sourceMapConsumer The SourceMap.
|
|
*/
|
|
static fromSourceMap(sourceMapConsumer: SourceMapConsumer): SourceMapGenerator;
|
|
|
|
/**
|
|
* Add a single mapping from original source line and column to the generated
|
|
* source's line and column for this source map being created. The mapping
|
|
* object should have the following properties:
|
|
*
|
|
* - generated: An object with the generated line and column positions.
|
|
* - original: An object with the original line and column positions.
|
|
* - source: The original source file (relative to the sourceRoot).
|
|
* - name: An optional original token name for this mapping.
|
|
*/
|
|
addMapping(mapping: Mapping): void;
|
|
|
|
/**
|
|
* Set the source content for a source file.
|
|
*/
|
|
setSourceContent(sourceFile: string, sourceContent: string): void;
|
|
|
|
/**
|
|
* Applies the mappings of a sub-source-map for a specific source file to the
|
|
* source map being generated. Each mapping to the supplied source file is
|
|
* rewritten using the supplied source map. Note: The resolution for the
|
|
* resulting mappings is the minimium of this map and the supplied map.
|
|
*
|
|
* @param sourceMapConsumer The source map to be applied.
|
|
* @param sourceFile Optional. The filename of the source file.
|
|
* If omitted, SourceMapConsumer's file property will be used.
|
|
* @param sourceMapPath Optional. The dirname of the path to the source map
|
|
* to be applied. If relative, it is relative to the SourceMapConsumer.
|
|
* This parameter is needed when the two source maps aren't in the same
|
|
* directory, and the source map to be applied contains relative source
|
|
* paths. If so, those relative source paths need to be rewritten
|
|
* relative to the SourceMapGenerator.
|
|
*/
|
|
applySourceMap(sourceMapConsumer: SourceMapConsumer, sourceFile?: string, sourceMapPath?: string): void;
|
|
|
|
toString(): string;
|
|
|
|
toJSON(): RawSourceMap;
|
|
}
|
|
|
|
export class SourceNode {
|
|
children: SourceNode[];
|
|
sourceContents: any;
|
|
line: number;
|
|
column: number;
|
|
source: string;
|
|
name: string;
|
|
|
|
constructor();
|
|
constructor(
|
|
line: number | null,
|
|
column: number | null,
|
|
source: string | null,
|
|
chunks?: Array<(string | SourceNode)> | SourceNode | string,
|
|
name?: string
|
|
);
|
|
|
|
static fromStringWithSourceMap(
|
|
code: string,
|
|
sourceMapConsumer: SourceMapConsumer,
|
|
relativePath?: string
|
|
): SourceNode;
|
|
|
|
add(chunk: Array<(string | SourceNode)> | SourceNode | string): SourceNode;
|
|
|
|
prepend(chunk: Array<(string | SourceNode)> | SourceNode | string): SourceNode;
|
|
|
|
setSourceContent(sourceFile: string, sourceContent: string): void;
|
|
|
|
walk(fn: (chunk: string, mapping: MappedPosition) => void): void;
|
|
|
|
walkSourceContents(fn: (file: string, content: string) => void): void;
|
|
|
|
join(sep: string): SourceNode;
|
|
|
|
replaceRight(pattern: string, replacement: string): SourceNode;
|
|
|
|
toString(): string;
|
|
|
|
toStringWithSourceMap(startOfSourceMap?: StartOfSourceMap): CodeWithSourceMap;
|
|
}
|