Handle sourceMappingURL comments, including base64 encoded ones

microsoft · weswigham · Mar 26, 2018 · Feb 15, 2018 · Feb 17, 2018 · Mar 16, 2018
commit 6a467ba0415597bd8b7ce993b1ba620f74a077d9
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
@@ -457,6 +457,7 @@ namespace ts {
         clearTimeout?(timeoutId: any): void;
         clearScreen?(): void;
         /*@internal*/ setBlocking?(): void;
+        base64decode?(input: string): string;
     }
 
     export interface FileWatcher {
@@ -528,6 +529,8 @@ namespace ts {
               _crypto = undefined;
             }
 
+            const Buffer: typeof global.Buffer = require("buffer").Buffer;
+
             const nodeVersion = getNodeMajorVersion();
             const isNode4OrLater = nodeVersion >= 4;
 
@@ -620,6 +623,9 @@ namespace ts {
                     if (process.stdout && process.stdout._handle && process.stdout._handle.setBlocking) {
                         process.stdout._handle.setBlocking(true);
                     }
+                },
+                base64decode: input => {
+                    return Buffer.from(input, "base64").toString("utf8");
                 }
             };
             return nodeSystem;

diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -3463,6 +3463,42 @@ namespace ts {
         return result;
     }
 
+    export function base64decode(host: { base64decode?(input: string): string }, input: string): string {
+        if (host.base64decode) {
+            return host.base64decode(input);
+        }
+        let result = "";
+        const length = input.length;
+        let i = 0;
+        while (i < length) {
+            // Stop decoding once padding characters are present
+            if (input.charCodeAt(i) === base64Digits.charCodeAt(64)) {
+                break;
+            }
+            // convert 4 input digits into three characters, ignoring padding characters at the end
+            const ch1 = base64Digits.indexOf(input[i]);
+            const ch2 = base64Digits.indexOf(input[i + 1]);
+            const ch3 = base64Digits.indexOf(input[i + 2]);
+            const ch4 = base64Digits.indexOf(input[i + 3]);
+
+            const code1 = (ch1 & 0B00111111 << 2) | (ch2 & 0B00000011);
+            const code2 = (ch2 & 0B00001111 << 4) | (ch3 & 0B00001111);
+            const code3 = (ch3 & 0B00000011 << 6) | (ch4 & 0B00111111);
+
+            if (code2 === 0 && ch3 !== 0) { // code2 decoded to zero, but ch3 was padding - elide code2 and code3
+                result += String.fromCharCode(code1);
+            }
+            else if (code3 === 0 && ch4 !== 0) { // code3 decoded to zero, but ch4 was padding, elide code3
+                result += `${String.fromCharCode(code1)}${String.fromCharCode(code2)}`;
+            }
+            else {
+                result += `${String.fromCharCode(code1)}${String.fromCharCode(code2)}${String.fromCharCode(code3)}`;
+            }
+            i += 4;
+        }
+        return result;
+    }
+
     const carriageReturnLineFeed = "\r\n";
     const lineFeed = "\n";
     export function getNewLineCharacter(options: CompilerOptions | PrinterOptions, getNewLine?: () => string): string {

diff --git a/src/services/services.ts b/src/services/services.ts
@@ -1573,22 +1573,29 @@ namespace ts {
             return checker.getSymbolAtLocation(node);
         }
 
-        function getSourceMapper(fileName: string, file: { sourceMapper?: sourcemaps.SourceMapper }) {
-            if (!host.readFile || !host.fileExists) {
-                return file.sourceMapper = sourcemaps.identitySourceMapper;
-            }
-            if (file.sourceMapper) {
-                return file.sourceMapper;
+
+        const sourceMapCommentRE = /^\/\/[@#] sourceMappingURL=(.+)$/gm;
+        const dataURLRE = /^data:/;
+        const base64URLRE = /^data:application\/json;charset=utf-8;base64,(.+)$/;
+        function scanForSourcemapURL(fileName: string) {
+            const mappedFile = sourcemappedFileCache.get(toPath(fileName, currentDirectory, getCanonicalFileName));
+            if (!mappedFile) {
+                return;
             }
-            // TODO (weswigham): Read sourcemappingurl from last line of .d.ts if present
-            const mapFileName = fileName + ".map";
-            if (!host.fileExists(mapFileName)) {
-                return file.sourceMapper = sourcemaps.identitySourceMapper;
+            const starts = getLineStarts(mappedFile);
+            for (let index = starts.length - 1; index--; index >= 0) {
+                sourceMapCommentRE.lastIndex = starts[index];
+                const comment = sourceMapCommentRE.exec(mappedFile.text);
+                if (comment) {
+                    return comment[1];
+                }
             }
-            const doc = host.readFile(mapFileName);
+        }
+
+        function convertDocumentToSourceMapper(file: { sourceMapper?: sourcemaps.SourceMapper }, contents: string, mapFileName: string) {
             let maps: sourcemaps.SourceMapData;
             try {
-                maps = JSON.parse(doc);
+                maps = JSON.parse(contents);
             }
             catch {
                 // swallow error
@@ -1605,6 +1612,36 @@ namespace ts {
             }, mapFileName, maps, program, sourcemappedFileCache);
         }
 
+        function getSourceMapper(fileName: string, file: { sourceMapper?: sourcemaps.SourceMapper }) {
+            if (!host.readFile || !host.fileExists) {
+                return file.sourceMapper = sourcemaps.identitySourceMapper;
+            }
+            if (file.sourceMapper) {
+                return file.sourceMapper;
+            }
+            let mapFileName = scanForSourcemapURL(fileName);
+            if (mapFileName && dataURLRE.exec(mapFileName)) {
+                const b64EncodedMatch = base64URLRE.exec(mapFileName);
+                if (b64EncodedMatch) {
+                    const base64Object = b64EncodedMatch[1];
+                    return convertDocumentToSourceMapper(file, base64decode(sys, base64Object), fileName);
+                }
+                mapFileName = undefined;
+            }
+            const possibleMapLocations: string[] = [];
+            if (mapFileName) {
+                possibleMapLocations.push(mapFileName);
+            }
+            possibleMapLocations.push(fileName + ".map");
+            for (const location of possibleMapLocations) {
+                const mapPath = toPath(location, getDirectoryPath(fileName), getCanonicalFileName);
+                if (host.fileExists(mapPath)) {
+                    return convertDocumentToSourceMapper(file, host.readFile(mapPath), mapPath);
+                }
+            }
+            return file.sourceMapper = sourcemaps.identitySourceMapper;
+        }
+
         function makeGetTargetOfMappedPosition<TIn>(
             extract: (original: TIn) => sourcemaps.SourceMappableLocation,
             create: (result: sourcemaps.SourceMappableLocation, original: TIn) => TIn

diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -2893,6 +2893,7 @@ declare namespace ts {
         setTimeout?(callback: (...args: any[]) => void, ms: number, ...args: any[]): any;
         clearTimeout?(timeoutId: any): void;
         clearScreen?(): void;
+        base64decode?(input: string): string;
     }
     interface FileWatcher {
         close(): void;

diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
@@ -2893,6 +2893,7 @@ declare namespace ts {
         setTimeout?(callback: (...args: any[]) => void, ms: number, ...args: any[]): any;
         clearTimeout?(timeoutId: any): void;
         clearScreen?(): void;
+        base64decode?(input: string): string;
     }
     interface FileWatcher {
         close(): void;