@remotex-labs/xmap 2.0.2 → 2.0.3

package/dist/{cjs/providers → providers}/mapping.provider.d.ts

@@ -1,7 +1,11 @@
 /**
  * Import will remove at compile time
  */
-import { Bias, type MapType, type SegmentInterface } from './interfaces/mapping.interface';
+import type { MapType, SegmentInterface } from './interfaces/mapping.interface';
+/**
+ * Imports
+ */
+import { Bias } 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.

package/dist/providers/mapping.provider.js

@@ -0,0 +1,2 @@
+import{Bias as c}from"./interfaces/mapping.interface.js";import{decodeVLQ as p,encodeArrayVLQ as g}from"../components/base64.component.js";class l{mapping=[];constructor(e,r=0,t=0){e=e instanceof l?e.mapping:e,Array.isArray(e)?this.decodeMappingArray(e,r,t):this.decodeMappingString(e,r,t)}encode(){return this.encodeMappings(this.mapping)}decode(e,r=0,t=0){e=e instanceof l?e.mapping:e,Array.isArray(e)?this.decodeMappingArray(e,r,t):this.decodeMappingString(e,r,t)}getSegment(e,r,t=c.BOUND){const d=this.mapping[e-1];if(!d||d.length===0)return null;let n=0,o=d.length-1,i=null;for(;n<=o;){const a=Math.floor((n+o)/2),u=d[a];if(u.generatedColumn<r)n=a+1,i=t===c.LOWER_BOUND?u:i;else if(u.generatedColumn>r)o=a-1,i=t===c.UPPER_BOUND?u:i;else return u}return i}getOriginalSegment(e,r,t,d=c.BOUND){let n=null;for(const o of this.mapping){if(!o)continue;let i=0,a=o.length-1;for(;i<=a;){const u=Math.floor((i+a)/2),s=o[u];if(s.sourceIndex<t||s.line<e)i=u+1;else if(s.sourceIndex>t||s.line>e)a=u-1;else if(s.column<r)i=u+1,n=d===c.LOWER_BOUND?s:n;else if(s.column>r)a=u-1,n=d===c.UPPER_BOUND?s:n;else return s}}return n}initPositionOffsets(e=0,r=0){return{line:0,column:0,nameIndex:e,sourceIndex:r,generatedLine:0,generatedColumn:0}}validateMappingString(e){return/^[a-zA-Z0-9+/,;]+$/.test(e)}validateSegment(e){if(!Number.isFinite(e.line))throw new Error(`Invalid segment: line must be a finite number, received ${e.line}`);if(!Number.isFinite(e.column))throw new Error(`Invalid segment: column must be a finite number, received ${e.column}`);if(e.nameIndex!==null&&!Number.isFinite(e.nameIndex))throw new Error(`Invalid segment: nameIndex must be a number or null, received ${e.nameIndex}`);if(!Number.isFinite(e.sourceIndex))throw new Error(`Invalid segment: sourceIndex must be a finite number, received ${e.sourceIndex}`);if(!Number.isFinite(e.generatedLine))throw new Error(`Invalid segment: generatedLine must be a finite number, received ${e.generatedLine}`);if(!Number.isFinite(e.generatedColumn))throw new Error(`Invalid segment: generatedColumn must be a finite number, received ${e.generatedColumn}`)}encodeSegment(e,r){const{line:t,column:d,generatedColumn:n,nameIndex:o,sourceIndex:i}=r,a=t-1,u=d-1,s=n-1,m=[s-e.generatedColumn,i!==e.sourceIndex?i-e.sourceIndex:0,a-e.line,u-e.column];return o!=null&&(m[4]=o-e.nameIndex,e.nameIndex=o),e.line=a,e.column=u,e.generatedColumn=s,e.sourceIndex=i,g(m)}encodeMappings(e){const r=this.initPositionOffsets();return e.map(t=>t?(r.generatedColumn=0,t.map(n=>this.encodeSegment(r,n)).join(",")):"").join(";")}decodedSegment(e,r){const[t,d,n,o,i]=r;return e.line+=n,e.column+=o,e.nameIndex+=i??0,e.sourceIndex+=d,e.generatedColumn+=t,{line:e.line+1,column:e.column+1,nameIndex:i!==void 0?e.nameIndex:null,sourceIndex:e.sourceIndex,generatedLine:e.generatedLine+1,generatedColumn:e.generatedColumn+1}}decodeMappingString(e,r,t){if(!this.validateMappingString(e))throw new Error("Invalid Mappings string format: the provided string does not conform to expected VLQ format.");const d=e.split(";"),n=this.mapping.length,o=this.initPositionOffsets(r,t);try{d.forEach((i,a)=>{if(!i){this.mapping.push(null);return}o.generatedColumn=0,o.generatedLine=n+a;const u=i.split(",").map(s=>this.decodedSegment(o,p(s)));this.mapping.push(u)})}catch(i){throw new Error(`Error decoding mappings at frame index ${d.length}: ${i.message}`)}}decodeMappingArray(e,r,t){const d=this.mapping.length;if(!Array.isArray(e))throw new Error("Invalid encoded map: expected an array of frames.");try{e.forEach((n,o)=>{if(!n){this.mapping.push(n);return}if(!Array.isArray(n))throw new Error(`Invalid Mappings array format at frame index ${o}: expected an array, received ${typeof n}.`);const i=n.map(a=>(this.validateSegment(a),{...a,nameIndex:typeof a.nameIndex=="number"?a.nameIndex+r:null,sourceIndex:a.sourceIndex+t,generatedLine:a.generatedLine+d}));this.mapping.push(i)})}catch(n){const o=n instanceof Error?n.message:"Unknown error";throw new Error(`Error decoding mappings: ${o}`)}}}export{l as MappingProvider};
+//# sourceMappingURL=mapping.provider.js.map

package/dist/providers/mapping.provider.js.map

