Add patched kotlin-source-map-loader

libraries/tools/kotlin-source-map-loader/.yarnclean

@@ -0,0 +1,45 @@
+# test directories
+__tests__
+test
+tests
+powered-test
+
+# asset directories
+docs
+doc
+website
+images
+assets
+
+# examples
+example
+examples
+
+# code coverage directories
+coverage
+.nyc_output
+
+# build scripts
+Makefile
+Gulpfile.js
+Gruntfile.js
+
+# configs
+appveyor.yml
+circle.yml
+codeship-services.yml
+codeship-steps.yml
+wercker.yml
+.tern-project
+.gitattributes
+.editorconfig
+.*ignore
+.eslintrc
+.jshintrc
+.flowconfig
+.documentup.json
+.yarn-metadata.json
+.travis.yml
+
+# misc
+*.md

libraries/tools/kotlin-source-map-loader/build.gradle.kts

@@ -0,0 +1,78 @@
+import com.moowork.gradle.node.yarn.YarnTask
+
+description = "Source Map Loader for Webpack"
+
+plugins {
+    id("base")
+    id("com.moowork.node") version "1.2.0"
+}
+
+val default = configurations.getByName(Dependency.DEFAULT_CONFIGURATION)
+val archives = configurations.getByName(Dependency.ARCHIVES_CONFIGURATION)
+
+default.extendsFrom(archives)
+
+plugins.apply("maven")
+
+convention.getPlugin(MavenPluginConvention::class.java).also {
+    it.conf2ScopeMappings.addMapping(MavenPlugin.RUNTIME_PRIORITY, archives, Conf2ScopeMappingContainer.RUNTIME)
+}
+
+node {
+    version = "11.9.0"
+    download = true
+    nodeModulesDir = projectDir
+}
+
+tasks {
+    named("yarn") {
+        outputs.upToDateWhen {
+            projectDir.resolve("node_modules").isDirectory
+        }
+    }
+
+    register<YarnTask>("yarnBuild") {
+        group = "build"
+
+        dependsOn("yarn")
+        setWorkingDir(projectDir)
+        args = listOf("build")
+
+        inputs.files(
+            "kotlin-source-map-loader.js",
+            "package.json",
+            "yarn.lock"
+        )
+        outputs.dir("lib")
+    }
+
+    register<Delete>("cleanYarn") {
+        group = "build"
+
+        delete = setOf(
+            "node_modules",
+            "lib",
+            ".rpt2_cache"
+        )
+    }
+
+    named("clean") {
+        dependsOn("cleanYarn")
+    }
+}
+
+val jar by tasks.creating(Jar::class) {
+    dependsOn(tasks.named("yarnBuild"))
+    from(projectDir.resolve("lib"))
+}
+
+artifacts {
+    add(
+        "archives",
+        jar.archiveFile.get().asFile
+    ) {
+        builtBy(jar)
+    }
+}
+
+publish()

libraries/tools/kotlin-source-map-loader/kotlin-source-map-loader.js

