@remotex-labs/xmap 2.0.2 → 2.0.4

package/dist/esm/components/highlighter.component.d.ts

@@ -1,186 +0,0 @@
-/**
- * Import will remove at compile time
- */
-import type { HighlightSchemeInterface } from "./interfaces/highlighter.interface";
-/**
- * Imports
- */
-import * as ts from 'typescript';
-/**
- * An enum containing ANSI escape sequences for various colors.
- *
- * This enum is primarily intended for terminal output and won't work directly in JavaScript for web development.
- * It defines color codes for various colors and a reset code to return to
- * the default text color.
- *
- * @example
- * ```typescript
- * console.log(`${Colors.red}This the text will be red in the terminal.${Colors.reset}`);
- * ```
- *
- * This functionality is limited to terminal environments.
- * Consider alternative methods
- * for color highlighting in web development contexts, such as CSS classes.
- */
-export declare const enum Colors {
-    reset = "\u001B[0m",
-    gray = "\u001B[38;5;243m",
-    darkGray = "\u001B[38;5;238m",
-    lightCoral = "\u001B[38;5;203m",
-    lightOrange = "\u001B[38;5;215m",
-    oliveGreen = "\u001B[38;5;149m",
-    burntOrange = "\u001B[38;5;208m",
-    lightGoldenrodYellow = "\u001B[38;5;221m",
-    lightYellow = "\u001B[38;5;230m",
-    canaryYellow = "\u001B[38;5;227m",
-    deepOrange = "\u001B[38;5;166m",
-    lightGray = "\u001B[38;5;252m",
-    brightPink = "\u001B[38;5;197m"
-}
-/**
- * Class responsible for applying semantic highlighting to a source code string based on a given color scheme.
- *
- * @class
- *
- * @param sourceFile - The TypeScript AST node representing the source file.
- * @param code - The source code string to be highlighted.
- * @param schema - The color scheme used for highlighting different elements in the code.
- *
- * const highlighter = new CodeHighlighter(sourceFile, code, schema);
- */
-export declare class CodeHighlighter {
-    private sourceFile;
-    private code;
-    private schema;
-    /**
-     * A Map of segments where the key is a combination of start and end positions,
-     * and the value is an object containing the color and reset code.
-     * This structure ensures unique segments and allows for fast lookups and updates.
-     *
-     * @example
-     * this.segments = new Map([
-     *   ['0-10', { start: 1, end: 11, color: '\x1b[31m', reset: '\x1b[0m' }],
-     *   ['11-20', { start: 12, end: 20, color: '\x1b[32m', reset: '\x1b[0m' }]
-     * ]);
-     */
-    private segments;
-    /**
-     * Creates an instance of the CodeHighlighter class.
-     *
-     * @param sourceFile - The TypeScript AST node representing the source file.
-     * @param code - The source code string to be highlighted.
-     * @param schema - The color scheme used for highlighting different elements in the code.
-     */
-    constructor(sourceFile: ts.Node, code: string, schema: HighlightSchemeInterface);
-    /**
-     * Parses a TypeScript AST node and processes its comments to identify segments that need highlighting.
-     *
-     * @param node - The TypeScript AST node to be parsed.
-     */
-    parseNode(node: ts.Node): void;
-    /**
-     * Generates a string with highlighted code segments based on the provided color scheme.
-     *
-     * This method processes the stored segments, applies the appropriate colors to each segment,
-     * and returns the resulting highlighted code as a single string.
-     *
-     * @returns The highlighted code as a string, with ANSI color codes applied to the segments.
-     */
-    highlight(): string;
-    /**
-     * Extracts a substring from the code based on the specified start and end positions.
-     *
-     * This method is used to retrieve the source code segment that corresponds to the
-     * given start and end positions. It is primarily used for highlighting specific
-     * segments of the code.
-     *
-     * @param start - The starting index of the segment to be extracted.
-     * @param end - The ending index of the segment to be extracted.
-     * @returns The extracted substring from the code.
-     */
-    private getSegmentSource;
-    /**
-     * Adds a new segment to the list of segments to be highlighted.
-     * The segment is defined by its start and end positions, the color to apply, and an optional reset code.
-     *
-     * @param start - The starting index of the segment in the code string.
-     * @param end - The ending index of the segment in the code string.
-     * @param color - The color code to apply to the segment.
-     * @param reset - The color reset code to apply after the segment, Defaults to the reset code defined in `Colors.reset`.
-     */
-    private addSegment;
-    /**
-     * Processes comments within a TypeScript AST node and adds segments for highlighting.
-     * Extracts trailing and leading comments from the node and adds them as segments using the color defined in `this.colorSchema.comments`.
-     *
-     * @param node - The TypeScript AST node whose comments are to be processed.
-     */
-    private processComments;
-    /**
-     * Processes the keywords within a TypeScript AST node and adds them as segments for highlighting.
-     *
-     * This method identifies potential keyword tokens within the provided node and adds them to the
-     * list of segments with the color defined in `this.schema.keywordColor`.
-     * The method considers the current node, its first token, and its last token to determine if they should be highlighted
-     * as keywords.
-     *
-     * The method checks if the node's kind falls within the range of keyword kinds defined by TypeScript.
-     * If the node or any of its tokens are identified as keywords, a segment is added to `this.segments`
-     * with the start and end positions of the node and the specified color for keywords.
-     *
-     * @param  node - The TypeScript AST node to be processed for keywords.
-     */
-    private processKeywords;
-    /**
-     * Processes identifiers within a TypeScript AST node and adds them as segments for highlighting
-     * based on the node's parent type.
-     *
-     * This method determines the appropriate color for an identifier based on its parent node's kind.
-     * If the parent node matches one of the specified kinds, the identifier is highlighted with a cyan color.
-     * Supported parent kinds include various declarations, expressions, and signatures.
-     *
-     * @param node - The TypeScript AST node representing the identifier to be processed.
-     */
-    private processIdentifier;
-    /**
-     * Processes a TypeScript template expression and adds segments for highlighting its literal parts.
-     *
-     * This method adds a segment for the head of the template expression with the color specified in `this.schema.stringColor`.
-     * It also processes each template span within the expression, adding
-     * segments for each span's literal part.
-     *
-     * @param templateExpression - The TypeScript template expression to be processed.
-     */
-    private processTemplateExpression;
-    /**
-     * Processes a TypeScript AST node and adds segments for highlighting based on the node's kind.
-     *
-     * This method identifies the kind of the node and determines the appropriate color for highlighting.
-     * It handles various node kinds including string literals, regular expressions, template expressions, and identifiers.
-     * Specific methods are invoked for more complex node kinds, such as template expressions and identifiers.
-     *
-     * @param  node - The TypeScript AST node to be processed.
-     */
-    private processNode;
-}
-/**
- * Applies semantic highlighting to the provided code string using the specified color scheme.
- *
- * @param code - The source code to be highlighted.
- * @param schema - An optional partial schema defining the color styles for various code elements.
- *                 Defaults to an empty object, which means no specific highlighting will be applied.
- *
- * @returns A string with the code elements wrapped in the appropriate color styles as specified by the schema.
- *
- * @example
- * const code = 'const x: number = 42;';
- * const schema = {
- *   keywordColor: '\x1b[34m', // Blue
- *   stringColor: '\x1b[32m',  // Green
- *   numberColor: '\x1b[31m',  // Red
- *   reset: '\x1b[0m'          // Reset
- * };
- * const highlightedCode = highlightCode(code, schema);
- * console.log(highlightedCode);
- */
-export declare function highlightCode(code: string, schema?: Partial<HighlightSchemeInterface>): string;