@@ -0,0 +1,8 @@
+{
+  "version": 3,
+  "sources": ["../../src/providers/mapping.provider.ts"],
+  "sourceRoot": "https://github.com/remotex-lab/xmap/tree/2.0.3/",
+  "sourcesContent": ["/**\n * Import will remove at compile time\n */\n\nimport type { MapType, FrameType, SegmentInterface, SegmentOffsetInterface } from './interfaces/mapping.interface.js';\n\n/**\n * Imports\n */\n\nimport { Bias } from './interfaces/mapping.interface.js';\nimport { decodeVLQ, encodeArrayVLQ } from '../components/base64.component.js';\n\n/**\n * The `MappingProvider` class provides methods to encode and decode mappings\n * from a source map or mapping string to an internal structured representation.\n */\n\nexport class MappingProvider {\n    /**\n     * The internal mapping representation, where each index represents a frame of segments.\n     */\n\n    private mapping: MapType = [];\n\n    /**\n     * Constructor to initialize the `MappingProvider` with a mapping.\n     * Can be initialized with either a mapping string or a structured mapping array.\n     *\n     * @param mapping - The mapping data, either as a string or structured array.\n     * @param namesOffset - Optional offset for the names index.\n     * @param sourceOffset - Optional offset for the sources index.\n     *\n     * @example\n     * ```ts\n     * const provider = new MappingProvider(\";;;AAiBO,SAAS,OAAO;AACnB,UAAQ,IAAI,MAAM;AACtB;;;ACjBA,QAAQ,IAAI,GAAG;AACf,KAAK;\", 0, 0);\n     * const provider2 = new MappingProvider([\n     *   null,\n     *   [\n     *     {\n     *       line: 1,\n     *       column: 1,\n     *       nameIndex: null,\n     *       sourceIndex: 0,\n     *       generatedLine: 2,\n     *       generatedColumn: 1\n     *     }\n     *   ],\n     *   null\n     * ], 0, 0);\n     * ```\n     */\n\n    constructor(mapping: string, namesOffset?: number, sourceOffset?: number);\n    constructor(mapping: MapType, namesOffset?: number, sourceOffset?: number);\n    constructor(mapping: MappingProvider, namesOffset?: number, sourceOffset?: number);\n    constructor(mapping: MappingProvider| MapType | string, namesOffset = 0, sourcesOffset = 0) {\n        mapping = mapping instanceof MappingProvider ? mapping.mapping : mapping;\n        if (Array.isArray(mapping)) {\n            this.decodeMappingArray(mapping, namesOffset, sourcesOffset);\n        } else {\n            this.decodeMappingString(mapping, namesOffset, sourcesOffset);\n        }\n    }\n\n    /**\n     * Encodes the internal mapping array back into a mapping string.\n     *\n     * @returns {string} - The encoded mapping string.\n     * @example\n     * ```ts\n     * const encoded = provider.encode();\n     * console.log(encoded); // Outputs encoded mapping string\n     * ```\n     */\n\n    encode(): string {\n        return this.encodeMappings(this.mapping);\n    }\n\n    /**\n     * Decodes a mapping from either a string or structured array into the internal mapping.\n     *\n     * @param mapping - The mapping data to decode.\n     * @param namesOffset - Offset for the names index.\n     * @param sourcesOffset - Offset for the sources index.\n     * @example\n     * ```ts\n     * provider.decode(\";;;AAiBO,SAAS,OAAO;AACnB,UAAQ,IAAI,MAAM;AACtB;;;ACjBA,QAAQ,IAAI,GAAG;AACf,KAAK;\", 0, 0);\n     * provider.decode([\n     *   null,\n     *   [\n     *     {\n     *       line: 1,\n     *       column: 1,\n     *       nameIndex: null,\n     *       sourceIndex: 0,\n     *       generatedLine: 2,\n     *       generatedColumn: 1\n     *     }\n     *   ],\n     *   null\n     * ], 0, 0);\n     * ```\n     */\n\n    decode(mapping: MappingProvider| MapType | string, namesOffset = 0, sourcesOffset = 0): void {\n        mapping = mapping instanceof MappingProvider ? mapping.mapping : mapping;\n        if (Array.isArray(mapping)) {\n            this.decodeMappingArray(mapping, namesOffset, sourcesOffset);\n        } else {\n            this.decodeMappingString(mapping, namesOffset, sourcesOffset);\n        }\n    }\n\n    /**\n     * Retrieves a segment based on the provided generated line and column,\n     * applying the specified bias when the exact match is not found.\n     *\n     * This method performs a binary search on the segments of the specified\n     * generated line to efficiently locate the segment corresponding to\n     * the provided generated column. If an exact match is not found,\n     * the method returns the closest segment based on the specified bias:\n     * - `Bias.BOUND`: No preference for column matching (returns the closest segment).\n     * - `Bias.LOWER_BOUND`: Prefers the closest mapping with a lower column value.\n     * - `Bias.UPPER_BOUND`: Prefers the closest mapping with a higher column value.\n     *\n     * @param generatedLine - The line number of the generated code (1-based index).\n     * @param generatedColumn - The column number of the generated code (0-based index).\n     * @param bias - The bias to use when the line matches, can be one of:\n     *   - `Bias.BOUND` (default): No preference for column matching.\n     *   - `Bias.LOWER_BOUND`: Prefer the closest mapping with a lower column value.\n     *   - `Bias.UPPER_BOUND`: Prefer the closest mapping with a higher column value.\n     * @returns The matching segment if found;\n     * returns null if no segments exist for the specified generated line\n     * or if the generated line is out of bounds.\n     *\n     * @throws { Error } - Throws an error if the generated line is invalid\n     * (out of bounds).\n     *\n     * @example\n     * ```ts\n     * const segment = sourceMap.getSegment(5, 10, Bias.UPPER_BOUND);\n     * if (segment) {\n     *     console.log(`Found segment: line ${segment.line}, column ${segment.column}`);\n     * } else {\n     *     console.log('No matching segment found.');\n     * }\n     * ```\n     */\n\n    getSegment(generatedLine: number, generatedColumn: number, bias: Bias = Bias.BOUND): SegmentInterface | null {\n        const segments = this.mapping[generatedLine - 1];\n        if (!segments || segments.length === 0)\n            return null;\n\n        let low = 0;\n        let high = segments.length - 1;\n        let closestSegment: SegmentInterface | null = null;\n        while (low <= high) {\n            const mid = Math.floor((low + high) / 2);\n            const segment = segments[mid];\n\n            if (segment.generatedColumn < generatedColumn) {\n                low = mid + 1;\n                closestSegment = bias === Bias.LOWER_BOUND ? segment : closestSegment;\n            } else if (segment.generatedColumn > generatedColumn) {\n                high = mid - 1;\n                closestSegment = bias === Bias.UPPER_BOUND ? segment : closestSegment;\n            } else {\n                return segment;\n            }\n        }\n\n        return closestSegment;\n    }\n\n    /**\n     * Retrieves the original segment based on the provided line, column, and source index.\n     *\n     * This method searches for the original segment that corresponds to the specified\n     * line, column, and source index. It uses binary search to find the closest segment\n     * based on the provided bias.\n     *\n     * @param line - The line number of the original code (1-based index).\n     * @param column - The column number of the original code (0-based index).\n     * @param sourceIndex - The index of the source file in the source map.\n     * @param bias - The bias to apply when multiple segments match; defaults to `Bias.BOUND`.\n     * @returns {SegmentInterface | null} - The matching original segment if found;\n     * returns null if no segments exist for the specified line and source index.\n     *\n     * @example\n     * ```ts\n     * const originalSegment = sourceMap.getOriginalSegment(3, 5, 0, Bias.LOWER_BOUND);\n     * if (originalSegment) {\n     *     console.log(`Found original segment: line ${originalSegment.line}, column ${originalSegment.column}`);\n     * } else {\n     *     console.log('No matching original segment found.');\n     * }\n     * ```\n     */\n\n    getOriginalSegment(line: number, column: number, sourceIndex: number, bias: Bias = Bias.BOUND): SegmentInterface | null {\n        let closestSegment: SegmentInterface | null = null;\n        for (const segments of this.mapping) {\n            if (!segments)\n                continue;\n\n            let low = 0;\n            let high = segments.length - 1;\n            while (low <= high) {\n                const mid = Math.floor((low + high) / 2);\n                const midSegment = segments[mid];\n\n                if (midSegment.sourceIndex < sourceIndex || midSegment.line < line) {\n                    low = mid + 1;\n                } else if (midSegment.sourceIndex > sourceIndex || midSegment.line > line) {\n                    high = mid - 1;\n                } else if (midSegment.column < column) {\n                    low = mid + 1;\n                    closestSegment = bias === Bias.LOWER_BOUND ? midSegment : closestSegment;\n                } else if (midSegment.column > column) {\n                    high = mid - 1;\n                    closestSegment = bias === Bias.UPPER_BOUND ? midSegment : closestSegment;\n                } else {\n                    return midSegment;\n                }\n            }\n        }\n\n        return closestSegment;\n    }\n\n    /**\n     * Initializes the segment offsets used to track the current decoding position.\n     *\n     * @param namesOffset - The offset for the names index.\n     * @param sourceIndex - The offset for the source index.\n     * @returns { SegmentOffsetInterface } - The initialized segment offset.\n     */\n\n    private initPositionOffsets(namesOffset: number = 0, sourceIndex: number = 0): SegmentOffsetInterface {\n        return {\n            line: 0,\n            column: 0,\n            nameIndex: namesOffset,\n            sourceIndex: sourceIndex,\n            generatedLine: 0,\n            generatedColumn: 0\n        };\n    }\n\n    /**\n     * Validates the format of an encoded mapping string.\n     *\n     * @param encodedSourceMap - The encoded source map string to validate.\n     * @returns Returns `true` if the format is valid, otherwise `false`.\n     */\n\n    private validateMappingString(encodedSourceMap: string): boolean {\n        // /^(;+)?([a-z0-9+/]{1,10}(,|;+)?)+$/\n        return /^[a-zA-Z0-9+/,;]+$/.test(encodedSourceMap);\n    }\n\n    /**\n     * Validates the properties of a segment to ensure they conform to expected types.\n     *\n     * This method checks that the segment's properties are finite numbers and that\n     * the nameIndex, if provided, is either a finite number or null.\n     * An error is thrown if any of the properties do not meet the specified criteria.\n     *\n     * @param segment - The segment object to validate, which must conform to the\n     *                  SegmentInterface structure, including:\n     *                  - line: number (finite)\n     *                  - column: number (finite)\n     *                  - nameIndex: number | null (if not null, must be finite)\n     *                  - sourceIndex: number (finite)\n     *                  - generatedLine: number (finite)\n     *                  - generatedColumn: number (finite)\n     *\n     * @throws {Error} - Throws an error if any property of the segment is invalid.\n     *                   The error message will specify which property is invalid\n     *                   and the value that was received.\n     */\n\n    private validateSegment(segment: SegmentInterface): void {\n        if (!Number.isFinite(segment.line)) {\n            throw new Error(`Invalid segment: line must be a finite number, received ${segment.line}`);\n        }\n        if (!Number.isFinite(segment.column)) {\n            throw new Error(`Invalid segment: column must be a finite number, received ${segment.column}`);\n        }\n        if (segment.nameIndex !== null && !Number.isFinite(segment.nameIndex)) {\n            throw new Error(`Invalid segment: nameIndex must be a number or null, received ${segment.nameIndex}`);\n        }\n        if (!Number.isFinite(segment.sourceIndex)) {\n            throw new Error(`Invalid segment: sourceIndex must be a finite number, received ${segment.sourceIndex}`);\n        }\n        if (!Number.isFinite(segment.generatedLine)) {\n            throw new Error(`Invalid segment: generatedLine must be a finite number, received ${segment.generatedLine}`);\n        }\n        if (!Number.isFinite(segment.generatedColumn)) {\n            throw new Error(`Invalid segment: generatedColumn must be a finite number, received ${segment.generatedColumn}`);\n        }\n    }\n\n    /**\n     * Encodes a segment into a VLQ-encoded string based on the segment offsets.\n     *\n     * @param segmentOffset - The current segment offset.\n     * @param segmentObject - The segment to encode.\n     * @returns The encoded segment string.\n     */\n\n    private encodeSegment(segmentOffset: SegmentOffsetInterface, segmentObject: SegmentInterface): string {\n        const { line, column, generatedColumn, nameIndex, sourceIndex } = segmentObject;\n        const adjustedLine = line - 1;\n        const adjustedColumn = column - 1;\n        const adjustedGeneratedColumn = generatedColumn - 1;\n\n        const segment: Array<number> = [\n            adjustedGeneratedColumn - segmentOffset.generatedColumn, // generatedColumn difference\n            sourceIndex !== segmentOffset.sourceIndex ? sourceIndex - segmentOffset.sourceIndex : 0, // sourceIndex difference\n            adjustedLine - segmentOffset.line, // line difference\n            adjustedColumn - segmentOffset.column // column difference\n        ];\n\n        if (nameIndex !== null && nameIndex !== undefined) {\n            segment[4] = nameIndex - segmentOffset.nameIndex; // nameIndex difference\n            segmentOffset.nameIndex = nameIndex;\n        }\n\n        segmentOffset.line = adjustedLine;\n        segmentOffset.column = adjustedColumn;\n        segmentOffset.generatedColumn = adjustedGeneratedColumn;\n        segmentOffset.sourceIndex = sourceIndex;\n\n        return encodeArrayVLQ(segment);\n    }\n\n    /**\n     * Encodes the entire mapping array into a VLQ-encoded mapping string.\n     *\n     * @param map - The mapping array to encode.\n     * @returns The encoded mapping string.\n     */\n\n    private encodeMappings(map: MapType): string {\n        const positionOffset = this.initPositionOffsets();\n\n        return map.map(frame => {\n            if (!frame)\n                return '';\n\n            positionOffset.generatedColumn = 0;\n            const segments = frame.map(segment => this.encodeSegment(positionOffset, segment));\n\n            return segments.join(',');\n        }).join(';');\n    }\n\n    /**\n     * Decodes a VLQ-encoded segment into a segment object based on the current offset.\n     *\n     * @param segmentOffset - The current segment offset.\n     * @param decodedSegment - The decoded VLQ segment values.\n     * @returns The decoded segment object.\n     */\n\n    private decodedSegment(segmentOffset: SegmentOffsetInterface, decodedSegment: Array<number>): SegmentInterface {\n        const [ generatedColumn, sourceIndex, sourceLine, sourceColumn, nameIndex ] = decodedSegment;\n        segmentOffset.line += sourceLine;\n        segmentOffset.column += sourceColumn;\n        segmentOffset.nameIndex += nameIndex ?? 0;\n        segmentOffset.sourceIndex += sourceIndex;\n        segmentOffset.generatedColumn += generatedColumn;\n\n        return {\n            line: segmentOffset.line + 1,\n            column: segmentOffset.column + 1,\n            nameIndex: nameIndex !== undefined ? segmentOffset.nameIndex : null,\n            sourceIndex: segmentOffset.sourceIndex,\n            generatedLine: segmentOffset.generatedLine + 1,\n            generatedColumn: segmentOffset.generatedColumn + 1\n        };\n    }\n\n    /**\n     * Decodes a VLQ-encoded mapping string into the internal mapping representation.\n     *\n     * @param encodedMap - The VLQ-encoded mapping string.\n     * @param namesOffset - Offset for the names index.\n     * @param sourceOffset - Offset for the sources index.\n     * @throws { Error } - Throws an error if the mapping string is invalid.\n     */\n\n    private decodeMappingString(encodedMap: string, namesOffset: number, sourceOffset: number): void {\n        if (!this.validateMappingString(encodedMap))\n            throw new Error('Invalid Mappings string format: the provided string does not conform to expected VLQ format.');\n\n        const frames = encodedMap.split(';');\n        const linesOffset = this.mapping.length;\n        const positionOffset = this.initPositionOffsets(namesOffset, sourceOffset);\n        try {\n            frames.forEach((frame, index) => {\n                if (!frame) {\n                    this.mapping.push(null);\n\n                    return;\n                }\n\n                positionOffset.generatedColumn = 0;\n                positionOffset.generatedLine = linesOffset + index;\n                const segmentsArray: Array<SegmentInterface> = frame.split(',')\n                    .map(segment => this.decodedSegment(positionOffset, decodeVLQ(segment)));\n\n                this.mapping.push(segmentsArray);\n            });\n        } catch (error) {\n            throw new Error(`Error decoding mappings at frame index ${frames.length}: ${(<Error>error).message}`);\n        }\n    }\n\n    /**\n     * Decodes a mapping array into the internal mapping representation, adjusting for offsets.\n     *\n     * This method processes each frame in the provided structured mapping array,\n     * validating each segment within the frame and adjusting the indices based on the\n     * specified offsets for names and sources. If a frame is invalid or not an array,\n     * an error will be thrown.\n     *\n     * @param encodedMap - The structured mapping array, which should be an array of frames,\n     *                     where each frame is an array of segments. Each segment must conform\n     *                     to the SegmentInterface.\n     * @param namesOffset - Offset for the names index, which will be added to each segment's nameIndex.\n     * @param sourceOffset - Offset for the sources index, which will be added to each segment's sourceIndex.\n     * @throws { Error } - Throws an error if:\n     *                   - The mapping array is invalid (not an array).\n     *                   - Any frame is not an array.\n     *                   - Any segment does not conform to the SegmentInterface.\n     */\n\n    private decodeMappingArray(encodedMap: MapType, namesOffset: number, sourceOffset: number): void {\n        const linesOffset = this.mapping.length;\n        if (!Array.isArray(encodedMap))\n            throw new Error('Invalid encoded map: expected an array of frames.');\n\n        try {\n            encodedMap.forEach((frame, index) => {\n                if (!frame) {\n                    this.mapping.push(frame);\n\n                    return;\n                }\n\n                if (!Array.isArray(frame))\n                    throw new Error(`Invalid Mappings array format at frame index ${index}: expected an array, received ${typeof frame}.`);\n\n                const segments: FrameType = frame.map(segment => {\n                    this.validateSegment(segment);\n\n                    return {\n                        ...segment,\n                        nameIndex: (typeof segment.nameIndex === 'number') ? segment.nameIndex + namesOffset : null,\n                        sourceIndex: segment.sourceIndex + sourceOffset,\n                        generatedLine: segment.generatedLine + linesOffset\n                    };\n                });\n\n                this.mapping.push(segments);\n            });\n        } catch (error: unknown) {\n            const errorMessage = (error instanceof Error) ? error.message : 'Unknown error';\n            throw new Error(`Error decoding mappings: ${errorMessage}`);\n        }\n    }\n}\n"],
+  "mappings": "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",
+  "names": ["Bias", "decodeVLQ", "encodeArrayVLQ", "MappingProvider", "mapping", "namesOffset", "sourcesOffset", "generatedLine", "generatedColumn", "bias", "segments", "low", "high", "closestSegment", "mid", "segment", "line", "column", "sourceIndex", "midSegment", "encodedSourceMap", "segmentOffset", "segmentObject", "nameIndex", "adjustedLine", "adjustedColumn", "adjustedGeneratedColumn", "map", "positionOffset", "frame", "decodedSegment", "sourceLine", "sourceColumn", "encodedMap", "sourceOffset", "frames", "linesOffset", "index", "segmentsArray", "error", "errorMessage"]
+}

