smipper 27.0.0 → 28.0.0

package/dist/Cache.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = exports.CacheEntry = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class CacheEntry {
+    constructor(key, smipper, trim) {
+        this.key = key;
+        this.smipper = smipper;
+        this.entries = new Map();
+        this.trim = trim;
+    }
+    add(url, contents) {
+        this.entries.set(url, contents);
+    }
+    write() {
+        if (!this.entries.size) {
+            return;
+        }
+        const tempdir = fs.mkdtempSync(this.smipper.cacheDir);
+        try {
+            for (const [url, contents] of this.entries) {
+                const encoded = encodeURIComponent(url);
+                fs.writeFileSync(path.join(tempdir, encoded), contents);
+            }
+            const dest = path.join(this.smipper.cacheDir, `smipper:${encodeURIComponent(this.key)}`);
+            fs.renameSync(tempdir, dest);
+            this.smipper.verbose("Moved", this.entries.keys(), "from", tempdir, "to", dest);
+            this.trim();
+        }
+        catch (err) {
+            this.smipper.verbose("Got error writing file(s)", err);
+            fs.rmSync(tempdir, { recursive: true, force: true });
+        }
+    }
+}
+exports.CacheEntry = CacheEntry;
+class Cache {
+    constructor(smipper) {
+        this.smipper = smipper;
+        this.smipper.verbose("Created cache", this.smipper.cacheDir, this.smipper.cacheSize);
+        if (!fs.existsSync(smipper.cacheDir)) {
+            fs.mkdirSync(smipper.cacheDir, { recursive: true });
+        }
+        else {
+            this.trim();
+        }
+    }
+    trim() {
+        try {
+            const dirs = fs
+                .readdirSync(this.smipper.cacheDir, { withFileTypes: true })
+                .filter((x) => x.isDirectory() && x.name.startsWith("smipper:"))
+                .map((x) => path.join(this.smipper.cacheDir, x.name))
+                .sort((l, r) => fs.statSync(l).mtimeMs - fs.statSync(r).mtimeMs);
+            this.smipper.verbose("trim", this.smipper.cacheDir, this.smipper.cacheSize, "=>", dirs);
+            while (dirs.length > this.smipper.cacheSize) {
+                const dir = dirs[0] || "";
+                this.smipper.verbose("removing directory", dir);
+                fs.rmSync(dir, { recursive: true, force: true });
+                dirs.shift();
+            }
+        }
+        catch (err) {
+            /* */
+        }
+    }
+    get(key, url) {
+        const file = path.join(this.smipper.cacheDir, `smipper:${encodeURIComponent(key)}`, encodeURIComponent(url));
+        try {
+            return fs.readFileSync(file, "utf8");
+        }
+        catch (err) {
+            this.smipper.verbose("Failed to read file", file, err);
+            return undefined;
+        }
+    }
+    create(key) {
+        return new CacheEntry(key, this.smipper, this.trim.bind(this));
+    }
+}
+exports.Cache = Cache;

package/dist/Smipper.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/buildStackLine.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStackLine = void 0;
+function buildStackLine(functionName, url, line, column) {
+    return `${functionName ? "at " + functionName + " " : ""}${url}:${line}:${column}`;
+}
+exports.buildStackLine = buildStackLine;

package/dist/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const init_1 = require("./init");
+const run_1 = require("./run");
+const smipper = (0, init_1.init)();
+if (smipper.stack === undefined) {
+    console.error("Nothing to smip");
+    process.exit(1);
+}
+(0, run_1.run)(smipper)
+    .then((output) => {
+    console.log(output);
+    if (smipper.cacheEntry) {
+        smipper.verbose("Writing cache entry");
+        smipper.cacheEntry.write();
+    }
+    process.exit(0);
+})
+    .catch((error) => {
+    console.error(error.message);
+    process.exit(2);
+});