package/dist/esm/components/interfaces/formatter.interface.d.ts

@@ -1,42 +0,0 @@
-/**
- * A callback function type used for formatting code lines.
- *
- * @param lineString - The content of the line to be formatted.
- * @param padding - The amount of padding to be applied to the line.
- * @param line - The line number of the line to be formatted.
- * @returns The formatted line string.
- */
-export type FormatCodeCallbackType = (lineString: string, padding: number, line: number) => string;
-/**
- * Configuration options for formatting code.
- */
-export interface FormatCodeInterface {
-    /**
-     * The amount of padding to be applied to each line. If not specified, defaults to 0.
-     */
-    padding?: number;
-    /**
-     * The starting line number for formatting. If not specified, defaults to 1.
-     */
-    startLine?: number;
-    /**
-     * An optional action object specifying a line where a callback function should be triggered.
-     */
-    action?: {
-        /**
-         * The line number at which the callback function should be triggered.
-         */
-        triggerLine: number;
-        /**
-         * The callback function to be executed when the trigger line is encountered.
-         */
-        callback: FormatCodeCallbackType;
-    };
-}
-/**
- * Set color to an error pointer
- */
-export interface AnsiOptionInterface {
-    color: string;
-    reset: string;
-}

package/dist/esm/components/interfaces/highlighter.interface.d.ts