package/dist/services/source.service.js

@@ -0,0 +1,4 @@
+import{MappingProvider as m}from"../providers/mapping.provider.js";import{Bias as c}from"../providers/interfaces/mapping.interface.js";class l{file;mappings;sourceRoot;names;sources;sourcesContent;constructor(e,n=null){typeof e=="string"&&(e=JSON.parse(e)),e=e,this.validateSourceMap(e),this.file=e.file??n,this.names=[...e.names??[]],this.sources=[...e.sources??[]],this.sourceRoot=e.sourceRoot??null,this.sourcesContent=e.sourcesContent?[...e.sourcesContent]:[],this.mappings=new m(e.mappings)}getMapObject(){const e={version:3,names:this.names,sources:this.sources,mappings:this.mappings.encode(),sourcesContent:this.sourcesContent};return this.file&&(e.file=this.file),this.sourceRoot&&(e.sourceRoot=this.sourceRoot),e}concat(...e){if(e.length<1)throw new Error("At least one map must be provided for concatenation.");for(const n of e)this.mappings.decode(n.mappings,this.names.length,this.sources.length),this.names.push(...n.names),this.sources.push(...n.sources),this.sourcesContent.push(...n.sourcesContent??[])}concatNewMap(...e){if(e.length<1)throw new Error("At least one map must be provided for concatenation.");const n=new l(this);for(const t of e)n.mappings.decode(t.mappings,n.names.length,n.sources.length),n.names.push(...t.names),n.sources.push(...t.sources),n.sourcesContent.push(...t.sourcesContent??[]);return n}getPositionByOriginal(e,n,t,r=c.BOUND){let o=t;if(typeof t=="string"&&(o=this.sources.findIndex(i=>i.includes(t))),o<0)return null;const s=this.mappings.getOriginalSegment(e,n,o,r);return s?{name:this.names[s.nameIndex??-1]??null,line:s.line,column:s.column,source:this.sources[s.sourceIndex],sourceRoot:this.sourceRoot,sourceIndex:s.sourceIndex,generatedLine:s.generatedLine,generatedColumn:s.generatedColumn}:null}getPosition(e,n,t=c.BOUND){const r=this.mappings.getSegment(e,n,t);return r?{name:this.names[r.nameIndex??-1]??null,line:r.line,column:r.column,source:this.sources[r.sourceIndex],sourceRoot:this.sourceRoot,sourceIndex:r.sourceIndex,generatedLine:r.generatedLine,generatedColumn:r.generatedColumn}:null}getPositionWithContent(e,n,t=c.BOUND){const r=this.getPosition(e,n,t);return r?{...r,sourcesContent:this.sourcesContent[r.sourceIndex]}:null}getPositionWithCode(e,n,t=c.BOUND,r){const o=this.getPosition(e,n,t);if(!o||!this.sourcesContent[o.sourceIndex])return null;const s=Object.assign({linesAfter:4,linesBefore:3},r),i=this.sourcesContent[o.sourceIndex].split(`
+`),a=Math.min((o.line??1)+s.linesAfter,i.length),u=Math.max((o.line??1)-s.linesBefore,0),p=i.slice(u,Math.min(a+1,i.length)).join(`
+`);return{...o,code:p,endLine:a,startLine:u}}toString(){return JSON.stringify(this.getMapObject())}validateSourceMap(e){if(!["sources","mappings","names"].every(t=>t in e))throw new Error("Missing required keys in SourceMap.")}}export{l as SourceService};
+//# sourceMappingURL=source.service.js.map

