@emoyly/problem 5.0.8 → 7.0.0

package/src/parsers/jsonwebtoken.ts

@@ -0,0 +1,104 @@
+import { Problem } from '../problem.js'
+import type { Parser } from '../typings/parser.js'
+import { JsonWebTokenError, NotBeforeError, TokenExpiredError } from 'jsonwebtoken'
+import type { ProblemOpts } from '../typings/problem.js'
+
+interface ErrorMap {
+    'search': string | RegExp,
+    'result': ProblemOpts,
+}
+
+const errorMap: ErrorMap[] = [
+    {
+        'search': 'invalid token',
+        'result': {
+            'type': '/errors/jsonwebtoken/invalidtoken',
+            'status': 400,
+            'title': 'Invalid JSON Web Token',
+        }
+    },
+    {
+        'search': 'jwt malformed',
+        'result': {
+            'type': '/errors/jsonwebtoken/malformed',
+            'status': 400,
+            'title': 'Malformed JSON Web Token',
+        }
+    },
+    {
+        'search': 'jwt signature is required',
+        'result': {
+            'type': '/errors/jsonwebtoken/signaturerequired',
+            'status': 400,
+            'title': 'JSON Web Token is missing, but required',
+        }
+    },
+    {
+        'search': 'invalid signature',
+        'result': {
+            'type': '/errors/jsonwebtoken/invalidsignature',
+            'status': 400,
+            'title': 'The JSON Web Token signature is invalid',
+        }
+    },
+    {
+        'search': /^(jwt audience invalid\. expected:)/,
+        'result': {
+            'type': '/errors/jsonwebtoken/invalidaud',
+            'status': 400,
+            'title': 'The JSON Web Token audience is invalid',
+        }
+    },
+    {
+        'search': /^(jwt issuer invalid\. expected:)/,
+        'result': {
+            'type': '/errors/jsonwebtoken/invalidiss',
+            'status': 400,
+            'title': 'The JSON Web Token issuer is invalid',
+        }
+    },
+    {
+        'search': /^(jwt id invalid\. expected:)/,
+        'result': {
+            'type': '/errors/jsonwebtoken/invalidid',
+            'status': 400,
+            'title': 'The JSON Web Token id is invalid',
+        }
+    },
+    {
+        'search': /^(jwt subject invalid\. expected:)/,
+        'result': {
+            'type': '/errors/jsonwebtoken/invalidsubject',
+            'status': 400,
+            'title': 'The JSON Web Token subject is invalid',
+        }
+    }
+]
+
+const parse: Parser = (input) => {
+    if (input instanceof JsonWebTokenError && input.name === 'JsonWebTokenError') {
+        const found = errorMap.find(val => typeof val.search === 'string' ? val.search === input.message : val.search.test(input.message))
+
+        if (found) {
+            return [new Problem(found.result)]
+        }
+    } else if (input instanceof TokenExpiredError && input.name === 'TokenExpiredError') {
+        return [new Problem({
+            'title': 'The JSON Web Token has expired',
+            'type': '/errors/jsonwebtoken/tokenexpired',
+            'detail': `The JSON Web Token expired at ${input.expiredAt}`,
+            'status': 400,
+        })]
+    } else if (input instanceof NotBeforeError && input.name === 'NotBeforeError') {
+        return [new Problem({
+            'title': 'The JSON Web Token is not valid yet',
+            'type': '/errors/jsonwebtoken/notbefore',
+            'detail': `The JSON Web Token is not valid before ${input.date}`,
+            'status': 400,
+        })]
+    }
+
+    return []
+}
+
+export default parse

package/src/parsers/mikroorm.ts

@@ -0,0 +1,21 @@
+import { Problem } from '../problem.js'
+import { statusCodes } from '../defaults/4xx.js'
+import type { Parser } from '../typings/parser.js'
+import { NotFoundError } from '@mikro-orm/core'
+
+// TODO: Make this less bad
+const parse: Parser = (input) => {
+    if (!(input instanceof NotFoundError)) {
+        return []
+    }
+
+    return [
+        new Problem({
+            ...statusCodes['404'],
+            'stack': input.stack,
+            'errorObject': input,
+        })
+    ]
+}
+
+export default parse

package/src/parsers/tsoa.ts

@@ -0,0 +1,25 @@
+import { ValidateError } from 'tsoa'
+import { Problem } from '../problem.js'
+import { otherErrors } from '../defaults/others.js'
+import type { Parser } from '../typings/parser.js'
+
+const parse: Parser = (input) => {
+    if (!(input instanceof ValidateError)) {
+        return []
+    }
+
+    // TODO: Give actual useful responses instead of this shit
+    return [
+        new Problem({
+            ...otherErrors.inputValidationError,
+            'detail': input.message,
+            'status': input.status,
+            'data': {
+                'fields': input.fields,
+            },
+            'stack': input.stack,
+        })
+    ]
+}
+
+export default parse