@@ -0,0 +1,141 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var fs = require("fs");
+var path = require("path");
+var async = require("async");
+var loaderUtils = require("loader-utils");
+
+// Matches only the last occurrence of sourceMappingURL
+var baseRegex = "\\s*[@#]\\s*sourceMappingURL\\s*=\\s*([^\\s]*)(?![\\S\\s]*sourceMappingURL)",
+    // Matches /* ... */ comments
+    regex1 = new RegExp("/\\*" + baseRegex + "\\s*\\*/"),
+    // Matches // .... comments
+    regex2 = new RegExp("//" + baseRegex + "($|\n|\r\n?)"),
+    // Matches DataUrls
+    regexDataUrl = /data:[^;\n]+(?:;charset=[^;\n]+)?;base64,([a-zA-Z0-9+/]+={0,2})/;
+
+module.exports = function (input, inputMap) {
+    this.cacheable && this.cacheable();
+    var resolve = this.resolve;
+    var addDependency = this.addDependency;
+    var emitWarning = this.emitWarning || function () {
+    };
+    var match = input.match(regex1) || input.match(regex2);
+    if (match) {
+        var url = match[1];
+        var dataUrlMatch = regexDataUrl.exec(url);
+        var callback = this.async();
+        if (dataUrlMatch) {
+            var mapBase64 = dataUrlMatch[1];
+            var mapStr = (new Buffer(mapBase64, "base64")).toString();
+            var map;
+            try {
+                map = JSON.parse(mapStr)
+            }
+            catch (e) {
+                emitWarning("Cannot parse inline SourceMap '" + mapBase64.substr(0, 50) + "': " + e);
+                return untouched();
+            }
+            processMap(map, this.context, callback);
+        }
+        else {
+            resolve(this.context, loaderUtils.urlToRequest(url, true), function (err, result) {
+                if (err) {
+                    emitWarning("Cannot find SourceMap '" + url + "': " + err);
+                    return untouched();
+                }
+                addDependency(result);
+                fs.readFile(result, "utf-8", function (err, content) {
+                    if (err) {
+                        emitWarning("Cannot open SourceMap '" + result + "': " + err);
+                        return untouched();
+                    }
+                    var map;
+                    try {
+                        map = JSON.parse(content);
+                    }
+                    catch (e) {
+                        emitWarning("Cannot parse SourceMap '" + url + "': " + e);
+                        return untouched();
+                    }
+                    processMap(map, path.dirname(result), callback);
+                });
+            }.bind(this));
+
+        }
+    }
+    else {
+        var callback = this.callback;
+        return untouched();
+    }
+
+    function untouched() {
+        callback(null, input, inputMap);
+    }
+
+    function resize(arr, size, defval) {
+        while (arr.length > size) {
+            arr.pop();
+        }
+        while (arr.length < size) {
+            arr.push(defval);
+        }
+    }
+
+    function processMap(map, context, callback) {
+        function setResult(map) {
+            callback(null, input.replace(match[0], ''), map);
+        }
+
+        var sourcesWithoutContent = [];
+        map.sourcesContent = map.sourcesContent || [];
+        resize(map.sourcesContent, map.sources.length, null);
+        map.sourcesContent.forEach(function (sourceContent, i) {
+            if (!sourceContent) {
+                sourcesWithoutContent.push({source: map.sources[i], index: i})
+            }
+        });
+
+        if (sourcesWithoutContent.length == 0) {
+            setResult(map)
+        }
+        else {
+            var sourcePrefix = map.sourceRoot ? map.sourceRoot + "/" : "";
+            async.map(sourcesWithoutContent, function (item, callback) {
+                var source = sourcePrefix + item.source;
+                map.sources = map.sources.map(function (s) {
+                    return sourcePrefix + s;
+                });
+                delete map.sourceRoot;
+                resolve(context, loaderUtils.urlToRequest(source, true), function (err, result) {
+                    if (err) {
+                        emitWarning("Cannot find source file '" + source + "': " + err);
+                        return callback(null, null);
+                    }
+                    addDependency(result);
+                    fs.readFile(result, "utf-8", function (err, content) {
+                        if (err) {
+                            emitWarning("Cannot open source file '" + result + "': " + err);
+                            return callback(null, null);
+                        }
+                        callback(null, {
+                            index: item.index,
+                            source: result,
+                            content: content
+                        });
+                    });
+                });
+            }, function (err, info) {
+                info.forEach(function (item) {
+                    if (item) {
+                        map.sources[item.index] = item.source;
+                        map.sourcesContent[item.index] = item.content;
+                    }
+                });
+                setResult(map);
+            });
+        }
+    }
+};

libraries/tools/kotlin-source-map-loader/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@kotlin/source-map-loader",
+  "version": "0.0.1",
+  "description": "Modern source-map-loader with additional features",
+  "main": "lib/kotlin-source-map-loader.js",
+  "files": [
+    "lib/**/*"
+  ],
+  "scripts": {
+    "build": "cpx \"kotlin-source-map-loader.js\" lib"
+  },
+  "dependencies": {
+  },
+  "devDependencies": {
+    "cpx": "^1.5.0"
+  }
+}