package/dist/services/source.service.js.map

@@ -0,0 +1,8 @@
+{
+  "version": 3,
+  "sources": ["../../src/services/source.service.ts"],
+  "sourceRoot": "https://github.com/remotex-lab/xmap/tree/2.0.3/",
+  "sourcesContent": ["/**\n * Import will remove at compile time\n */\n\nimport type {\n    PositionInterface,\n    SourceMapInterface,\n    SourceOptionsInterface,\n    PositionWithCodeInterface,\n    PositionWithContentInterface\n} from './/interfaces/source.interface';\n\n/**\n * Imports\n */\n\nimport { MappingProvider } from '../providers/mapping.provider.js';\nimport { Bias } from '../providers/interfaces/mapping.interface.js';\n\n/**\n * A service for validating and processing source maps.\n * This class allows parsing and manipulation of source maps, providing functionality such as\n * retrieving position mappings between original and generated code, concatenating source maps,\n * and getting code snippets based on mappings.\n *\n * @example\n * ```ts\n * const sourceMapJSON = '{\"version\": 3, \"file\": \"bundle.js\", \"sources\": [\"foo.ts\"], \"names\": [], \"mappings\": \"AAAA\"}';\n * const sourceService = new SourceService(sourceMapJSON);\n *\n * console.log(sourceService.file); // Outputs: 'bundle.js'\n * ```\n */\n\nexport class SourceService {\n    /**\n     * The name of the generated file (bundle) that this source map applies to.\n     *\n     * @example\n     * ```ts\n     * console.log(sourceService.file); // 'bundle.js'\n     * ```\n     */\n\n    readonly file: string | null;\n\n    /**\n     * A MappingProvider instance of base64 VLQ-encoded mappings.\n     */\n\n    readonly mappings: MappingProvider;\n\n    /**\n     * The root URL for the sources, if present in the source map.\n     */\n\n    readonly sourceRoot: string | null;\n\n    /**\n     * A list of symbol names used by the \u201Cmappings\u201D entry.\n     */\n\n    readonly names: Array<string>;\n\n    /**\n     * An array of source file paths.\n     */\n\n    readonly sources: Array<string>;\n\n    /**\n     * An array of source files contents.\n     */\n\n    readonly sourcesContent: Array<string>;\n\n    /**\n     * Creates a new instance of the `SourceService` class.\n     *\n     * This constructor initializes the class using either a `SourceMapInterface` object,\n     * a JSON string representing the source map, or an existing `SourceService` instance.\n     * It validates the source map and populates its properties such as `file`, `sources`, and `mappings`.\n     *\n     * @param source - Can be one of the following:\n     *   - An object conforming to the `SourceMapInterface`.\n     *   - A JSON string representing the source map.\n     *   - A `SourceService` instance to copy the properties.\n     * @param file - (Optional) A string representing the file name of the generated bundle.\n     *               Defaults to `null`. It will overwrite any existing `file` property in the source map.\n     * @throws {Error} - If the source map does not contain required properties or has an invalid format.\n     *\n     * @example\n     * ```ts\n     * const sourceMapJSON = '{\"version\": 3, \"file\": \"bundle.js\", \"sources\": [\"foo.ts\"], \"names\": [], \"mappings\": \"AAAA\"}';\n     * const sourceService = new SourceService(sourceMapJSON);\n     * ```\n     */\n\n    constructor(source: SourceService);\n    constructor(source: SourceMapInterface | string, file?: string | null);\n    constructor(source: SourceService | SourceMapInterface | string, file: string | null = null) {\n        if (typeof source === 'string') {\n            source = <SourceMapInterface> JSON.parse(source);\n        }\n\n        source = <SourceMapInterface> source;\n        this.validateSourceMap(source);\n        this.file = source.file ?? file;\n        this.names =  [ ...source.names ?? [] ];\n        this.sources = [ ...source.sources ?? [] ];\n        this.sourceRoot = source.sourceRoot ?? null;\n        this.sourcesContent = source.sourcesContent ? [ ...source.sourcesContent ] : [];;\n        this.mappings = new MappingProvider(source.mappings);\n    }\n\n    /**\n     * Converts the current source map data into a plain object format.\n     *\n     * @returns The source map json object.\n     *\n     * @example\n     * ```ts\n     * const mapObject = sourceService.getMapObject();\n     * console.log(mapObject.file); // 'bundle.js'\n     * ```\n     */\n\n    getMapObject(): SourceMapInterface {\n        const sourceMap: SourceMapInterface = {\n            version: 3,\n            names: this.names,\n            sources: this.sources,\n            mappings: this.mappings.encode(),\n            sourcesContent: this.sourcesContent\n        };\n\n        if (this.file)\n            sourceMap.file = this.file;\n\n        if (this.sourceRoot)\n            sourceMap.sourceRoot = this.sourceRoot;\n\n        return sourceMap;\n    }\n\n    /**\n     * Concatenates one or more source maps to the current source map.\n     *\n     * This method merges additional source maps into the current source map,\n     * updating the `mappings`, `names`, `sources`, and `sourcesContent` arrays.\n     *\n     * @param maps - An array of `SourceMapInterface` or `SourceService` instances to be concatenated.\n     * @throws { Error } If no source maps are provided for concatenation.\n     *\n     * @example\n     * ```ts\n     * sourceService.concat(anotherSourceMap);\n     * console.log(sourceService.sources); // Updated source paths\n     * ```\n     */\n\n    concat(...maps: Array<SourceMapInterface | SourceService>): void {\n        if (maps.length < 1)\n            throw new Error('At least one map must be provided for concatenation.');\n\n        for (const map of (maps as Array<SourceMapInterface>)) {\n            this.mappings.decode(map.mappings, this.names.length, this.sources.length);\n            this.names.push(...map.names);\n            this.sources.push(...map.sources);\n            this.sourcesContent.push(...map.sourcesContent ?? []);\n        }\n    }\n\n    /**\n     * Creates a new instance of `SourceService` with concatenated source maps.\n     *\n     * @param maps - An array of `SourceMapInterface` or `SourceService` instances to be concatenated.\n     * @returns { SourceService } A new `SourceService` instance with the concatenated maps.\n     * @throws { Error } If no source maps are provided.\n     *\n     * @example\n     * ```ts\n     * const newService = sourceService.concatNewMap(anotherSourceMap);\n     * console.log(newService.file); // The file from the new source map\n     * ```\n     */\n\n    concatNewMap(...maps: Array<SourceMapInterface | SourceService>): SourceService {\n        if (maps.length < 1)\n            throw new Error('At least one map must be provided for concatenation.');\n\n        const sourceService = new SourceService(this);\n        for (const map of (maps as Array<SourceMapInterface>)) {\n            sourceService.mappings.decode(map.mappings, sourceService.names.length, sourceService.sources.length);\n            sourceService.names.push(...map.names);\n            sourceService.sources.push(...map.sources);\n            sourceService.sourcesContent.push(...map.sourcesContent ?? []);\n        }\n\n        return sourceService;\n    }\n\n    /**\n     * Retrieves the position information based on the original source line and column.\n     *\n     * @param line - The line number in the generated code.\n     * @param column - The column number in the generated code.\n     * @param sourceIndex - The index or file path of the original source.\n     * @param bias - The bias to use when matching positions (`Bias.LOWER_BOUND`, `Bias.UPPER_BOUND`, or `Bias.BOUND`).\n     * @returns { PositionInterface | null } The corresponding position in the original source, or `null` if not found.\n     *\n     * @example\n     * ```ts\n     * const position = sourceService.getPositionByOriginal(1, 10, 'foo.ts');\n     * console.log(position?.line); // The line number in the original source\n     * ```\n     */\n\n    getPositionByOriginal(line: number, column: number, sourceIndex: number | string, bias: Bias = Bias.BOUND): PositionInterface | null {\n        let index = <number> sourceIndex;\n        if (typeof sourceIndex === 'string')\n            index = this.sources.findIndex(str => str.includes(sourceIndex));\n\n        if (index < 0)\n            return null;\n\n        const segment = this.mappings.getOriginalSegment(line, column, index, bias);\n        if (!segment)\n            return null;\n\n        return {\n            name: this.names[segment.nameIndex ?? -1] ?? null,\n            line: segment.line,\n            column: segment.column,\n            source: this.sources[segment.sourceIndex],\n            sourceRoot: this.sourceRoot,\n            sourceIndex: segment.sourceIndex,\n            generatedLine: segment.generatedLine,\n            generatedColumn: segment.generatedColumn\n        };\n    }\n\n    /**\n     * Retrieves the position in the original source code based on a given line and column\n     * in the generated code.\n     *\n     * @param line - Line number in the generated code.\n     * @param column - Column number in the generated code.\n     * @param bias - The bias to use for matching positions. Defaults to `Bias.BOUND`.\n     * @returns {PositionInterface | null} The position in the original source, or null if not found.\n     *\n     * @example\n     * ```ts\n     * const position = sourceService.getPosition(2, 15);\n     * console.log(position?.source); // The original source file\n     * ```\n     */\n\n    getPosition(line: number, column: number, bias: Bias = Bias.BOUND): PositionInterface | null {\n        const segment = this.mappings.getSegment(line, column, bias);\n        if (!segment)\n            return null;\n\n        return {\n            name: this.names[segment.nameIndex ?? -1] ?? null,\n            line: segment.line,\n            column: segment.column,\n            source: this.sources[segment.sourceIndex],\n            sourceRoot: this.sourceRoot,\n            sourceIndex: segment.sourceIndex,\n            generatedLine: segment.generatedLine,\n            generatedColumn: segment.generatedColumn\n        };\n    }\n\n    /**\n     * Retrieves the position and original source content for a given position in the generated code.\n     *\n     * @param line - Line number in the generated code.\n     * @param column - Column number in the generated code.\n     * @param bias - Bias used for position matching.\n     * @returns { PositionWithContentInterface | null } The position and its associated content, or `null` if not found.\n     *\n     * @example\n     * ```ts\n     * const positionWithContent = sourceService.getPositionWithContent(3, 5);\n     * console.log(positionWithContent?.sourcesContent); // The source code content\n     * ```\n     */\n\n    getPositionWithContent(line: number, column: number, bias: Bias = Bias.BOUND): PositionWithContentInterface | null {\n        const position = this.getPosition(line, column, bias);\n        if (!position)\n            return null;\n\n        return {\n            ...position,\n            sourcesContent: this.sourcesContent[position.sourceIndex]\n        };\n    }\n\n    /**\n     * Retrieves the position and a code snippet from the original source based on the given\n     * generated code position, with additional lines of code around the matching line.\n     *\n     * @param line - Line number in the generated code.\n     * @param column - Column number in the generated code.\n     * @param bias - Bias used for position matching.\n     * @param options - (Optional) Extra options for the amount of surrounding lines to include.\n     * @returns { PositionWithCodeInterface | null } The position and code snippet.\n     *\n     * @example\n     * ```ts\n     * const positionWithCode = sourceService.getPositionWithCode(4, 8, Bias.BOUND, { linesBefore: 2, linesAfter: 2 });\n     * console.log(positionWithCode?.code); // The code snippet from the original source\n     * ```\n     */\n\n    getPositionWithCode(line: number, column: number, bias: Bias = Bias.BOUND, options?: SourceOptionsInterface): PositionWithCodeInterface | null {\n        const position = this.getPosition(line, column, bias);\n        if (!position || !this.sourcesContent[position.sourceIndex])\n            return null;\n\n        const settings = Object.assign({\n            linesAfter: 4,\n            linesBefore: 3\n        }, options);\n\n        const code = this.sourcesContent[position.sourceIndex].split('\\n');\n        const endLine = Math.min( (position.line ?? 1) + settings.linesAfter, code.length);\n        const startLine = Math.max((position.line ?? 1) - settings.linesBefore, 0);\n        const relevantCode = code.slice(startLine, Math.min(endLine + 1, code.length)).join('\\n');\n\n        return {\n            ...position,\n            code: relevantCode,\n            endLine: endLine,\n            startLine: startLine\n        };\n    }\n\n    /**\n     * Converts the current source map object to a JSON string.\n     *\n     * @returns A stringified version of the source map object.\n     *\n     * @example\n     * ```ts\n     * console.log(sourceService.toString()); // JSON string of the source map\n     * ```\n     */\n\n    toString(): string {\n        return JSON.stringify(this.getMapObject());\n    }\n\n    /**\n     * Validates the provided source map object.\n     *\n     * This method checks whether all required keys are present in the source map object.\n     * It throws an error if any required keys are missing.\n     *\n     * @private\n     * @param input - The source map object to be validated.\n     * @throws Error If any required key is missing from the source map.\n     *\n     * @example\n     * ```ts\n     * const sourceMap = {\n     *     version: 3,\n     *     file: 'example.js',\n     *     names: ['src', 'maps', 'example', 'function', 'line', 'column'],\n     *     sources: ['source1.js', 'source2.js'],\n     *     mappings: 'AAAA,SAASA,CAAC,CAAC,CAAC;AAAA,CAAC,CAAC;AAAC,CAAC',\n     * };\n     * sourceService['validateSource'](sourceMap); // Throws if invalid\n     * ```\n     */\n\n    private validateSourceMap(input: SourceMapInterface): void {\n        const requiredKeys: (keyof SourceMapInterface)[] = [ 'sources', 'mappings', 'names' ];\n        if (!requiredKeys.every(key => key in input)) {\n            throw new Error('Missing required keys in SourceMap.');\n        }\n    }\n}\n"],
+  "mappings": "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",
+  "names": ["MappingProvider", "Bias", "SourceService", "source", "file", "sourceMap", "maps", "map", "sourceService", "line", "column", "sourceIndex", "bias", "index", "str", "segment", "position", "options", "settings", "code", "endLine", "startLine", "relevantCode", "input", "key"]
+}

