@trezor/connect 9.0.0-beta.1

package/lib/data/config.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.config = {
+    webusb: [
+        { vendorId: 0x534c, productId: 0x0001 },
+        { vendorId: 0x1209, productId: 0x53c0 },
+        { vendorId: 0x1209, productId: 0x53c1 },
+    ],
+    whitelist: [
+        { origin: 'chrome-extension://imloifkgjagghnncjkhggdhalmcnfklk', priority: 1 },
+        { origin: 'chrome-extension://niebkpllfhmpfbffbfifagfgoamhpflf', priority: 1 },
+        { origin: 'file://', priority: 2 },
+        { origin: 'trezor.io', priority: 0 },
+        { origin: 'sldev.cz', priority: 0 },
+        { origin: 'localhost', priority: 0 },
+        { origin: 'trezoriovpjcahpzkrewelclulmszwbqpzmzgub37gbcjlvluxtruqad.onion', priority: 0 },
+    ],
+    management: [{ origin: 'trezor.io' }, { origin: 'sldev.cz' }, { origin: 'localhost' }],
+    knownHosts: [
+        {
+            origin: 'imloifkgjagghnncjkhggdhalmcnfklk',
+            label: 'Trezor Password Manager (Develop)',
+            icon: '',
+        },
+        { origin: 'niebkpllfhmpfbffbfifagfgoamhpflf', label: 'Trezor Password Manager', icon: '' },
+        { origin: 'trezor-connect@trezor.io', label: 'Trezor Connect FF Extension', icon: '' },
+        {
+            origin: 'efbfhenfhihgdcmnfdkhaphjdnopihlf',
+            label: 'Trezor Connect Chrome Extension',
+            icon: '',
+        },
+        {
+            origin: 'mnpfhpndmjholfdlhpkjfmjkgppmodaf',
+            label: 'MetaMask',
+            icon: '',
+        },
+        {
+            origin: 'webextension@metamask.io',
+            label: 'MetaMask',
+            icon: '',
+        },
+        { origin: 'file://', label: ' ', icon: '' },
+    ],
+    onionDomains: {
+        'trezor.io': 'trezoriovpjcahpzkrewelclulmszwbqpzmzgub37gbcjlvluxtruqad.onion',
+    },
+    assets: [
+        {
+            name: 'coins',
+            url: './data/coins.json',
+        },
+        {
+            name: 'bridge',
+            url: './data/bridge/releases.json',
+        },
+        {
+            name: 'firmware-t1',
+            url: './data/firmware/1/releases.json',
+        },
+        {
+            name: 'firmware-t2',
+            url: './data/firmware/2/releases.json',
+        },
+    ],
+    messages: [
+        {
+            name: 'default',
+            range: {
+                min: ['1.0.0', '2.0.0'],
+            },
+            json: './data/messages/messages.json',
+        },
+    ],
+    supportedBrowsers: {
+        chrome: {
+            version: 59,
+            download: 'https://www.google.com/chrome/',
+            update: 'https://support.google.com/chrome/answer/95414',
+        },
+        chromium: {
+            version: 59,
+            download: 'https://www.chromium.org/',
+            update: 'https://www.chromium.org/',
+        },
+        electron: {
+            version: 0,
+            download: 'https://www.electronjs.org/',
+            update: 'https://www.electronjs.org/',
+        },
+        firefox: {
+            version: 54,
+            download: 'https://www.mozilla.org/en-US/firefox/new/',
+            update: 'https://support.mozilla.org/en-US/kb/update-firefox-latest-version',
+        },
+    },
+    supportedFirmware: [
+        {
+            coin: ['xrp', 'txrp'],
+            methods: ['getAccountInfo'],
+            min: ['0', '2.1.0'],
+            max: undefined,
+            comment: [
+                "Since firmware 2.1.0 there is a new protobuf field 'destination_tag' in RippleSignTx",
+            ],
+        },
+        {
+            coin: ['bnb'],
+            min: ['1.9.0', '2.3.0'],
+            comment: [
+                'There were protobuf backwards incompatible changes with introduction of 1.9.0/2.3.0 firmwares',
+            ],
+        },
+        {
+            coin: ['eth', 'trop'],
+            min: ['1.8.0', '2.1.0'],
+            comment: ['There were protobuf backwards incompatible changes.'],
+        },
+        {
+            methods: ['rippleGetAddress', 'rippleSignTransaction'],
+            min: ['0', '2.1.0'],
+            comment: [
+                "Since firmware 2.1.0 there is a new protobuf field 'destination_tag' in RippleSignTx",
+            ],
+        },
+        {
+            methods: ['cardanoGetAddress', 'cardanoGetPublicKey'],
+            min: ['0', '2.3.2'],
+            comment: ['Shelley fork support since firmware 2.3.2'],
+        },
+        {
+            methods: ['cardanoSignTransaction'],
+            min: ['0', '2.4.2'],
+            comment: ['Non-streamed signing no longer supported'],
+        },
+        {
+            methods: ['cardanoGetNativeScriptHash'],
+            min: ['0', '2.4.3'],
+            comment: ['Cardano GetNativeScriptHash call added in 2.4.3'],
+        },
+        {
+            methods: ['tezosSignTransaction'],
+            min: ['0', '2.1.8'],
+            comment: [
+                'Since 2.1.8 there are new protobuf fields in tezos transaction (Babylon fork)',
+            ],
+        },
+        {
+            methods: ['stellarSignTransaction'],
+            min: ['1.9.0', '2.3.0'],
+            comment: [
+                'There were protobuf backwards incompatible changes with introduction of 1.9.0/2.3.0 firmwares',
+            ],
+        },
+        {
+            capabilities: ['replaceTransaction', 'amountUnit'],
+            min: ['1.9.4', '2.3.5'],
+            comment: ['new sign tx process since 1.9.4/2.3.5'],
+        },
+        {
+            capabilities: ['decreaseOutput'],
+            min: ['1.10.0', '2.4.0'],
+            comment: ['allow reduce output in RBF transaction since 1.10.0/2.4.0'],
+        },
+        {
+            capabilities: ['eip1559'],
+            min: ['1.10.4', '2.4.2'],
+            comment: ['new eth transaction pricing mechanism (EIP1559) since 1.10.4/2.4.2'],
+        },
+        {
+            capabilities: ['taproot', 'signMessageNoScriptType'],
+            min: ['1.10.4', '2.4.3'],
+            comment: [
+                'new btc accounts taproot since 1.10.4/2.4.3 (BTC + TEST only)',
+                'SignMessage with no_script_type support',
+            ],
+        },
+        {
+            coin: ['dcr', 'tdcr'],
+            methods: ['signTransaction'],
+            min: ['1.10.1', '2.4.0'],
+            comment: [''],
+        },
+        {
+            methods: ['ethereumSignTypedData'],
+            min: ['1.10.5', '2.4.3'],
+            comment: ['EIP-712 typed signing support added in 1.10.5/2.4.3'],
+        },
+        {
+            capabilities: ['eip712-domain-only'],
+            min: ['1.10.6', '2.4.4'],
+            comment: ['EIP-712 domain-only signing, when primaryType=EIP712Domain'],
+        },
+        {
+            capabilities: ['coinjoin'],
+            methods: ['authorizeCoinJoin', 'getOwnershipId', 'getOwnershipProof'],
+            min: ['0', '2.4.4'],
+        },
+    ],
+};
+//# sourceMappingURL=config.js.map

