400 lines
12 KiB
TypeScript
400 lines
12 KiB
TypeScript
// 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
|
|
}
|