package/src/problem.ts

@@ -0,0 +1,56 @@
+import type { IProblem, ProblemOpts, JsonProblem } from './typings/problem.js'
+import { defaultDetail, defaultInstance, defaultTitle, defaultType } from './util/defaults.js'
+import { version } from './util/version.js'
+
+export class Problem extends Error implements IProblem {
+    public type = defaultType
+    public title = defaultTitle
+    public status = 500
+    public detail = defaultDetail
+    public instance = defaultInstance
+    public errorObject?: unknown
+    public __problemVersion = version
+    public data: unknown = undefined
+    public middleware?: string
+
+    constructor({ type, title, status, detail, instance, stack, errorObject, data, middleware }: ProblemOpts) {
+        super(detail ?? title ?? 'HTTP Problem Details')
+        // TODO: Figure out why i wrote this?
+        Object.setPrototypeOf(this, new.target.prototype)
+
+        this.type = type
+        this.title = title
+        this.status = status
+
+        if (detail) this.detail = detail
+        if (instance) this.instance = instance
+        if (errorObject) this.errorObject = errorObject
+        if (middleware) this.middleware = middleware
+
+        if (stack) {
+            this.stack = stack
+        } else if (errorObject && typeof errorObject === 'object' && 'stack' in errorObject && typeof errorObject.stack === 'string') {
+            this.stack = errorObject.stack
+        } else {
+            if (typeof Error.captureStackTrace === 'function') {
+                Error.captureStackTrace(this, this.constructor)
+            } else {
+                this.stack = new Error(detail ?? title ?? 'HTTP Problem Details').stack
+            }
+        }
+
+        if (data) this.data = data
+    }
+
+    public toObject = (): JsonProblem => {
+        return {
+            'type': this.type,
+            'title': this.title,
+            'status': this.status,
+            'detail': this.detail,
+            'instance': this.instance,
+            '__problemVersion': this.__problemVersion,
+            'data': this.data
+        }
+    }
+}

package/src/typings/codes.ts

@@ -0,0 +1,6 @@
+import type { ProblemOpts } from './problem.js'
+
+export interface Codes {
+    [key: number]: ProblemOpts | undefined
+    [key: string]: ProblemOpts | undefined
+}

package/src/typings/index.ts

@@ -0,0 +1,4 @@
+export * from './middleware.js'
+export * from './parser.js'
+export * from './problem.js'
+export * from './codes.js'

package/src/typings/middleware.ts

@@ -0,0 +1,14 @@
+import type { Problem } from '../problem.js'
+import type { Parser } from './parser.js'
+
+export interface MiddlewareOptions {
+    /**
+     * A list of parsers to be used by the middleware.
+     * Parsers are run in the order they sit in the array
+     */
+    parsers: Parser[]
+}
+
+export type PartialMiddlewareOptions = Partial<MiddlewareOptions>
+
+export type ProblemListener = (problems: Problem[]) => void

package/src/typings/parser.ts

@@ -0,0 +1,3 @@
+import type { Problem } from '../problem.js'
+
+export type Parser = (input: unknown) => Problem[]

package/src/typings/problem.ts

@@ -0,0 +1,27 @@
+/**
+ * @param {string} type - A URI refrence that identifies the problem type. 
+ * @param {string} title - A short, human-readable summary of the problem
+ * type.  It SHOULD NOT change from occurrence to occurrence of the problem
+ * @param {number} status - The HTTP status code
+ * @param {string} detail - A human-readable explanation specific to this
+      occurrence of the problem.
+ * @property {string} instance - A URI reference that identifies the specific
+      occurrence of the problem
+**/
+
+export interface IProblem {
+    type: string
+    title: string
+    status: number
+    detail?: string
+    instance?: string
+    stack?: string
+    errorObject?: unknown
+    __problemVersion: string
+    data?: unknown
+    middleware?: string
+}
+
+export type JsonProblem = Omit<IProblem, 'stack' | 'errorObject' | 'middleware'>
+
+export type ProblemOpts = Omit<IProblem, '__problemVersion'>

package/src/util/defaults.ts

@@ -0,0 +1,4 @@
+export const defaultType = '/errors/default/unknown'
+export const defaultTitle = 'Unknown error'
+export const defaultDetail = 'No extended details are available'
+export const defaultInstance = '/unknown'

package/src/util/getProblems.ts