package/dist/init.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const Cache_1 = require("./Cache");
+function init() {
+    let smipper = {
+        verbose: () => { },
+        json: false,
+        jsc: 0,
+        cacheDir: path_1.default.join(os_1.default.homedir(), ".cache", "smipper", "cache"),
+        cacheSize: 10,
+        sourceMaps: {}
+    };
+    for (const key in process.env) {
+        switch (key) {
+            case "SMIPPER_CACHE_KEY":
+                smipper.cacheKey = process.env[key];
+                break;
+            case "SMIPPER_CACHE_SIZE":
+                smipper.cacheSize = process.env[key] ? parseInt(process.env[key] || "") : 0;
+                break;
+            case "SMIPPER_CACHE_DIR":
+                smipper.cacheDir = process.env[key] || "";
+                break;
+            case "SMIPPER_VERBOSE": {
+                const val = process.env[key];
+                if (val && val !== "false" && val !== "0") {
+                    smipper.verbose = console.error.bind(console);
+                }
+                break;
+            }
+        }
+    }
+    const usage = "smipper [stack|-h|--help|-v|--verbose|--version|--jsc|--json|--file=@FILE@|-f=@FILE@|--cache-key=$CACHE_KEY$|--cache-dir=$CACHE_DIR$|--cache-size=$CACHE_SIZE$|-";
+    for (let i = 2; i < process.argv.length; ++i) {
+        try {
+            const arg = process.argv[i] || "";
+            smipper.verbose("got arg", arg);
+            if (arg === "-f" || arg === "--file") {
+                smipper.stack = fs_1.default.readFileSync(process.argv[++i]).toString();
+            }
+            else if (arg.startsWith("-f")) {
+                smipper.stack = fs_1.default.readFileSync(arg.substring(2)).toString();
+            }
+            else if (arg.startsWith("--file=")) {
+                smipper.stack = fs_1.default.readFileSync(arg.substring(7)).toString();
+            }
+            else if (arg === "--verbose" || arg === "-v") {
+                smipper.verbose = console.error.bind(console);
+            }
+            else if (arg === "--version") {
+                console.log(JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, "package.json"), "utf8")).version);
+                process.exit(0);
+            }
+            else if (arg === "--json") {
+                smipper.json = true;
+            }
+            else if (arg === "--cache-key") {
+                smipper.cacheKey = process.argv[++i] || "";
+            }
+            else if (arg.startsWith("--cache-key=")) {
+                smipper.cacheKey = arg.substring(12);
+            }
+            else if (arg === "--cache-size") {
+                smipper.cacheSize = parseInt(String(process.argv[++i]));
+            }
+            else if (arg.startsWith("--cache-size=")) {
+                smipper.cacheSize = parseInt(arg.substring(13));
+            }
+            else if (arg === "--cache-dir") {
+                smipper.cacheDir = String(process.argv[++i]);
+            }
+            else if (arg.startsWith("--cache-dir=")) {
+                smipper.cacheDir = arg.substring(12);
+            }
+            else if (arg === "--jsc") {
+                // jsc has the wrong column for some reason
+                smipper.jsc = 1;
+            }
+            else if (arg === "-h" || arg === "--help") {
+                console.log(usage);
+                process.exit(0);
+            }
+            else if (arg === "-") {
+                // stdin
+            }
+            else {
+                smipper.stack = arg;
+            }
+        }
+        catch (err) {
+            console.error("Error: " + err.toString());
+            process.exit(1);
+        }
+    }
+    if (isNaN(smipper.cacheSize)) {
+        console.error(usage);
+        process.exit(1);
+    }
+    if (smipper.cacheKey) {
+        smipper.cache = new Cache_1.Cache(smipper);
+    }
+    if (!smipper.stack) {
+        smipper.stack = fs_1.default.readFileSync("/dev/stdin").toString();
+        if (!smipper.stack) {
+            console.error("Nothing to do");
+            process.exit(0);
+        }
+    }
+    return smipper;
+}
+exports.init = init;