@@ -1,48 +0,0 @@
-/**
- * HighlightSchemeInterface defines the structure for a color style schema
- * used in semantic highlighting.
- * This interface ensures that the highlighting styles are consistent and easily configurable.
- */
-export interface HighlightSchemeInterface {
-    enumColor: string;
-    typeColor: string;
-    classColor: string;
-    stringColor: string;
-    keywordColor: string;
-    commentColor: string;
-    functionColor: string;
-    variableColor: string;
-    interfaceColor: string;
-    parameterColor: string;
-    getAccessorColor: string;
-    numericLiteralColor: string;
-    methodSignatureColor: string;
-    regularExpressionColor: string;
-    propertyAssignmentColor: string;
-    propertyAccessExpressionColor: string;
-    expressionWithTypeArgumentsColor: string;
-}
-/**
- * Represents a segment of a code string that needs to be highlighted.
- *
- * @interface
- *
- * @property start - The starting index of the segment in the code string.
- * @property end - The ending index of the segment in the code string.
- * @property color - The color code to apply to the segment.
- * @property reset - The color reset code to apply after the segment.
- *
- * @example
- * const segment: HighlightNodeSegment = {
- *   start: 0,
- *   end: 10,
- *   color: '\x1b[31m', // Red
- *   reset: '\x1b[0m' // Reset
- * };
- */
-export interface HighlightNodeSegmentInterface {
-    end: number;
-    start: number;
-    color: string;
-    reset: string;
-}

package/dist/esm/components/interfaces/parse.interface.d.ts

@@ -1,31 +0,0 @@
-/**
- * Represents an entry in the stack trace.
- */
-export interface StackInterface {
-    /**
-     * The function or method where the error occurred.
-     */
-    at: string;
-    /**
-     * The file path where the error occurred.
-     */
-    file: string;
-    /**
-     * The line number where the error occurred.
-     */
-    line: number;
-    /**
-     * The column number where the error occurred.
-     */
-    column: number;
-}
-/**
- * Represents a detailed entry in the stack trace, which may include an executor stack entry.
- */
-export interface StackEntryInterface extends StackInterface {
-    /**
-     * The executor information if the error occurred within an eval function.
-     * This will be `null` if the error did not occur within an eval function.
-     */
-    executor?: StackInterface | null;
-}

package/dist/esm/components/parser.component.d.ts

@@ -1,11 +0,0 @@
-/**
- * Import will remove at compile time
- */
-import type { StackEntryInterface } from "./interfaces/parse.interface";
-/**
- * Parses an error stack trace and returns an object with a message and an array of stack entries.
- *
- * @param stackString - The error stack trace.
- * @returns The parsed stack trace object.
- */
-export declare function parseErrorStack(stackString: string): Array<StackEntryInterface>;

package/dist/esm/index.d.ts

@@ -1,9 +0,0 @@
-export type * from "./components/interfaces/parse.interface";
-export type * from "./components/interfaces/formatter.interface";
-export type * from "./components/interfaces/highlighter.interface";
-export type * from "./services/interfaces/source.interface";
-export * from "./components/parser.component";
-export * from "./components/base64.component";
-export * from "./components/formatter.component";
-export * from "./components/highlighter.component";
-export * from "./services/source.service";

package/dist/esm/providers/interfaces/mapping.interface.d.ts