@@ -0,0 +1,43 @@
+import { Problem } from '../problem.js'
+import type { JsonProblem } from '../typings/problem.js'
+import { isProblemArray } from './isProblemArray.js'
+import { isCompatibleVersion } from './version.js'
+
+const strings = ['title', 'type', 'instance', 'detail', '__problemVersion']
+export function isJsonProblem(input: unknown): input is JsonProblem {
+    if (input === null) return false
+    if (typeof input !== 'object') return false
+
+    if (!strings.every(val => val in input && typeof input[val as keyof typeof input] === 'string')) return false
+    if (!isCompatibleVersion(('__problemVersion' in input && typeof input['__problemVersion'] === 'string') ? input['__problemVersion'] : '')) return false
+
+    if (!('status' in input) || typeof input.status !== 'number') return false
+
+    return true
+}
+
+export function createFromJson({ title, type, instance, detail, status, data }: JsonProblem): Problem {
+    return new Problem({ title, type, instance, detail, status, data })
+}
+
+export function getProblems(input: unknown): Problem[] | void {
+    if (typeof input === 'string') {
+        try {
+            const p = JSON.parse(input)
+            input = p
+        } catch (err) { /**/ }
+    }
+
+    if (input instanceof Problem) return [input]
+    if (isProblemArray(input)) return input
+
+    if (Array.isArray(input) && input.every(val => isJsonProblem(val))) {
+        const _input = input as JsonProblem[]
+
+        return _input.map(val => createFromJson(val))
+    }
+
+    if (isJsonProblem(input)) {
+        return [createFromJson(input)]
+    }
+}

package/src/util/isProblemArray.ts

@@ -0,0 +1,6 @@
+import { Problem } from '../problem.js'
+
+export function isProblemArray(input: unknown): input is Problem[] {
+    if (!Array.isArray(input)) return false
+    return input.every(val => val instanceof Problem)
+}

package/src/util/misc.ts

@@ -0,0 +1,20 @@
+import * as allCodes from '../defaults/index.js'
+import { ProblemOpts, Codes } from '../typings/index.js'
+
+export function getHttpError(statusCode: number | string): ProblemOpts | undefined {
+    for (const key in allCodes) {
+        // This ensures all codes are written correctly as well, so that's a bonus
+        const codeObject: Codes = allCodes[key as keyof typeof allCodes]
+
+        if (typeof statusCode === 'string') {
+            const conv = Number(statusCode)
+            if (!isNaN(conv)) statusCode = conv
+        }
+
+        const code = codeObject[statusCode]
+
+        if (!code) return
+
+        return code
+    }
+}

package/src/util/version.ts

@@ -0,0 +1,16 @@
+export const version = '7.0.0'
+export const major = Number(version.split('.')[0])
+
+export function isCompatibleVersion(inputVersion: string) {
+    // TODO: Remove this
+    if (inputVersion === 'lua-dev') return true
+
+    const parts = inputVersion.split('.')
+    const inputMajor = Number(parts[0])
+
+    if (parts.length !== 3) return false
+    if (isNaN(inputMajor)) return false
+    if (inputMajor !== major) return false
+
+    return true
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "extends": "./node_modules/@emoyly/devutils/tsconfig-base.json",
+    "compilerOptions": {
+        "outDir": "./esm",
+        "esModuleInterop": false,
+        "lib": [
+            "DOM",
+            "ES2022"
+        ]
+    },
+    "exclude": [
+        "./esm/",
+        "./cjs/"
+    ]
+}

package/defaults/index.d.ts

@@ -1,7 +0,0 @@
-export { statusCodes as codes4xx } from '../defaults/4xx';
-export { statusCodes as codes5xx } from '../defaults/5xx';
-export { statusCodes as codesAws } from '../defaults/aws';
-export { statusCodes as codesCloudflare } from '../defaults/cloudflare';
-export { statusCodes as codesIis } from '../defaults/iis';
-export { statusCodes as codesNginx } from '../defaults/nginx';
-export { otherErrors } from '../defaults/others';