package/dist/load.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = void 0;
+const rewriteLocalControl_1 = require("./rewriteLocalControl");
+const fs_1 = __importDefault(require("fs"));
+const got_1 = __importDefault(require("got"));
+async function load(smipper, path) {
+    if (path.startsWith("http://localcontrol.netflix.com/")) {
+        return (0, rewriteLocalControl_1.rewriteLocalControl)(path);
+    }
+    if (path.startsWith("file:///")) {
+        return fs_1.default.readFileSync(path.substring(7), "utf8");
+    }
+    if (!path.startsWith("http://") && !path.startsWith("https://")) {
+        throw new Error("Not a url");
+    }
+    if (smipper.cache && smipper.cacheKey) {
+        const response = smipper.cache.get(smipper.cacheKey, path);
+        if (response) {
+            return response;
+        }
+        if (!smipper.cacheEntry) {
+            smipper.cacheEntry = smipper.cache.create(smipper.cacheKey);
+        }
+    }
+    // let retryIndex = 0;
+    async function get() {
+        const response = await got_1.default.get(path, { timeout: 10000 });
+        smipper.verbose(response.headers);
+        return response.body || "";
+    }
+    const response = await get();
+    if (smipper.cacheEntry) {
+        smipper.cacheEntry.add(path, response);
+    }
+    return response;
+}
+exports.load = load;

package/dist/loadUri.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadUri = void 0;
+const sourceMap = __importStar(require("source-map"));
+const load_1 = require("./load");
+async function loadUri(smipper, path) {
+    if (path[0] === "/") {
+        path = "file://" + path;
+    }
+    return new Promise((resolve, reject) => {
+        smipper.verbose("loading", path);
+        if (!(path in smipper.sourceMaps)) {
+            smipper.sourceMaps[path] = {
+                resolvers: [resolve],
+                rejecters: [reject]
+            };
+            (0, load_1.load)(smipper, path)
+                .then((jsData) => {
+                const idx = jsData.lastIndexOf("//# sourceMappingURL=");
+                smipper.verbose("Got the file", jsData.length, idx);
+                if (idx == -1) {
+                    return path + ".map";
+                }
+                const mapUrl = jsData.substring(idx + 21);
+                const match = /^(data:.+\/.+;)base64,/.exec(mapUrl);
+                if (match) {
+                    return mapUrl.substring(match[1].length);
+                }
+                if (mapUrl.indexOf("://") != -1) {
+                    return mapUrl;
+                }
+                // console.log(mapUrl);
+                return new URL(mapUrl, path).href;
+            })
+                .then((mapUrl) => {
+                // console.log(mapUrl.substring(0, 20));
+                if (mapUrl.startsWith("base64,")) {
+                    return Buffer.from(mapUrl.substring(7), "base64").toString();
+                }
+                return (0, load_1.load)(smipper, mapUrl);
+            })
+                .then(async (sourceMapData) => {
+                const parsed = JSON.parse(sourceMapData);
+                const smap = await new sourceMap.SourceMapConsumer(parsed);
+                const pending = smipper.sourceMaps[path];
+                // sourceMaps.delete(path);
+                if (pending) {
+                    pending.resolvers.forEach((func) => {
+                        func(smap);
+                    });
+                }
+            })
+                .catch((err) => {
+                const pending = smipper.sourceMaps[path];
+                if (!pending) {
+                    throw new Error("Gotta have pending");
+                }
+                // sourceMaps.delete(path);
+                pending.rejecters.forEach((func) => {
+                    func(err);
+                });
+            });
+        }
+        else {
+            const cur = smipper.sourceMaps[path];
+            smipper.verbose("path is in source maps already", cur);
+            if (!cur) {
+                throw new Error("Gotta have cur");
+            }
+            cur.resolvers.push(resolve);
+            cur.rejecters.push(reject);
+        }
+    });
+}
+exports.loadUri = loadUri;