@@ -1,52 +0,0 @@
-/**
- * Represents a mapping segment that corresponds to a position in the source map.
- *
- * @property line - The original line number in the source file.
- * @property column - The original column number in the source file.
- * @property nameIndex - The index of the symbol name in the source map, or `null` if there is no associated name.
- * @property sourceIndex - The index of the source file in the source map.
- * @property generatedLine - The line number in the generated code.
- * @property generatedColumn - The column number in the generated code.
- */
-export interface SegmentInterface {
-    line: number;
-    column: number;
-    nameIndex: number | null;
-    sourceIndex: number;
-    generatedLine: number;
-    generatedColumn: number;
-}
-/**
- * Extends the `SegmentInterface` to represent an offset segment used during mapping calculations.
- * The main difference is that `nameIndex` is always a number.
- *
- * @augments { SegmentInterface }
- * @property nameIndex - The index of the symbol name in the source map (cannot be null in this context).
- */
-export interface SegmentOffsetInterface extends SegmentInterface {
-    nameIndex: number;
-}
-/**
- * Represents the bias used when searching for segments in the source map.
- * This enum is useful for determining the preferred matching behavior
- * when the exact line and column cannot be found.
- *
- * @property BOUND - No preference for column matching; returns the first match found.
- * @property LOWER_BOUND - Prefer the closest mapping with a lower column value.
- * @property UPPER_BOUND - Prefer the closest mapping with a higher column value.
- */
-export declare const enum Bias {
-    BOUND = 0,
-    LOWER_BOUND = 1,
-    UPPER_BOUND = 2
-}
-/**
- * A type alias for a frame in the source map, representing an array of segments.
- * Each frame consists of multiple mapping segments for a given line in the generated code.
- */
-export type FrameType = Array<SegmentInterface>;
-/**
- * A type alias for the source map, where each entry represents a frame of mappings.
- * A frame can either be an array of segments (frame) or `null` if the line has no mappings (represented by a semicolon in the mapping string).
- */
-export type MapType = Array<null | FrameType>;

package/dist/esm/providers/mapping.provider.d.ts