package/lib/data/connectSettings.d.ts

@@ -0,0 +1,6 @@
+import type { ConnectSettings } from '../types';
+export declare const DEFAULT_PRIORITY = 2;
+export declare const getEnv: () => "web" | "webextension" | "electron" | "react-native";
+export declare const corsValidator: (url?: string | undefined) => string | undefined;
+export declare const parseConnectSettings: (input?: Partial<ConnectSettings>) => ConnectSettings;
+//# sourceMappingURL=connectSettings.d.ts.map

package/lib/data/connectSettings.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConnectSettings = exports.corsValidator = exports.getEnv = exports.DEFAULT_PRIORITY = void 0;
+const version_1 = require("./version");
+exports.DEFAULT_PRIORITY = 2;
+const initialSettings = {
+    configSrc: './data/config.json',
+    version: version_1.VERSION,
+    debug: false,
+    priority: exports.DEFAULT_PRIORITY,
+    trustedHost: false,
+    connectSrc: version_1.DEFAULT_DOMAIN,
+    iframeSrc: `${version_1.DEFAULT_DOMAIN}iframe.html`,
+    popup: true,
+    popupSrc: `${version_1.DEFAULT_DOMAIN}popup.html`,
+    webusbSrc: `${version_1.DEFAULT_DOMAIN}webusb.html`,
+    webusb: true,
+    pendingTransportEvent: true,
+    supportedBrowser: typeof navigator !== 'undefined' ? !/Trident|MSIE|Edge/.test(navigator.userAgent) : true,
+    env: 'web',
+    lazyLoad: false,
+    timestamp: new Date().getTime(),
+    interactionTimeout: 600,
+};
+const parseManifest = (manifest) => {
+    if (!manifest)
+        return;
+    if (typeof manifest.email !== 'string')
+        return;
+    if (typeof manifest.appUrl !== 'string')
+        return;
+    return {
+        email: manifest.email,
+        appUrl: manifest.appUrl,
+    };
+};
+const getEnv = () => {
+    if (typeof chrome !== 'undefined' &&
+        chrome.runtime &&
+        typeof chrome.runtime.onConnect !== 'undefined') {
+        return 'webextension';
+    }
+    if (typeof navigator !== 'undefined') {
+        if (typeof navigator.product === 'string' &&
+            navigator.product.toLowerCase() === 'reactnative') {
+            return 'react-native';
+        }
+        const userAgent = navigator.userAgent.toLowerCase();
+        if (userAgent.indexOf(' electron/') > -1) {
+            return 'electron';
+        }
+    }
+    return 'web';
+};
+exports.getEnv = getEnv;
+const corsValidator = (url) => {
+    if (typeof url !== 'string')
+        return;
+    if (url.match(/^https:\/\/([A-Za-z0-9\-_]+\.)*trezor\.io\//))
+        return url;
+    if (url.match(/^https?:\/\/localhost:[58][0-9]{3}\//))
+        return url;
+    if (url.match(/^https:\/\/([A-Za-z0-9\-_]+\.)*sldev\.cz\//))
+        return url;
+    if (url.match(/^https?:\/\/([A-Za-z0-9\-_]+\.)*trezoriovpjcahpzkrewelclulmszwbqpzmzgub37gbcjlvluxtruqad\.onion\//))
+        return url;
+};
+exports.corsValidator = corsValidator;
+const parseConnectSettings = (input = {}) => {
+    const settings = { ...initialSettings };
+    if (Object.prototype.hasOwnProperty.call(input, 'debug')) {
+        if (Array.isArray(input)) {
+        }
+        if (typeof input.debug === 'boolean') {
+            settings.debug = input.debug;
+        }
+        else if (typeof input.debug === 'string') {
+            settings.debug = input.debug === 'true';
+        }
+    }
+    if (typeof input.connectSrc === 'string') {
+        settings.connectSrc = input.connectSrc;
+    }
+    let globalSrc;
+    if (typeof window !== 'undefined') {
+        globalSrc = window.__TREZOR_CONNECT_SRC;
+    }
+    else if (typeof global !== 'undefined') {
+        globalSrc = global.__TREZOR_CONNECT_SRC;
+    }
+    if (typeof globalSrc === 'string') {
+        settings.connectSrc = (0, exports.corsValidator)(globalSrc);
+        settings.debug = true;
+    }
+    if (typeof window !== 'undefined' &&
+        window.location &&
+        typeof window.location.search === 'string') {
+        const vars = window.location.search.split('&');
+        const customUrl = vars.find(v => v.indexOf('trezor-connect-src') >= 0);
+        if (customUrl) {
+            const [, connectSrc] = customUrl.split('=');
+            settings.connectSrc = (0, exports.corsValidator)(decodeURIComponent(connectSrc));
+            settings.debug = true;
+        }
+    }
+    const src = settings.connectSrc || version_1.DEFAULT_DOMAIN;
+    settings.iframeSrc = `${src}iframe.html`;
+    settings.popupSrc = `${src}popup.html`;
+    settings.webusbSrc = `${src}webusb.html`;
+    if (typeof input.transportReconnect === 'boolean') {
+        settings.transportReconnect = input.transportReconnect;
+    }
+    if (typeof input.webusb === 'boolean') {
+        settings.webusb = input.webusb;
+    }
+    if (typeof input.popup === 'boolean') {
+        settings.popup = input.popup;
+    }
+    if (typeof input.lazyLoad === 'boolean') {
+        settings.lazyLoad = input.lazyLoad;
+    }
+    if (typeof input.pendingTransportEvent === 'boolean') {
+        settings.pendingTransportEvent = input.pendingTransportEvent;
+    }
+    if (typeof window !== 'undefined' && window.location && window.location.protocol === 'file:') {
+        settings.origin = `file://${window.location.pathname}`;
+        settings.webusb = false;
+    }
+    if (typeof input.extension === 'string') {
+        settings.extension = input.extension;
+    }
+    if (typeof input.env === 'string') {
+        settings.env = input.env;
+    }
+    else {
+        settings.env = (0, exports.getEnv)();
+    }
+    if (typeof input.timestamp === 'number') {
+        settings.timestamp = input.timestamp;
+    }
+    if (typeof input.interactionTimeout === 'number') {
+        settings.interactionTimeout = input.interactionTimeout;
+    }
+    if (typeof input.manifest === 'object') {
+        settings.manifest = parseManifest(input.manifest);
+    }
+    return settings;
+};
+exports.parseConnectSettings = parseConnectSettings;
+//# sourceMappingURL=connectSettings.js.map

package/lib/data/firmwareInfo.d.ts

@@ -0,0 +1,11 @@
+import type { Features, FirmwareRelease, ReleaseInfo } from '../types';
+export declare const parseFirmware: (json: any, model: number) => void;
+export interface GetInfoProps {
+    features: Features;
+    releases: FirmwareRelease[];
+}
+export declare const getInfo: ({ features, releases }: GetInfoProps) => ReleaseInfo | null;
+export declare const getFirmwareStatus: (features: Features) => "valid" | "outdated" | "required" | "unknown" | "none";
+export declare const getRelease: (features: Features) => ReleaseInfo | null;
+export declare const getReleases: (model: number) => FirmwareRelease[];
+//# sourceMappingURL=firmwareInfo.d.ts.map

package/lib/data/firmwareInfo.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReleases = exports.getRelease = exports.getFirmwareStatus = exports.getInfo = exports.parseFirmware = void 0;
+const utils_1 = require("@trezor/utils");
+const firmwareUtils_1 = require("../utils/firmwareUtils");
+const releases = {};
+releases[1] = [];
+releases[2] = [];
+const cleanUrl = (url) => {
+    if (typeof url !== 'string')
+        return;
+    if (url.indexOf('data/') === 0)
+        return url.substring(5);
+    return url;
+};
+const parseFirmware = (json, model) => {
+    Object.keys(json).forEach(key => {
+        const release = json[key];
+        releases[model].push({
+            ...release,
+            url: cleanUrl(release.url),
+            url_bitcoinonly: cleanUrl(release.url_bitcoinonly),
+        });
+    });
+};
+exports.parseFirmware = parseFirmware;
+const getChangelog = (releases, features) => {
+    if (features.bootloader_mode) {
+        if (features.firmware_present && features.major_version === 1) {
+            return null;
+        }
+        if (features.firmware_present && features.major_version === 2) {
+            return releases.filter(r => utils_1.versionUtils.isNewer(r.version, [
+                features.fw_major,
+                features.fw_minor,
+                features.fw_patch,
+            ]));
+        }
+        return releases;
+    }
+    return releases.filter(r => utils_1.versionUtils.isNewer(r.version, [
+        features.major_version,
+        features.minor_version,
+        features.patch_version,
+    ]));
+};
+const isNewer = (release, features) => {
+    if (features.major_version === 1 && features.bootloader_mode) {
+        return null;
+    }
+    return utils_1.versionUtils.isNewer(release.version, [
+        features.major_version,
+        features.minor_version,
+        features.patch_version,
+    ]);
+};
+const isRequired = (changelog) => {
+    if (!changelog || !changelog.length)
+        return null;
+    return changelog.some(item => item.required);
+};
+const isEqual = (release, latest) => utils_1.versionUtils.isEqual(release.version, latest.version);
+const getInfo = ({ features, releases }) => {
+    if (!(0, firmwareUtils_1.isStrictFeatures)(features)) {
+        throw new Error('Features of unexpected shape provided.');
+    }
+    if (!(0, firmwareUtils_1.isValidReleases)(releases)) {
+        throw new Error(`Release object in unexpected shape.`);
+    }
+    let parsedReleases = releases;
+    let score = 0;
+    if (features.device_id) {
+        score = (0, firmwareUtils_1.getScore)(features.device_id);
+    }
+    const { bootloader_mode, major_version, minor_version, patch_version, fw_major, fw_minor, fw_patch, } = features;
+    if (score) {
+        parsedReleases = parsedReleases.filter(item => {
+            if (!item.rollout)
+                return true;
+            return item.rollout >= score;
+        });
+    }
+    const latest = parsedReleases[0];
+    if (major_version === 2 && bootloader_mode) {
+        if (fw_major !== null && fw_minor !== null && fw_patch !== null) {
+            parsedReleases = (0, firmwareUtils_1.filterSafeListByFirmware)(parsedReleases, [
+                fw_major,
+                fw_minor,
+                fw_patch,
+            ]);
+        }
+        parsedReleases = (0, firmwareUtils_1.filterSafeListByBootloader)(parsedReleases, [
+            major_version,
+            minor_version,
+            patch_version,
+        ]);
+    }
+    else if (major_version === 1 && bootloader_mode) {
+        parsedReleases = (0, firmwareUtils_1.filterSafeListByBootloader)(parsedReleases, [
+            major_version,
+            minor_version,
+            patch_version,
+        ]);
+    }
+    else {
+        parsedReleases = (0, firmwareUtils_1.filterSafeListByFirmware)(parsedReleases, [
+            major_version,
+            minor_version,
+            patch_version,
+        ]);
+    }
+    if (!parsedReleases.length) {
+        return null;
+    }
+    const isLatest = isEqual(parsedReleases[0], latest);
+    const changelog = getChangelog(parsedReleases, features);
+    return {
+        changelog,
+        release: parsedReleases[0],
+        isLatest,
+        latest,
+        isRequired: isRequired(changelog),
+        isNewer: isNewer(parsedReleases[0], features),
+    };
+};
+exports.getInfo = getInfo;
+const getFirmwareStatus = (features) => {
+    if (features.firmware_present === false) {
+        return 'none';
+    }
+    if (features.major_version === 1 && features.bootloader_mode) {
+        return 'unknown';
+    }
+    const info = (0, exports.getInfo)({ features, releases: releases[features.major_version] });
+    if (!info)
+        return 'unknown';
+    if (info.isRequired)
+        return 'required';
+    if (info.isNewer)
+        return 'outdated';
+    return 'valid';
+};
+exports.getFirmwareStatus = getFirmwareStatus;
+const getRelease = (features) => (0, exports.getInfo)({ features, releases: releases[features.major_version] });
+exports.getRelease = getRelease;
+const getReleases = (model) => releases[model];
+exports.getReleases = getReleases;
+//# sourceMappingURL=firmwareInfo.js.map

package/lib/data/transportInfo.d.ts

@@ -0,0 +1,4 @@
+import type { BridgeInfo } from '../events/transport';
+export declare const parseBridgeJSON: (json: any) => BridgeInfo;
+export declare const getBridgeInfo: () => BridgeInfo;
+//# sourceMappingURL=transportInfo.d.ts.map

package/lib/data/transportInfo.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBridgeInfo = exports.parseBridgeJSON = void 0;
+const info = {
+    version: [],
+    directory: '',
+    packages: [],
+    changelog: '',
+};
+const parseBridgeJSON = (json) => {
+    const latest = json[0];
+    const version = latest.version.join('.');
+    const data = JSON.parse(JSON.stringify(latest).replace(/{version}/g, version));
+    const { directory } = data;
+    const packages = data.packages.map(p => ({
+        name: p.name,
+        platform: p.platform,
+        url: `${directory}${p.url}`,
+        signature: p.signature ? `${directory}${p.signature}` : undefined,
+    }));
+    info.version = data.version;
+    info.directory = directory;
+    info.packages = packages;
+    return info;
+};
+exports.parseBridgeJSON = parseBridgeJSON;
+const getBridgeInfo = () => info;
+exports.getBridgeInfo = getBridgeInfo;
+//# sourceMappingURL=transportInfo.js.map

package/lib/data/udevInfo.d.ts

@@ -0,0 +1,3 @@
+import type { UdevInfo } from '../events/transport';
+export declare const getUdevInfo: () => UdevInfo;
+//# sourceMappingURL=udevInfo.d.ts.map

package/lib/data/udevInfo.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUdevInfo = void 0;
+const info = {
+    directory: '',
+    packages: [
+        {
+            name: 'RPM package',
+            platform: ['rpm32', 'rpm64'],
+            url: '/udev/trezor-udev-2-1.noarch.rpm',
+        },
+        {
+            name: 'DEB package',
+            platform: ['deb32', 'deb64'],
+            url: '/udev/trezor-udev_2_all.deb',
+        },
+    ],
+};
+const getUdevInfo = () => info;
+exports.getUdevInfo = getUdevInfo;
+//# sourceMappingURL=udevInfo.js.map

package/lib/data/version.d.ts

@@ -0,0 +1,3 @@
+export declare const VERSION = "9.0.0-beta.1";
+export declare const DEFAULT_DOMAIN: string;
+//# sourceMappingURL=version.d.ts.map

package/lib/data/version.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DOMAIN = exports.VERSION = void 0;
+exports.VERSION = '9.0.0-beta.1';
+const versionN = exports.VERSION.split('.').map(s => parseInt(s, 10));
+exports.DEFAULT_DOMAIN = `https://connect.trezor.io/${versionN[0]}/`;
+//# sourceMappingURL=version.js.map

package/lib/device/AbortController.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+declare class AbortSignal {
+    eventEmitter: EventEmitter;
+    aborted: boolean;
+    constructor();
+    toString(): string;
+    removeEventListener(name: string, handler: any): void;
+    addEventListener(name: string, handler: any): void;
+    dispatchEvent(type: string): void;
+}
+declare class AbortControllerFallback {
+    signal: AbortSignal;
+    constructor();
+    abort(): void;
+    toString(): string;
+}
+export declare type Controller = AbortController | AbortControllerFallback;
+export declare const getAbortController: () => AbortControllerFallback | AbortController;
+export {};
+//# sourceMappingURL=AbortController.d.ts.map

package/lib/device/AbortController.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAbortController = void 0;
+const tslib_1 = require("tslib");
+const events_1 = (0, tslib_1.__importDefault)(require("events"));
+class AbortSignal {
+    constructor() {
+        this.aborted = false;
+        this.eventEmitter = new events_1.default();
+    }
+    toString() {
+        return '[object AbortSignal]';
+    }
+    removeEventListener(name, handler) {
+        this.eventEmitter.removeListener(name, handler);
+    }
+    addEventListener(name, handler) {
+        this.eventEmitter.on(name, handler);
+    }
+    dispatchEvent(type) {
+        this.eventEmitter.emit(type, { type, target: this });
+    }
+}
+class AbortControllerFallback {
+    constructor() {
+        this.signal = new AbortSignal();
+    }
+    abort() {
+        if (this.signal.aborted)
+            return;
+        this.signal.dispatchEvent('abort');
+        this.signal.aborted = true;
+    }
+    toString() {
+        return '[object AbortController]';
+    }
+}
+const getAbortController = () => typeof AbortController !== 'undefined' ? new AbortController() : new AbortControllerFallback();
+exports.getAbortController = getAbortController;
+//# sourceMappingURL=AbortController.js.map