package/dist/processFrame.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFrame = void 0;
+const loadUri_1 = require("./loadUri");
+const buildStackLine_1 = require("./buildStackLine");
+const fs_1 = __importDefault(require("fs"));
+function processFrame(smipper, functionName, url, line, column) {
+    smipper.verbose("got frame", functionName, url, line, column);
+    if (functionName.endsWith("@")) {
+        functionName = functionName.substring(0, functionName.length - 1);
+    }
+    return new Promise((resolve) => {
+        let newUrl, newLine, newColumn;
+        smipper.verbose("calling loadUri", url);
+        if (!url.includes("://") && url[0] !== "/" && fs_1.default.existsSync(url)) {
+            url = `file://${process.cwd()}/${url}`;
+        }
+        return (0, loadUri_1.loadUri)(smipper, url)
+            .then((smap) => {
+            smipper.verbose("got map", url, Object.keys(smap));
+            // it appears that we're supposed to reduce the column
+            // number by 1 when we get this from jsc
+            const pos = smap.originalPositionFor({ line, column: column - smipper.jsc });
+            if (!pos.source) {
+                smipper.verbose("nothing here", pos);
+                throw new Error("Mapping not found");
+            }
+            // smc.sourceContentFor(pos.source);
+            newUrl = pos.source;
+            newLine = pos.line || 0;
+            newColumn = pos.column || 0;
+        })
+            .catch((err) => {
+            smipper.verbose("didn't get map", url, err);
+            // console.error(err);
+        })
+            .finally(() => {
+            if (smipper.json) {
+                const ret = {
+                    functionName: functionName,
+                    sourceURL: newUrl ? newUrl : url,
+                    line: newUrl ? newLine : line,
+                    column: newUrl ? newColumn : column
+                };
+                // if (newUrl) {
+                //     ret.oldSourceURL = url;
+                //     ret.oldLine = line;
+                //     ret.oldColumn = column;
+                // }
+                // if (newUrl) {
+                //     ret.newUrl = newUrl;
+                //     ret.newLine = newLine;
+                //     ret.newColumn = newColumn;
+                // }
+                resolve(ret);
+            }
+            else {
+                let str;
+                if (newUrl) {
+                    str = `${(0, buildStackLine_1.buildStackLine)(functionName, newUrl, newLine, newColumn)} (${(0, buildStackLine_1.buildStackLine)("", url, line, column)})`;
+                }
+                else {
+                    str = (0, buildStackLine_1.buildStackLine)(functionName, url, line, column);
+                }
+                resolve(str);
+            }
+        });
+    });
+}
+exports.processFrame = processFrame;

package/dist/rewriteLocalControl.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewriteLocalControl = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function findFile(dir, fn) {
+    const list = fs_1.default.readdirSync(dir);
+    for (let file of list) {
+        const match = file === fn;
+        file = dir + "/" + file;
+        const stat = fs_1.default.statSync(file);
+        if (stat && stat.isDirectory()) {
+            const ret = findFile(file, fn);
+            if (ret) {
+                return ret;
+            }
+        }
+        else if (match) {
+            return "file://" + file;
+        }
+    }
+    return undefined;
+}
+function rewriteLocalControl(url) {
+    const found = findFile(process.cwd(), path_1.default.basename(url.substring(6)));
+    if (found) {
+        return found;
+    }
+    throw new Error("Couldn't resolve localcontrol " + url);
+}
+exports.rewriteLocalControl = rewriteLocalControl;