@@ -1,229 +0,0 @@
-/**
- * Import will remove at compile time
- */
-import { Bias, type MapType, type SegmentInterface } from './interfaces/mapping.interface';
-/**
- * The `MappingProvider` class provides methods to encode and decode mappings
- * from a source map or mapping string to an internal structured representation.
- */
-export declare class MappingProvider {
-    /**
-     * The internal mapping representation, where each index represents a frame of segments.
-     */
-    private mapping;
-    /**
-     * Constructor to initialize the `MappingProvider` with a mapping.
-     * Can be initialized with either a mapping string or a structured mapping array.
-     *
-     * @param mapping - The mapping data, either as a string or structured array.
-     * @param namesOffset - Optional offset for the names index.
-     * @param sourceOffset - Optional offset for the sources index.
-     *
-     * @example
-     * ```ts
-     * const provider = new MappingProvider(";;;AAiBO,SAAS,OAAO;AACnB,UAAQ,IAAI,MAAM;AACtB;;;ACjBA,QAAQ,IAAI,GAAG;AACf,KAAK;", 0, 0);
-     * const provider2 = new MappingProvider([
-     *   null,
-     *   [
-     *     {
-     *       line: 1,
-     *       column: 1,
-     *       nameIndex: null,
-     *       sourceIndex: 0,
-     *       generatedLine: 2,
-     *       generatedColumn: 1
-     *     }
-     *   ],
-     *   null
-     * ], 0, 0);
-     * ```
-     */
-    constructor(mapping: string, namesOffset?: number, sourceOffset?: number);
-    constructor(mapping: MapType, namesOffset?: number, sourceOffset?: number);
-    constructor(mapping: MappingProvider, namesOffset?: number, sourceOffset?: number);
-    /**
-     * Encodes the internal mapping array back into a mapping string.
-     *
-     * @returns {string} - The encoded mapping string.
-     * @example
-     * ```ts
-     * const encoded = provider.encode();
-     * console.log(encoded); // Outputs encoded mapping string
-     * ```
-     */
-    encode(): string;
-    /**
-     * Decodes a mapping from either a string or structured array into the internal mapping.
-     *
-     * @param mapping - The mapping data to decode.
-     * @param namesOffset - Offset for the names index.
-     * @param sourcesOffset - Offset for the sources index.
-     * @example
-     * ```ts
-     * provider.decode(";;;AAiBO,SAAS,OAAO;AACnB,UAAQ,IAAI,MAAM;AACtB;;;ACjBA,QAAQ,IAAI,GAAG;AACf,KAAK;", 0, 0);
-     * provider.decode([
-     *   null,
-     *   [
-     *     {
-     *       line: 1,
-     *       column: 1,
-     *       nameIndex: null,
-     *       sourceIndex: 0,
-     *       generatedLine: 2,
-     *       generatedColumn: 1
-     *     }
-     *   ],
-     *   null
-     * ], 0, 0);
-     * ```
-     */
-    decode(mapping: MappingProvider | MapType | string, namesOffset?: number, sourcesOffset?: number): void;
-    /**
-     * Retrieves a segment based on the provided generated line and column,
-     * applying the specified bias when the exact match is not found.
-     *
-     * This method performs a binary search on the segments of the specified
-     * generated line to efficiently locate the segment corresponding to
-     * the provided generated column. If an exact match is not found,
-     * the method returns the closest segment based on the specified bias:
-     * - `Bias.BOUND`: No preference for column matching (returns the closest segment).
-     * - `Bias.LOWER_BOUND`: Prefers the closest mapping with a lower column value.
-     * - `Bias.UPPER_BOUND`: Prefers the closest mapping with a higher column value.
-     *
-     * @param generatedLine - The line number of the generated code (1-based index).
-     * @param generatedColumn - The column number of the generated code (0-based index).
-     * @param bias - The bias to use when the line matches, can be one of:
-     *   - `Bias.BOUND` (default): No preference for column matching.
-     *   - `Bias.LOWER_BOUND`: Prefer the closest mapping with a lower column value.
-     *   - `Bias.UPPER_BOUND`: Prefer the closest mapping with a higher column value.
-     * @returns The matching segment if found;
-     * returns null if no segments exist for the specified generated line
-     * or if the generated line is out of bounds.
-     *
-     * @throws { Error } - Throws an error if the generated line is invalid
-     * (out of bounds).
-     *
-     * @example
-     * ```ts
-     * const segment = sourceMap.getSegment(5, 10, Bias.UPPER_BOUND);
-     * if (segment) {
-     *     console.log(`Found segment: line ${segment.line}, column ${segment.column}`);
-     * } else {
-     *     console.log('No matching segment found.');
-     * }
-     * ```
-     */
-    getSegment(generatedLine: number, generatedColumn: number, bias?: Bias): SegmentInterface | null;
-    /**
-     * Retrieves the original segment based on the provided line, column, and source index.
-     *
-     * This method searches for the original segment that corresponds to the specified
-     * line, column, and source index. It uses binary search to find the closest segment
-     * based on the provided bias.
-     *
-     * @param line - The line number of the original code (1-based index).
-     * @param column - The column number of the original code (0-based index).
-     * @param sourceIndex - The index of the source file in the source map.
-     * @param bias - The bias to apply when multiple segments match; defaults to `Bias.BOUND`.
-     * @returns {SegmentInterface | null} - The matching original segment if found;
-     * returns null if no segments exist for the specified line and source index.
-     *
-     * @example
-     * ```ts
-     * const originalSegment = sourceMap.getOriginalSegment(3, 5, 0, Bias.LOWER_BOUND);
-     * if (originalSegment) {
-     *     console.log(`Found original segment: line ${originalSegment.line}, column ${originalSegment.column}`);
-     * } else {
-     *     console.log('No matching original segment found.');
-     * }
-     * ```
-     */
-    getOriginalSegment(line: number, column: number, sourceIndex: number, bias?: Bias): SegmentInterface | null;
-    /**
-     * Initializes the segment offsets used to track the current decoding position.
-     *
-     * @param namesOffset - The offset for the names index.
-     * @param sourceIndex - The offset for the source index.
-     * @returns { SegmentOffsetInterface } - The initialized segment offset.
-     */
-    private initPositionOffsets;
-    /**
-     * Validates the format of an encoded mapping string.
-     *
-     * @param encodedSourceMap - The encoded source map string to validate.
-     * @returns Returns `true` if the format is valid, otherwise `false`.
-     */
-    private validateMappingString;
-    /**
-     * Validates the properties of a segment to ensure they conform to expected types.
-     *
-     * This method checks that the segment's properties are finite numbers and that
-     * the nameIndex, if provided, is either a finite number or null.
-     * An error is thrown if any of the properties do not meet the specified criteria.
-     *
-     * @param segment - The segment object to validate, which must conform to the
-     *                  SegmentInterface structure, including:
-     *                  - line: number (finite)
-     *                  - column: number (finite)
-     *                  - nameIndex: number | null (if not null, must be finite)
-     *                  - sourceIndex: number (finite)
-     *                  - generatedLine: number (finite)
-     *                  - generatedColumn: number (finite)
-     *
-     * @throws {Error} - Throws an error if any property of the segment is invalid.
-     *                   The error message will specify which property is invalid
-     *                   and the value that was received.
-     */
-    private validateSegment;
-    /**
-     * Encodes a segment into a VLQ-encoded string based on the segment offsets.
-     *
-     * @param segmentOffset - The current segment offset.
-     * @param segmentObject - The segment to encode.
-     * @returns The encoded segment string.
-     */
-    private encodeSegment;
-    /**
-     * Encodes the entire mapping array into a VLQ-encoded mapping string.
-     *
-     * @param map - The mapping array to encode.
-     * @returns The encoded mapping string.
-     */
-    private encodeMappings;
-    /**
-     * Decodes a VLQ-encoded segment into a segment object based on the current offset.
-     *
-     * @param segmentOffset - The current segment offset.
-     * @param decodedSegment - The decoded VLQ segment values.
-     * @returns The decoded segment object.
-     */
-    private decodedSegment;
-    /**
-     * Decodes a VLQ-encoded mapping string into the internal mapping representation.
-     *
-     * @param encodedMap - The VLQ-encoded mapping string.
-     * @param namesOffset - Offset for the names index.
-     * @param sourceOffset - Offset for the sources index.
-     * @throws { Error } - Throws an error if the mapping string is invalid.
-     */
-    private decodeMappingString;
-    /**
-     * Decodes a mapping array into the internal mapping representation, adjusting for offsets.
-     *
-     * This method processes each frame in the provided structured mapping array,
-     * validating each segment within the frame and adjusting the indices based on the
-     * specified offsets for names and sources. If a frame is invalid or not an array,
-     * an error will be thrown.
-     *
-     * @param encodedMap - The structured mapping array, which should be an array of frames,
-     *                     where each frame is an array of segments. Each segment must conform
-     *                     to the SegmentInterface.
-     * @param namesOffset - Offset for the names index, which will be added to each segment's nameIndex.
-     * @param sourceOffset - Offset for the sources index, which will be added to each segment's sourceIndex.
-     * @throws { Error } - Throws an error if:
-     *                   - The mapping array is invalid (not an array).
-     *                   - Any frame is not an array.
-     *                   - Any segment does not conform to the SegmentInterface.
-     */
-    private decodeMappingArray;
-}

