$

node_modules/@jridgewell/trace-mapping/dist/types/any-map.d.ts

@@ -0,0 +1,8 @@
+import { TraceMap } from './trace-mapping';
+import type { SectionedSourceMapInput } from './types';
+declare type AnyMap = {
+    new (map: SectionedSourceMapInput, mapUrl?: string | null): TraceMap;
+    (map: SectionedSourceMapInput, mapUrl?: string | null): TraceMap;
+};
+export declare const AnyMap: AnyMap;
+export {};

node_modules/@jridgewell/trace-mapping/dist/types/binary-search.d.ts

@@ -0,0 +1,32 @@
+import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment';
+export declare type MemoState = {
+    lastKey: number;
+    lastNeedle: number;
+    lastIndex: number;
+};
+export declare let found: boolean;
+/**
+ * A binary search implementation that returns the index if a match is found.
+ * If no match is found, then the left-index (the index associated with the item that comes just
+ * before the desired index) is returned. To maintain proper sort order, a splice would happen at
+ * the next index:
+ *
+ * ```js
+ * const array = [1, 3];
+ * const needle = 2;
+ * const index = binarySearch(array, needle, (item, needle) => item - needle);
+ *
+ * assert.equal(index, 0);
+ * array.splice(index + 1, 0, needle);
+ * assert.deepEqual(array, [1, 2, 3]);
+ * ```
+ */
+export declare function binarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, low: number, high: number): number;
+export declare function upperBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number;
+export declare function lowerBound(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, index: number): number;
+export declare function memoizedState(): MemoState;
+/**
+ * This overly complicated beast is just to record the last tested line/column and the resulting
+ * index, allowing us to skip a few tests if mappings are monotonically increasing.
+ */
+export declare function memoizedBinarySearch(haystack: SourceMapSegment[] | ReverseSegment[], needle: number, state: MemoState, key: number): number;

node_modules/@jridgewell/trace-mapping/dist/types/by-source.d.ts

@@ -0,0 +1,7 @@
+import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment';
+import type { MemoState } from './binary-search';
+export declare type Source = {
+    __proto__: null;
+    [line: number]: Exclude<ReverseSegment, [number]>[];
+};
+export default function buildBySources(decoded: readonly SourceMapSegment[][], memos: MemoState[]): Source[];

node_modules/@jridgewell/trace-mapping/dist/types/resolve.d.ts

@@ -0,0 +1 @@
+export default function resolve(input: string, base: string | undefined): string;

node_modules/@jridgewell/trace-mapping/dist/types/sort.d.ts

@@ -0,0 +1,2 @@
+import type { SourceMapSegment } from './sourcemap-segment';
+export default function maybeSort(mappings: SourceMapSegment[][], owned: boolean): SourceMapSegment[][];

node_modules/@jridgewell/trace-mapping/dist/types/sourcemap-segment.d.ts

@@ -0,0 +1,16 @@
+declare type GeneratedColumn = number;
+declare type SourcesIndex = number;
+declare type SourceLine = number;
+declare type SourceColumn = number;
+declare type NamesIndex = number;
+declare type GeneratedLine = number;
+export declare type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
+export declare type ReverseSegment = [SourceColumn, GeneratedLine, GeneratedColumn];
+export declare const COLUMN = 0;
+export declare const SOURCES_INDEX = 1;
+export declare const SOURCE_LINE = 2;
+export declare const SOURCE_COLUMN = 3;
+export declare const NAMES_INDEX = 4;
+export declare const REV_GENERATED_LINE = 1;
+export declare const REV_GENERATED_COLUMN = 2;
+export {};

node_modules/@jridgewell/trace-mapping/dist/types/strip-filename.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Removes everything after the last "/", but leaves the slash.
+ */
+export default function stripFilename(path: string | undefined | null): string;

node_modules/@jridgewell/trace-mapping/dist/types/trace-mapping.d.ts