package/dist/run.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const processFrame_1 = require("./processFrame");
+const assert_1 = __importDefault(require("assert"));
+const runJSON_1 = require("./runJSON");
+async function run(smipper) {
+    if (smipper.json) {
+        return (0, runJSON_1.runJSON)(smipper);
+    }
+    (0, assert_1.default)(smipper.stack !== undefined);
+    return Promise.all(smipper.stack
+        .split("\n")
+        .filter((x) => x)
+        .map((x) => {
+        x = x.trim();
+        let match = / *at *([^ ]*).* \(?([^ ]+):([0-9]+):([0-9]+)/.exec(x);
+        if (!match) {
+            match = /([^ ]+@)?(.*):([0-9]+):([0-9]+)/.exec(x);
+        }
+        smipper.verbose(x, " => ", match);
+        if (!match) {
+            const nolinecol = /([^ ]*)(.*)/.exec(x);
+            if (nolinecol) {
+                return nolinecol[0];
+            }
+            return x;
+        }
+        return (0, processFrame_1.processFrame)(smipper, match[1] || "", match[2] || "", parseInt(match[3] || ""), parseInt(match[4] || ""));
+    }))
+        .then((results) => {
+        if (!results.length) {
+            throw new Error("Empty output");
+        }
+        return results.join("\n");
+    })
+        .catch((error) => {
+        console.error("Got an error", error);
+        process.exit(3);
+    });
+}
+exports.run = run;

package/dist/runJSON.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runJSON = void 0;
+const assert_1 = __importDefault(require("assert"));
+const processFrame_1 = require("./processFrame");
+async function runJSON(smipper) {
+    (0, assert_1.default)(smipper.json);
+    let parsed;
+    try {
+        (0, assert_1.default)(typeof smipper.stack === "string");
+        parsed = JSON.parse(smipper.stack);
+        if (!Array.isArray(parsed)) {
+            throw new Error("Expected array");
+        }
+    }
+    catch (err) {
+        throw new Error(`Can't parse json ${err}`);
+    }
+    try {
+        const results = await Promise.all(parsed.map((frame) => {
+            smipper.verbose("got frame frame", frame);
+            return (0, processFrame_1.processFrame)(smipper, frame.functionName || "", frame.sourceURL || "", frame.line, frame.column);
+        }));
+        results.forEach((frame, index) => {
+            if (typeof frame !== "object") {
+                throw new Error("Huh?");
+            }
+            frame.index = index;
+        });
+        // console.log("shit", results);
+        return JSON.stringify(results, null, 4);
+    }
+    catch (error) {
+        throw new Error(`Got an error: ${error.message}`);
+    }
+}
+exports.runJSON = runJSON;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,16 +1,16 @@
 {
     "name": "smipper",
-    "version": "27.0.0",
+    "version": "28.0.0",
     "description": "",
     "main": "./index.js",
     "bin": {
-        "smipper": "./index.js"
+        "smipper": "./dist/index.js"
     },
     "files": [
-        "index.js"
+        "dist"
     ],
     "scripts": {
-        "build": "node ./node_modules/.bin/tsc index.ts && chmod +x ./index.js",
+        "build": "node ./node_modules/.bin/tsc --target es2020 --module node16 src/index.ts --outDir ./dist && chmod +x ./dist/index.js",
         "test": "echo \"Error: no test specified\" && exit 1"
     },
     "author": "",

package/index.js

@@ -1,403 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-exports.__esModule = true;
-var fs = require("fs");
-var got = require("got");
-var path = require("path");
-var sourceMap = require("source-map");
-var url = require("url");
-var verbose = false;
-var stack;
-var json = false;
-var retries = 3;
-var jsc = 0;
-for (var i = 2; i < process.argv.length; ++i) {
-    try {
-        var arg = process.argv[i] || "";
-        if (verbose) {
-            console.error("got arg", arg);
-        }
-        if (arg === "-f" || arg === "--file") {
-            stack = fs.readFileSync(process.argv[++i]).toString();
-        }
-        else if (arg.startsWith("-f")) {
-            stack = fs.readFileSync(arg.substring(2)).toString();
-        }
-        else if (arg.startsWith("--file=")) {
-            stack = fs.readFileSync(arg.substring(7)).toString();
-        }
-        else if (arg === "--verbose" || arg === "-v") {
-            verbose = true;
-        }
-        else if (arg === "--version") {
-            console.log(JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf8")).version);
-            process.exit(0);
-        }
-        else if (arg === "--json") {
-            json = true;
-        }
-        else if (arg === "--jsc") {
-            // jsc has the wrong column for some reason
-            jsc = 1;
-        }
-        else if (arg.startsWith("--retries")) {
-            retries = parseInt(arg.substring(9));
-            if (isNaN(retries) || retries < 0) {
-                console.error("smipper [stack|-h|--help|-v|--verbose|--version|--retries=<number>|--jsc|--json|-f=@FILE@|-");
-                process.exit(1);
-            }
-        }
-        else if (arg === "-h" || arg === "--help") {
-            console.error("smipper [stack|-h|--help|-v|--verbose|--version|--retries=<number>|--jsc|--json|-f=@FILE@|-");
-            process.exit(0);
-        }
-        else if (arg === "-") {
-            // stdin
-        }
-        else {
-            stack = arg;
-        }
-    }
-    catch (err) {
-        console.error("Error: " + err.toString());
-        process.exit(1);
-    }
-}
-if (!stack) {
-    stack = fs.readFileSync("/dev/stdin").toString();
-    if (!stack) {
-        console.error("Nothing to do");
-        process.exit(0);
-    }
-}
-function build(functionName, url, line, column) {
-    return "".concat(functionName ? "at " + functionName + " " : "").concat(url, ":").concat(line, ":").concat(column);
-}
-function findFile(dir, fn) {
-    var list = fs.readdirSync(dir);
-    for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
-        var file = list_1[_i];
-        var match = file === fn;
-        file = dir + "/" + file;
-        var stat = fs.statSync(file);
-        if (stat && stat.isDirectory()) {
-            var ret = findFile(file, fn);
-            if (ret) {
-                return ret;
-            }
-        }
-        else if (match) {
-            return "file://" + file;
-        }
-    }
-    return undefined;
-}
-function rewriteLocalControl(url) {
-    var found = findFile(process.cwd(), path.basename(url.substring(6)));
-    if (found) {
-        return found;
-    }
-    throw new Error("Couldn't resolve localcontrol " + url);
-}
-function load(path) {
-    return new Promise(function (resolve, reject) {
-        if (path.startsWith("http://localcontrol.netflix.com/")) {
-            try {
-                path = rewriteLocalControl(path);
-            }
-            catch (err) {
-                reject(err);
-                return;
-            }
-        }
-        if (path.startsWith("file:///")) {
-            try {
-                resolve(fs.readFileSync(path.substring(7), "utf8"));
-            }
-            catch (err) {
-                reject(err);
-            }
-            return;
-        }
-        if (!path.startsWith("http://") && !path.startsWith("https://")) {
-            reject(new Error("Not a url"));
-            return;
-        }
-        // let retryIndex = 0;
-        function get() {
-            return __awaiter(this, void 0, void 0, function () {
-                var response;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, got.get(path, { timeout: 10000 })];
-                        case 1:
-                            response = _a.sent();
-                            if (verbose) {
-                                console.error(response.headers);
-                            }
-                            return [2 /*return*/, response.body || ""];
-                    }
-                });
-            });
-        }
-        get().then(resolve, reject);
-    });
-}
-var sourceMaps = {};
-function loadUri(path) {
-    var _this = this;
-    if (path[0] === "/") {
-        path = "file://" + path;
-    }
-    return new Promise(function (resolve, reject) {
-        if (verbose) {
-            console.error("loading", path);
-        }
-        if (!(path in sourceMaps)) {
-            sourceMaps[path] = {
-                resolvers: [resolve],
-                rejecters: [reject]
-            };
-            load(path)
-                .then(function (jsData) {
-                var idx = jsData.lastIndexOf("//# sourceMappingURL=");
-                if (verbose) {
-                    console.error("Got the file", jsData.length, idx);
-                }
-                if (idx == -1) {
-                    return path + ".map";
-                }
-                var mapUrl = jsData.substring(idx + 21);
-                var match = /^(data:.+\/.+;)base64,/.exec(mapUrl);
-                if (match) {
-                    return mapUrl.substring(match[1].length);
-                }
-                if (mapUrl.indexOf("://") != -1) {
-                    return mapUrl;
-                }
-                // console.log(mapUrl);
-                return new url.URL(mapUrl, path).href;
-            })
-                .then(function (mapUrl) {
-                // console.log(mapUrl.substring(0, 20));
-                if (mapUrl.startsWith("base64,")) {
-                    return Buffer.from(mapUrl.substring(7), "base64").toString();
-                }
-                return load(mapUrl);
-            })
-                .then(function (sourceMapData) { return __awaiter(_this, void 0, void 0, function () {
-                var parsed, smap, pending;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            parsed = JSON.parse(sourceMapData);
-                            return [4 /*yield*/, new sourceMap.SourceMapConsumer(parsed)];
-                        case 1:
-                            smap = _a.sent();
-                            pending = sourceMaps[path];
-                            // sourceMaps.delete(path);
-                            if (pending) {
-                                pending.resolvers.forEach(function (func) {
-                                    func(smap);
-                                });
-                            }
-                            return [2 /*return*/];
-                    }
-                });
-            }); })["catch"](function (err) {
-                var pending = sourceMaps[path];
-                if (!pending) {
-                    throw new Error("Gotta have pending");
-                }
-                // sourceMaps.delete(path);
-                pending.rejecters.forEach(function (func) {
-                    func(err);
-                });
-            });
-        }
-        else {
-            var cur = sourceMaps[path];
-            if (verbose) {
-                console.error("path is in source maps already", cur);
-            }
-            if (!cur) {
-                throw new Error("Gotta have cur");
-            }
-            cur.resolvers.push(resolve);
-            cur.rejecters.push(reject);
-        }
-    });
-}
-function processFrame(functionName, url, line, column) {
-    if (verbose) {
-        console.error("got frame", functionName, url, line, column);
-    }
-    if (functionName.endsWith("@")) {
-        functionName = functionName.substring(0, functionName.length - 1);
-    }
-    return new Promise(function (resolve) {
-        var newUrl, newLine, newColumn;
-        if (verbose) {
-            console.error("calling loadUri", url);
-        }
-        if (!url.includes("://") && url[0] !== "/" && fs.existsSync(url)) {
-            url = "file://".concat(process.cwd(), "/").concat(url);
-        }
-        return loadUri(url)
-            .then(function (smap) {
-            if (verbose) {
-                console.error("got map", url, Object.keys(smap));
-            }
-            // it appears that we're supposed to reduce the column
-            // number by 1 when we get this from jsc
-            var pos = smap.originalPositionFor({ line: line, column: column - jsc });
-            if (!pos.source) {
-                if (verbose) {
-                    console.error("nothing here", pos);
-                }
-                throw new Error("Mapping not found");
-            }
-            // smc.sourceContentFor(pos.source);
-            newUrl = pos.source;
-            newLine = pos.line || 0;
-            newColumn = pos.column || 0;
-        })["catch"](function (err) {
-            if (verbose) {
-                console.error("didn't get map", url, err);
-            }
-            // console.error(err);
-        })["finally"](function () {
-            if (json) {
-                var ret = {
-                    functionName: functionName,
-                    sourceURL: newUrl ? newUrl : url,
-                    line: newUrl ? newLine : line,
-                    column: newUrl ? newColumn : column
-                };
-                // if (newUrl) {
-                //     ret.oldSourceURL = url;
-                //     ret.oldLine = line;
-                //     ret.oldColumn = column;
-                // }
-                // if (newUrl) {
-                //     ret.newUrl = newUrl;
-                //     ret.newLine = newLine;
-                //     ret.newColumn = newColumn;
-                // }
-                resolve(ret);
-            }
-            else {
-                var str = void 0;
-                if (newUrl) {
-                    str = "".concat(build(functionName, newUrl, newLine, newColumn), " (").concat(build("", url, line, column), ")");
-                }
-                else {
-                    str = build(functionName, url, line, column);
-                }
-                resolve(str);
-            }
-        });
-    });
-}
-if (json) {
-    var parsed = void 0;
-    try {
-        parsed = JSON.parse(stack);
-        if (!Array.isArray(parsed)) {
-            throw new Error("Expected array");
-        }
-    }
-    catch (err) {
-        console.error("Can't parse json ".concat(err));
-        process.exit(1);
-    }
-    Promise.all(parsed.map(function (frame) {
-        if (verbose) {
-            console.error("got frame frame", frame);
-        }
-        return processFrame(frame.functionName || "", frame.sourceURL || "", frame.line, frame.column);
-    }))
-        .then(function (results) {
-        results.forEach(function (frame, index) {
-            if (typeof frame !== "object") {
-                throw new Error("Huh?");
-            }
-            frame.index = index;
-        });
-        // console.log("shit", results);
-        console.log(JSON.stringify(results, null, 4));
-    })["catch"](function (error) {
-        console.error("Got an error", error);
-        process.exit(2);
-    });
-}
-else {
-    Promise.all(stack
-        .split("\n")
-        .filter(function (x) { return x; })
-        .map(function (x) {
-        x = x.trim();
-        var match = / *at *([^ ]*).* \(?([^ ]+):([0-9]+):([0-9]+)/.exec(x);
-        if (!match) {
-            match = /([^ ]+@)?(.*):([0-9]+):([0-9]+)/.exec(x);
-        }
-        if (verbose) {
-            console.error(x, " => ", match);
-        }
-        if (!match) {
-            var nolinecol = /([^ ]*)(.*)/.exec(x);
-            if (nolinecol) {
-                return nolinecol[0];
-            }
-            return x;
-        }
-        return processFrame(match[1] || "", match[2], parseInt(match[3]), parseInt(match[4]));
-    }))
-        .then(function (results) {
-        if (!results.length) {
-            throw new Error("Empty output");
-        }
-        results.forEach(function (str) {
-            console.log(str);
-        });
-    })["catch"](function (error) {
-        console.error("Got an error", error);
-        process.exit(3);
-    });
-}