package/defaults/index.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.otherErrors = exports.codesNginx = exports.codesIis = exports.codesCloudflare = exports.codesAws = exports.codes5xx = exports.codes4xx = void 0;
-var _4xx_1 = require("../defaults/4xx");
-Object.defineProperty(exports, "codes4xx", { enumerable: true, get: function () { return _4xx_1.statusCodes; } });
-var _5xx_1 = require("../defaults/5xx");
-Object.defineProperty(exports, "codes5xx", { enumerable: true, get: function () { return _5xx_1.statusCodes; } });
-var aws_1 = require("../defaults/aws");
-Object.defineProperty(exports, "codesAws", { enumerable: true, get: function () { return aws_1.statusCodes; } });
-var cloudflare_1 = require("../defaults/cloudflare");
-Object.defineProperty(exports, "codesCloudflare", { enumerable: true, get: function () { return cloudflare_1.statusCodes; } });
-var iis_1 = require("../defaults/iis");
-Object.defineProperty(exports, "codesIis", { enumerable: true, get: function () { return iis_1.statusCodes; } });
-var nginx_1 = require("../defaults/nginx");
-Object.defineProperty(exports, "codesNginx", { enumerable: true, get: function () { return nginx_1.statusCodes; } });
-var others_1 = require("../defaults/others");
-Object.defineProperty(exports, "otherErrors", { enumerable: true, get: function () { return others_1.otherErrors; } });

package/index.d.ts

@@ -1,5 +0,0 @@
-export { Problem } from './problem';
-export * as defaults from './defaults';
-export { default as events } from './util/events';
-export * from './typings';
-export * from './util/isProblemArray';

package/index.js

@@ -1,39 +0,0 @@
-"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;
-};
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.events = exports.defaults = exports.Problem = void 0;
-var problem_1 = require("./problem");
-Object.defineProperty(exports, "Problem", { enumerable: true, get: function () { return problem_1.Problem; } });
-exports.defaults = __importStar(require("./defaults"));
-var events_1 = require("./util/events");
-Object.defineProperty(exports, "events", { enumerable: true, get: function () { return __importDefault(events_1).default; } });
-__exportStar(require("./typings"), exports);
-__exportStar(require("./util/isProblemArray"), exports);

package/middleware/axios.js

@@ -1,36 +0,0 @@
-"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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AxiosMiddleware = void 0;
-const base_1 = require("./base");
-const axios_1 = __importDefault(require("../parsers/axios"));
-const events_1 = __importDefault(require("../util/events"));
-class AxiosMiddleware extends base_1.MiddlewareBase {
-    constructor(options) {
-        super({
-            'parsers': [axios_1.default]
-        }, options);
-        this.name = 'axios';
-        this.interceptor = (error) => __awaiter(this, void 0, void 0, function* () {
-            const problems = yield this.parse(error);
-            events_1.default.emit(problems);
-            return Promise.reject(problems);
-        });
-        /**
-         * @example instance.interceptors.response.use(...middleware.use())
-         */
-        this.use = () => [undefined, this.interceptor];
-    }
-}
-exports.AxiosMiddleware = AxiosMiddleware;

package/middleware/base.js

@@ -1,56 +0,0 @@
-"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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MiddlewareBase = void 0;
-const defaults_1 = require("../defaults");
-const problem_1 = require("../problem");
-const getProblems_1 = require("../util/getProblems");
-/**
- * Middleware collects errors from somewhere, transforms them into something recognizable by a parser, and then passes them to the parsers, and then returns an array of Problems to whatever is using the middleware
- */
-class MiddlewareBase {
-    constructor(defaultOptions, options) {
-        /**
-         * When nothing is returned from the parsers, just throw in a default "fallback" Problem object, so that a Problem is still actually returned/emitted
-         */
-        this.enableFallback = true;
-        /**
-         * Parse input using parsers
-         */
-        this.parse = (input) => __awaiter(this, void 0, void 0, function* () {
-            const problems = [];
-            const prob = (0, getProblems_1.getProblems)(input);
-            if (!prob) {
-                for (const parse of this.options.parsers) {
-                    const resp = parse(input);
-                    if (!resp.length)
-                        continue;
-                    problems.push(...resp);
-                    break;
-                }
-                if (!problems.length && this.enableFallback) {
-                    problems.push(new problem_1.Problem(Object.assign(Object.assign({}, this.fallback), { 'errorObject': input, 'stack': (typeof input === 'object' && input !== null && 'stack' in input && typeof input.stack === 'string') ? input.stack : undefined })));
-                }
-            }
-            else {
-                problems.push(...prob);
-            }
-            for (const p of problems) {
-                if (!p.middleware)
-                    p.middleware = this.name;
-            }
-            return problems;
-        });
-        this.fallback = defaults_1.otherErrors.unknown;
-        this.options = Object.assign(Object.assign({}, defaultOptions), options);
-    }
-}
-exports.MiddlewareBase = MiddlewareBase;

package/middleware/express.js