@@ -0,0 +1,74 @@
+import type { SourceMapSegment } from './sourcemap-segment';
+import type { SourceMapV3, DecodedSourceMap, EncodedSourceMap, InvalidOriginalMapping, OriginalMapping, InvalidGeneratedMapping, GeneratedMapping, SourceMapInput, Needle, SourceNeedle, SourceMap, EachMapping } from './types';
+export type { SourceMapSegment } from './sourcemap-segment';
+export type { SourceMapInput, SectionedSourceMapInput, DecodedSourceMap, EncodedSourceMap, SectionedSourceMap, InvalidOriginalMapping, OriginalMapping as Mapping, OriginalMapping, InvalidGeneratedMapping, GeneratedMapping, EachMapping, } from './types';
+export declare const LEAST_UPPER_BOUND = -1;
+export declare const GREATEST_LOWER_BOUND = 1;
+/**
+ * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
+ */
+export declare let encodedMappings: (map: TraceMap) => EncodedSourceMap['mappings'];
+/**
+ * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
+ */
+export declare let decodedMappings: (map: TraceMap) => Readonly<DecodedSourceMap['mappings']>;
+/**
+ * A low-level API to find the segment associated with a generated line/column (think, from a
+ * stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
+ */
+export declare let traceSegment: (map: TraceMap, line: number, column: number) => Readonly<SourceMapSegment> | null;
+/**
+ * A higher-level API to find the source/line/column associated with a generated line/column
+ * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
+ * `source-map` library.
+ */
+export declare let originalPositionFor: (map: TraceMap, needle: Needle) => OriginalMapping | InvalidOriginalMapping;
+/**
+ * Finds the source/line/column directly after the mapping returned by originalPositionFor, provided
+ * the found mapping is from the same source and line as the originalPositionFor mapping.
+ *
+ * Eg, in the code `let id = 1`, `originalPositionAfter` could find the mapping associated with `1`
+ * using the same needle that would return `id` when calling `originalPositionFor`.
+ */
+export declare let generatedPositionFor: (map: TraceMap, needle: SourceNeedle) => GeneratedMapping | InvalidGeneratedMapping;
+/**
+ * Iterates each mapping in generated position order.
+ */
+export declare let eachMapping: (map: TraceMap, cb: (mapping: EachMapping) => void) => void;
+/**
+ * Retrieves the source content for a particular source, if its found. Returns null if not.
+ */
+export declare let sourceContentFor: (map: TraceMap, source: string) => string | null;
+/**
+ * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
+ * maps.
+ */
+export declare let presortedDecodedMap: (map: DecodedSourceMap, mapUrl?: string) => TraceMap;
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare let decodedMap: (map: TraceMap) => Omit<DecodedSourceMap, 'mappings'> & {
+    mappings: readonly SourceMapSegment[][];
+};
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+export declare let encodedMap: (map: TraceMap) => EncodedSourceMap;
+export { AnyMap } from './any-map';
+export declare class TraceMap implements SourceMap {
+    version: SourceMapV3['version'];
+    file: SourceMapV3['file'];
+    names: SourceMapV3['names'];
+    sourceRoot: SourceMapV3['sourceRoot'];
+    sources: SourceMapV3['sources'];
+    sourcesContent: SourceMapV3['sourcesContent'];
+    resolvedSources: string[];
+    private _encoded;
+    private _decoded;
+    private _decodedMemo;
+    private _bySources;
+    private _bySourceMemos;
+    constructor(map: SourceMapInput, mapUrl?: string | null);
+}

node_modules/@jridgewell/trace-mapping/dist/types/types.d.ts

@@ -0,0 +1,85 @@
+import type { SourceMapSegment } from './sourcemap-segment';
+import type { TraceMap } from './trace-mapping';
+export interface SourceMapV3 {
+    file?: string | null;
+    names: string[];
+    sourceRoot?: string;
+    sources: (string | null)[];
+    sourcesContent?: (string | null)[];
+    version: 3;
+}
+export interface EncodedSourceMap extends SourceMapV3 {
+    mappings: string;
+}
+export interface DecodedSourceMap extends SourceMapV3 {
+    mappings: SourceMapSegment[][];
+}
+export interface Section {
+    offset: {
+        line: number;
+        column: number;
+    };
+    map: EncodedSourceMap | DecodedSourceMap | SectionedSourceMap;
+}
+export interface SectionedSourceMap {
+    file?: string | null;
+    sections: Section[];
+    version: 3;
+}
+export declare type OriginalMapping = {
+    source: string | null;
+    line: number;
+    column: number;
+    name: string | null;
+};
+export declare type InvalidOriginalMapping = {
+    source: null;
+    line: null;
+    column: null;
+    name: null;
+};
+export declare type GeneratedMapping = {
+    line: number;
+    column: number;
+};
+export declare type InvalidGeneratedMapping = {
+    line: null;
+    column: null;
+};
+export declare type SourceMapInput = string | EncodedSourceMap | DecodedSourceMap | TraceMap;
+export declare type SectionedSourceMapInput = SourceMapInput | SectionedSourceMap;
+export declare type Needle = {
+    line: number;
+    column: number;
+    bias?: 1 | -1;
+};
+export declare type SourceNeedle = {
+    source: string;
+    line: number;
+    column: number;
+    bias?: 1 | -1;
+};
+export declare type EachMapping = {
+    generatedLine: number;
+    generatedColumn: number;
+    source: null;
+    originalLine: null;
+    originalColumn: null;
+    name: null;
+} | {
+    generatedLine: number;
+    generatedColumn: number;
+    source: string | null;
+    originalLine: number;
+    originalColumn: number;
+    name: string | null;
+};
+export declare abstract class SourceMap {
+    version: SourceMapV3['version'];
+    file: SourceMapV3['file'];
+    names: SourceMapV3['names'];
+    sourceRoot: SourceMapV3['sourceRoot'];
+    sources: SourceMapV3['sources'];
+    sourcesContent: SourceMapV3['sourcesContent'];
+    resolvedSources: SourceMapV3['sources'];
+}