package/dist/esm/services/interfaces/source.interface.d.ts

@@ -1,53 +0,0 @@
-/**
- * Represents a source map structure used for mapping code within a file
- * to its original source. Source maps are essential for debugging minified
- * or transpiled code, as they allow developers to trace back to the
- * original source files and understand the context of the code execution.
- *
- * @interface SourceMapInterface
- * @property file - The generated file's name that the source map is associated with.
- * This property is optional and may be null if not specified.
- * @property names - An array of variable/function names that are present in the original source.
- * These names help in mapping the original code context during debugging.
- * @property version - The version of the source map specification.
- * This should be set to `3` for the standard source map version.
- * @property sources - An array of URLs or paths to the original source files.
- * These sources are used to locate the original code that corresponds to the generated code.
- * @property mappings - A VLQ (Variable-Length Quantity) encoded string that describes how to map the
- * generated code back to the original source code. This property is crucial for the correct functioning of the source map.
- * @property sourceRoot - An optional root URL for the sources.
- * It can be used to specify a base path for resolving the sources, which may be null if not applicable.
- * @property sourcesContent - An optional array containing the content of the original source files.
- * This property can be useful when the original files are not available at runtime.
- */
-export interface SourceMapInterface {
-    file?: string | null;
-    names: Array<string>;
-    version: number;
-    sources: Array<string>;
-    mappings: string;
-    sourceRoot?: string | null;
-    sourcesContent?: Array<string>;
-}
-export interface PositionInterface {
-    name: string | null;
-    line: number;
-    column: number;
-    source: string;
-    sourceRoot: string | null;
-    sourceIndex: number;
-    generatedLine: number;
-    generatedColumn: number;
-}
-export interface PositionWithContentInterface extends PositionInterface {
-    sourcesContent: string;
-}
-export interface PositionWithCodeInterface extends PositionInterface {
-    code: string;
-    endLine: number;
-    startLine: number;
-}
-export interface SourceOptionsInterface {
-    linesAfter?: number;
-    linesBefore?: number;
-}