@@ -1,60 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpressMiddleware = void 0;
-const base_1 = require("./base");
-const problem_1 = require("../problem");
-const defaults_1 = require("../defaults");
-const events_1 = __importDefault(require("../util/events"));
-const defaults_2 = require("../util/defaults");
-class ExpressMiddleware extends base_1.MiddlewareBase {
-    constructor(options) {
-        super({
-            'parsers': []
-        }, options);
-        this.name = 'express';
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        this.middleware = (error, req, res, next) => {
-            this.parse(error)
-                .then(problems => {
-                var _a, _b;
-                for (const problem of problems) {
-                    if (problem.instance === defaults_2.defaultInstance) {
-                        problem.instance = req.originalUrl;
-                    }
-                }
-                events_1.default.emit(problems);
-                res
-                    .contentType('application/problem+json')
-                    .status((_b = (_a = problems[0]) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : 500)
-                    .json(problems.map(val => val.toObject()));
-            })
-                .catch(err => {
-                res
-                    .contentType('application/problem+json')
-                    .status(500)
-                    .json([
-                    new problem_1.Problem(Object.assign(Object.assign({}, defaults_1.otherErrors.unknown), { 'instance': req.originalUrl, 'status': 500, 'stack': err === null || err === void 0 ? void 0 : err.stack, 'errorObject': err })).toObject()
-                ]);
-                throw err;
-            });
-        };
-        /**
-         * This function applies the middleware to your Express application. Put this at the very end of your middleware/routes.
-         * If you want to also handle 404 errors, check out the notFound middleware function.
-         * @example app.use(middleware.use())
-         */
-        this.use = () => this.middleware;
-        /**
-         * Put this right before the middleware.use() to catch all 404 errors and respond with a Problem instead of the default Express response
-         * @example app.use(middleware.notFound)
-         */
-        this.notFound = (req, res, next) => {
-            const error = new problem_1.Problem(Object.assign(Object.assign({}, defaults_1.codes4xx[404]), { 'instance': req.originalUrl, 'detail': `No API endpoints exist on ${req.url} for request method ${req.method}` }));
-            return next(error);
-        };
-    }
-}
-exports.ExpressMiddleware = ExpressMiddleware;

package/parsers/axios.d.ts

@@ -1,3 +0,0 @@
-import type { Parser } from '../typings/parser';
-declare const parse: Parser;
-export default parse;

package/parsers/axios.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const others_1 = require("../defaults/others");
-const problem_1 = require("../problem");
-const getProblems_1 = require("../util/getProblems");
-const misc_1 = require("../util/misc");
-function isAxiosError(payload) {
-    return typeof payload === 'object' && payload !== null && 'isAxiosError' in payload && payload.isAxiosError === true;
-}
-const parse = (input) => {
-    var _a, _b, _c, _d, _e;
-    if (typeof input !== 'object' || input == null)
-        return [];
-    if (!isAxiosError(input))
-        return [];
-    const request = input.request;
-    if ((_a = input === null || input === void 0 ? void 0 : input.response) === null || _a === void 0 ? void 0 : _a.data) {
-        const problems = (0, getProblems_1.getProblems)((_b = input === null || input === void 0 ? void 0 : input.response) === null || _b === void 0 ? void 0 : _b.data);
-        if (problems === null || problems === void 0 ? void 0 : problems.length)
-            return problems;
-    }
-    if (input === null || input === void 0 ? void 0 : input.response) {
-        const opts = (0, misc_1.getHttpError)(input.response.status);
-        if (opts)
-            return [new problem_1.Problem(Object.assign(Object.assign({}, opts), { 'instance': (_c = input === null || input === void 0 ? void 0 : input.config) === null || _c === void 0 ? void 0 : _c.url, 'stack': input === null || input === void 0 ? void 0 : input.stack, 'errorObject': input }))];
-    }
-    // TODO: Fix this, this seems bad
-    if (request) {
-        const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
-        const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-        if (isBrowser && request instanceof XMLHttpRequest) {
-            return [new problem_1.Problem(Object.assign(Object.assign({}, others_1.otherErrors.networkError), { 'instance': (_d = input === null || input === void 0 ? void 0 : input.config) === null || _d === void 0 ? void 0 : _d.url, 'stack': input === null || input === void 0 ? void 0 : input.stack, 'errorObject': input }))];
-        }
-        // Probably a ClientRequest
-        if (isNode && 'pipe' in request && 'destroy' in request) {
-            return [new problem_1.Problem(Object.assign(Object.assign({}, others_1.otherErrors.networkError), { 'instance': (_e = input === null || input === void 0 ? void 0 : input.config) === null || _e === void 0 ? void 0 : _e.url, 'stack': input === null || input === void 0 ? void 0 : input.stack, 'errorObject': input }))];
-        }
-    }
-    return [];
-};
-exports.default = parse;