package/package.json

@@ -2,10 +2,10 @@
     "name": "@remotex-labs/xmap",
     "main": "dist/cjs/index.js",
     "type": "module",
-    "types": "./dist/cjs/index.d.ts",
+    "types": "./dist/index.d.ts",
     "module": "./dist/esm/index.js",
     "author": "Garefild",
-    "version": "2.0.2",
+    "version": "2.0.3",
     "license": "Mozilla Public License Version 2.0",
     "description": "A library with a sourcemap parser and TypeScript code formatter for the CLI",
     "homepage": "https://github.com/remotex-lab/xMap",
@@ -38,11 +38,11 @@
         "./package.json": "./package.json",
         ".": {
             "import": {
-                "types": "./dist/esm/index.d.ts",
+                "types": "./dist/index.d.ts",
                 "default": "./dist/esm/index.js"
             },
             "require": {
-                "types": "./dist/cjs/index.d.ts",
+                "types": "./dist/index.d.ts",
                 "default": "./dist/cjs/index.js"
             }
         }
@@ -55,7 +55,7 @@
     "scripts": {
         "dev": "xBuild -w",
         "test": "jest",
-        "build": "xBuild && xbuild -c xbuild.cjs.ts",
+        "build": "xBuild",
         "test:coverage": "jest --coverage",
         "lint": "xbuild --tc && eslint . -c ./eslint.config.mjs",
         "ci:test": "jest",
@@ -64,13 +64,13 @@
     },
     "devDependencies": {
         "jest": "^29.7.0",
-        "eslint": "^9.12.0",
-        "typescript-eslint": "^8.9.0",
-        "eslint-plugin-jsdoc": "^50.4.1",
+        "eslint": "^9.13.0",
+        "typescript-eslint": "^8.11.0",
+        "eslint-plugin-jsdoc": "^50.4.3",
         "@swc/jest": "^0.2.36",
         "@types/jest": "^29.5.13",
-        "@types/node": "^22.7.5",
-        "@remotex-labs/xbuild": "^1.2.0"
+        "@types/node": "^22.7.8",
+        "@remotex-labs/xbuild": "^1.3.0"
     },
     "dependencies": {
         "typescript": "^5.6.3"

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

@@ -1,26 +0,0 @@
-/**
- * Encodes a given number using Variable-Length Quantity (VLQ) encoding.
- * Negative numbers are encoded by converting to a non-negative representation.
- * The continuation bit is used to indicate if more bytes follow.
- *
- * @param value - The number to be encoded.
- * @returns The VLQ encoded string.
- */
-export declare function encodeVLQ(value: number): string;
-/**
- * Encodes an array of numbers using VLQ encoding.
- * Each number in the array is individually encoded and the results are concatenated.
- *
- * @param values - The array of numbers to be encoded.
- * @returns The concatenated VLQ encoded string.
- */
-export declare function encodeArrayVLQ(values: number[]): string;
-/**
- * Decodes a VLQ encoded string back into an array of numbers.
- * Each character is decoded using the Base64 map and continuation bits are processed.
- *
- * @param data - The VLQ encoded string.
- * @returns The array of decoded numbers.
- * @throws Error If the string contains invalid Base64 characters.
- */
-export declare function decodeVLQ(data: string): number[];

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

@@ -1,66 +0,0 @@
-/**
- * Import will remove at compile time
- */
-import type { PositionWithCodeInterface } from "../services/interfaces/source.interface";
-import type { AnsiOptionInterface, FormatCodeInterface } from "./interfaces/formatter.interface";
-/**
- * Formats a code snippet with optional line padding and custom actions.
- *
- * This function takes a code string and an options object to format the code snippet.
- * It applies padding to line numbers and can trigger custom actions for specific lines.
- *
- * @param code - The source code | stack to be formatted.
- * @param options - Configuration options for formatting the code.
- *   - `padding` (number, optional): Number of characters for line number padding. Defaults to 10.
- *   - `startLine` (number, optional): The starting line number for formatting. Defaults to 1.
- *   - `action` (object, optional): Custom actions to apply to specific lines.
- *     - `triggerLine` (number): The line number where the action should be triggered.
- *     - `callback` (function): A callback function to format the line string when `triggerLine` is matched.
- *       The callback receives the formatted line string, the padding value, and the current line number as arguments.
- *
- * @returns A formatted string of the code snippet with applied padding and custom actions.
- *
- * @example
- * ```typescript
- * const formattedCode = formatCode(code, {
- *     padding: 8,
- *     startLine: 5,
- *     action: {
- *         triggerLine: 7,
- *         callback: (lineString, padding, lineNumber) => {
- *             return `Custom formatting for line ${lineNumber}: ${lineString}`;
- *         }
- *     }
- * });
- * console.log(formattedCode);
- * ```
- */
-export declare function formatCode(code: string, options?: FormatCodeInterface): string;
-/**
- * Formats a code snippet around an error location with special highlighting.
- *
- * This function takes a `sourcePosition` object containing information about the source code
- * and error location, then uses `formatCode` to format and highlight the relevant code snippet.
- *
- * @param sourcePosition - An object containing information about the source code and error location.
- *   - `code` (string): The entire source code content.
- *   - `line` (number): The line number where the error occurred (1-based indexing).
- *   - `column` (number): The column number within the line where the error occurred (1-based indexing).
- *   - `startLine` (number, optional): The starting line number of the code snippet (defaults to 1).
- * @param ansiOption - Optional configuration for ANSI color codes.
- *   - `color` (string): The ANSI escape sequence to colorize the error marker and prefix (e.g., `'\x1b[38;5;160m'`).
- *   - `reset` (string): The ANSI escape sequence to reset the color (e.g., `'\x1b[0m'`).
- *
- * @throws Error - If the provided `sourcePosition` object has invalid line or column numbers,
- *                  or if the error line is outside the boundaries of the provided code content.
- *
- * @returns A formatted string representing the relevant code snippet around the error location,
- *          including special highlighting for the error line and column.
- *
- * @example
- * ```typescript
- * const formattedErrorCode = formatErrorCode(sourcePosition);
- * console.log(formattedErrorCode);
- * ```
- */
-export declare function formatErrorCode(sourcePosition: PositionWithCodeInterface, ansiOption?: AnsiOptionInterface): string;

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";