Socket
Socket
Sign inDemoInstall

get-uri

Package Overview
Dependencies
Maintainers
1
Versions
21
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

get-uri - npm Package Compare versions

Comparing version 4.0.0 to 5.0.0

8

dist/data.d.ts
/// <reference types="node" />
/// <reference types="node" />
import { Readable } from 'stream';
import { UrlWithStringQuery } from 'url';
import { GetUriOptions } from '.';
import { GetUriProtocol } from './';
declare class DataReadable extends Readable {

@@ -9,3 +9,3 @@ hash?: string;

}
interface DataOptions extends GetUriOptions {
export interface DataOptions {
cache?: DataReadable;

@@ -16,3 +16,3 @@ }

*/
export default function get({ href: uri }: UrlWithStringQuery, { cache }: DataOptions): Promise<Readable>;
export declare const data: GetUriProtocol<DataOptions>;
export {};

9

dist/data.js

@@ -6,2 +6,3 @@ "use strict";

Object.defineProperty(exports, "__esModule", { value: true });
exports.data = void 0;
const debug_1 = __importDefault(require("debug"));

@@ -24,3 +25,3 @@ const stream_1 = require("stream");

*/
async function get({ href: uri }, { cache }) {
const data = async ({ href: uri }, { cache } = {}) => {
// need to create a SHA1 hash of the URI string, for cacheability checks

@@ -33,3 +34,3 @@ // in future `getUri()` calls with the same data URI passed in.

// check if the cache is the same "data:" URI that was previously passed in.
if (cache && cache.hash === hash) {
if (cache?.hash === hash) {
debug('got matching cache SHA1 hash: %o', hash);

@@ -43,4 +44,4 @@ throw new notmodified_1.default();

}
}
exports.default = get;
};
exports.data = data;
//# sourceMappingURL=data.js.map

12

dist/file.d.ts
/// <reference types="node" />
/// <reference types="node" />
import { Readable } from 'stream';
import { UrlWithStringQuery } from 'url';
import { Stats, createReadStream } from 'fs';
import { GetUriOptions } from '.';
declare type ReadStreamOptions = Exclude<Parameters<typeof createReadStream>[1], string>;
import { GetUriProtocol } from './';
type ReadStreamOptions = NonNullable<Exclude<Parameters<typeof createReadStream>[1], string>>;
interface FileReadable extends Readable {
stat?: Stats;
}
declare type FileOptions = GetUriOptions & ReadStreamOptions & {
export interface FileOptions extends ReadStreamOptions {
cache?: FileReadable;
};
}
/**
* Returns a `fs.ReadStream` instance from a "file:" URI.
*/
export default function get({ href: uri }: UrlWithStringQuery, opts: FileOptions): Promise<Readable>;
export declare const file: GetUriProtocol<FileOptions>;
export {};

15

dist/file.js

@@ -6,8 +6,9 @@ "use strict";

Object.defineProperty(exports, "__esModule", { value: true });
exports.file = void 0;
const debug_1 = __importDefault(require("debug"));
const fs_1 = require("fs");
const fs_extra_1 = require("fs-extra");
const file_uri_to_path_1 = __importDefault(require("file-uri-to-path"));
const notfound_1 = __importDefault(require("./notfound"));
const notmodified_1 = __importDefault(require("./notmodified"));
const url_1 = require("url");
const debug = (0, debug_1.default)('get-uri:file');

@@ -17,8 +18,8 @@ /**

*/
async function get({ href: uri }, opts) {
const { cache, flags = 'r', mode = 438 // =0666
const file = async ({ href: uri }, opts = {}) => {
const { cache, flags = 'r', mode = 438, // =0666
} = opts;
try {
// Convert URI → Path
const filepath = (0, file_uri_to_path_1.default)(uri);
const filepath = (0, url_1.fileURLToPath)(uri);
debug('Normalized pathname: %o', filepath);

@@ -41,3 +42,3 @@ // `open()` first to get a file descriptor and ensure that the file

...opts,
fd
fd,
});

@@ -53,4 +54,4 @@ rs.stat = stat;

}
}
exports.default = get;
};
exports.file = file;
// returns `true` if the `mtime` of the 2 stat objects are equal

@@ -57,0 +58,0 @@ function isNotModified(prev, curr) {

13

dist/ftp.d.ts
/// <reference types="node" />
import { Options } from 'ftp';
import { AccessOptions } from 'basic-ftp';
import { Readable } from 'stream';
import { UrlWithStringQuery } from 'url';
import { GetUriOptions } from '.';
interface FTPReadable extends Readable {
import { GetUriProtocol } from '.';
export interface FTPReadable extends Readable {
lastModified?: Date;
}
interface FTPOptions extends GetUriOptions, Options {
export interface FTPOptions extends AccessOptions {
cache?: FTPReadable;
debug?: (s: string) => void;
}

@@ -16,3 +14,2 @@ /**

*/
export default function get(parsed: UrlWithStringQuery, opts: FTPOptions): Promise<Readable>;
export {};
export declare const ftp: GetUriProtocol<FTPOptions>;

81

dist/ftp.js

@@ -6,4 +6,5 @@ "use strict";

Object.defineProperty(exports, "__esModule", { value: true });
const once_1 = __importDefault(require("@tootallnate/once"));
const ftp_1 = __importDefault(require("ftp"));
exports.ftp = void 0;
const basic_ftp_1 = require("basic-ftp");
const stream_1 = require("stream");
const path_1 = require("path");

@@ -17,37 +18,26 @@ const debug_1 = __importDefault(require("debug"));

*/
async function get(parsed, opts) {
const ftp = async (url, opts = {}) => {
const { cache } = opts;
const filepath = parsed.pathname;
let lastModified = null;
const filepath = decodeURIComponent(url.pathname);
let lastModified;
if (!filepath) {
throw new TypeError('No "pathname"!');
}
const client = new ftp_1.default();
client.once('greeting', (greeting) => {
debug('FTP greeting: %o', greeting);
});
function onend() {
// close the FTP client socket connection
client.end();
}
const client = new basic_ftp_1.Client();
try {
opts.host = parsed.hostname || parsed.host || 'localhost';
opts.port = parseInt(parsed.port || '0', 10) || 21;
opts.debug = debug;
if (parsed.auth) {
const [user, password] = parsed.auth.split(':');
opts.user = user;
opts.password = password;
}
const readyPromise = (0, once_1.default)(client, 'ready');
client.connect(opts);
await readyPromise;
const host = url.hostname || url.host || 'localhost';
const port = parseInt(url.port || '0', 10) || 21;
const user = url.username || undefined;
const password = url.password || undefined;
await client.access({
host,
port,
user,
password,
...opts,
});
// first we have to figure out the Last Modified date.
// try the MDTM command first, which is an optional extension command.
try {
lastModified = await new Promise((resolve, reject) => {
client.lastMod(filepath, (err, res) => {
return err ? reject(err) : resolve(res);
});
});
lastModified = await client.lastMod(filepath);
}

@@ -63,12 +53,8 @@ catch (err) {

// more bandwidth, but is more compatible with older FTP servers
const list = await new Promise((resolve, reject) => {
client.list((0, path_1.dirname)(filepath), (err, res) => {
return err ? reject(err) : resolve(res);
});
});
const list = await client.list((0, path_1.dirname)(filepath));
// attempt to find the "entry" with a matching "name"
const name = (0, path_1.basename)(filepath);
const entry = list.find(e => e.name === name);
const entry = list.find((e) => e.name === name);
if (entry) {
lastModified = entry.date;
lastModified = entry.modifiedAt;
}

@@ -84,11 +70,8 @@ }

}
// XXX: a small timeout seemed necessary otherwise FTP servers
// were returning empty sockets for the file occasionally
// setTimeout(client.get.bind(client, filepath, onfile), 10);
const rs = (await new Promise((resolve, reject) => {
client.get(filepath, (err, res) => {
return err ? reject(err) : resolve(res);
});
}));
rs.once('end', onend);
const stream = new stream_1.PassThrough();
const rs = stream;
client.downloadTo(stream, filepath).then((result) => {
debug(result.message);
client.close();
});
rs.lastModified = lastModified;

@@ -98,3 +81,3 @@ return rs;

catch (err) {
client.destroy();
client.close();
throw err;

@@ -104,3 +87,3 @@ }

function isNotModified() {
if (cache && cache.lastModified && lastModified) {
if (cache?.lastModified && lastModified) {
return +cache.lastModified === +lastModified;

@@ -110,4 +93,4 @@ }

}
}
exports.default = get;
};
exports.ftp = ftp;
//# sourceMappingURL=ftp.js.map

5

dist/http-error.js

@@ -10,7 +10,4 @@ "use strict";

super(message);
Object.setPrototypeOf(this, new.target.prototype);
this.statusCode = statusCode;
this.code = `E${String(message)
.toUpperCase()
.replace(/\s+/g, '')}`;
this.code = `E${String(message).toUpperCase().replace(/\s+/g, '')}`;
}

@@ -17,0 +14,0 @@ }

18

dist/http.d.ts
/// <reference types="node" />
import http from 'http';
/// <reference types="node" />
/// <reference types="node" />
/// <reference types="node" />
import http_ from 'http';
import https from 'https';
import { Readable } from 'stream';
import { UrlWithStringQuery } from 'url';
import { GetUriOptions } from '.';
declare type HttpOrHttpsModule = typeof http | typeof https;
import { GetUriProtocol } from '.';
type HttpOrHttpsModule = typeof http_ | typeof https;
export interface HttpReadableProps {
date?: number;
parsed?: UrlWithStringQuery;
parsed?: URL;
redirects?: HttpReadable[];

@@ -15,5 +17,5 @@ }

}
export interface HttpIncomingMessage extends http.IncomingMessage, HttpReadableProps {
export interface HttpIncomingMessage extends http_.IncomingMessage, HttpReadableProps {
}
export interface HttpOptions extends GetUriOptions, https.RequestOptions {
export interface HttpOptions extends https.RequestOptions {
cache?: HttpReadable;

@@ -27,3 +29,3 @@ http?: HttpOrHttpsModule;

*/
export default function get(parsed: UrlWithStringQuery, opts: HttpOptions): Promise<Readable>;
export declare const http: GetUriProtocol<HttpOptions>;
export {};

38

dist/http.js

@@ -6,2 +6,3 @@ "use strict";

Object.defineProperty(exports, "__esModule", { value: true });
exports.http = void 0;
const http_1 = __importDefault(require("http"));

@@ -11,3 +12,2 @@ const https_1 = __importDefault(require("https"));

const debug_1 = __importDefault(require("debug"));
const url_1 = require("url");
const http_error_1 = __importDefault(require("./http-error"));

@@ -20,5 +20,5 @@ const notfound_1 = __importDefault(require("./notfound"));

*/
async function get(parsed, opts) {
debug('GET %o', parsed.href);
const cache = getCache(parsed, opts.cache);
const http = async (url, opts = {}) => {
debug('GET %o', url.href);
const cache = getCache(url, opts.cache);
// first check the previous Expires and/or Cache-Control headers

@@ -50,3 +50,3 @@ // of a previous response if a `cache` was provided

}
const options = { ...opts, ...parsed };
const options = { ...opts };
// add "cache validation" headers if a `cache` was provided

@@ -68,3 +68,3 @@ if (cache) {

}
const req = mod.get(options);
const req = mod.get(url, options);
const [res] = await (0, once_1.default)(req, 'response');

@@ -74,3 +74,3 @@ const code = res.statusCode || 0;

res.date = Date.now();
res.parsed = parsed;
res.parsed = url;
debug('got %o response status code', code);

@@ -91,12 +91,11 @@ // any 2xx response is a "success" code

redirects.push(res);
let newUri = (0, url_1.resolve)(parsed.href, location);
debug('resolved redirect URL: %o', newUri);
let newUri = new URL(location, url.href);
debug('resolved redirect URL: %o', newUri.href);
let left = maxRedirects - redirects.length;
debug('%o more redirects allowed after this one', left);
// check if redirecting to a different protocol
let parsedUrl = (0, url_1.parse)(newUri);
if (parsedUrl.protocol !== parsed.protocol) {
opts.http = parsedUrl.protocol === 'https:' ? https_1.default : undefined;
if (newUri.protocol !== url.protocol) {
opts.http = newUri.protocol === 'https:' ? https_1.default : undefined;
}
return get(parsedUrl, opts);
return (0, exports.http)(newUri, opts);
}

@@ -122,4 +121,4 @@ }

return res;
}
exports.default = get;
};
exports.http = http;
/**

@@ -147,3 +146,4 @@ * Returns `true` if the provided cache's "freshness" is valid. That is, either

case 'max-age':
expires = (cache.date || 0) + parseInt(subparts[1], 10) * 1000;
expires =
(cache.date || 0) + parseInt(subparts[1], 10) * 1000;
fresh = Date.now() < expires;

@@ -184,5 +184,5 @@ if (fresh) {

*/
function getCache(parsed, cache) {
function getCache(url, cache) {
if (cache) {
if (cache.parsed && cache.parsed.href === parsed.href) {
if (cache.parsed && cache.parsed.href === url.href) {
return cache;

@@ -192,3 +192,3 @@ }

for (let i = 0; i < cache.redirects.length; i++) {
const c = getCache(parsed, cache.redirects[i]);
const c = getCache(url, cache.redirects[i]);
if (c) {

@@ -195,0 +195,0 @@ return c;

6

dist/https.d.ts

@@ -1,8 +0,6 @@

/// <reference types="node" />
import { Readable } from 'stream';
import { UrlWithStringQuery } from 'url';
import { HttpOptions } from './http';
import type { GetUriProtocol } from '.';
/**
* Returns a Readable stream from an "https:" URI.
*/
export default function get(parsed: UrlWithStringQuery, opts: HttpOptions): Promise<Readable>;
export declare const https: GetUriProtocol<HttpOptions>;

11

dist/https.js

@@ -6,11 +6,12 @@ "use strict";

Object.defineProperty(exports, "__esModule", { value: true });
exports.https = void 0;
const https_1 = __importDefault(require("https"));
const http_1 = __importDefault(require("./http"));
const http_1 = require("./http");
/**
* Returns a Readable stream from an "https:" URI.
*/
function get(parsed, opts) {
return (0, http_1.default)(parsed, { ...opts, http: https_1.default });
}
exports.default = get;
const https = (url, opts) => {
return (0, http_1.http)(url, { ...opts, http: https_1.default });
};
exports.https = https;
//# sourceMappingURL=https.js.map

37

dist/index.d.ts
/// <reference types="node" />
/// <reference types="node" />
import { Readable } from 'stream';
import { UrlWithStringQuery } from 'url';
type Protocol<T> = T extends `${infer Protocol}:${infer _}` ? Protocol : never;
export type GetUriProtocol<T> = (parsed: URL, opts?: T) => Promise<Readable>;
export declare const protocols: {
data: GetUriProtocol<import("./data").DataOptions>;
file: GetUriProtocol<import("./file").FileOptions>;
ftp: GetUriProtocol<import("./ftp").FTPOptions>;
http: GetUriProtocol<import("./http").HttpOptions>;
https: GetUriProtocol<import("./http").HttpOptions>;
};
type Protocols = typeof protocols;
type ProtocolOpts<T> = {
[P in keyof Protocols]: Protocol<T> extends P ? Parameters<Protocols[P]>[1] : never;
}[keyof Protocols];
export declare function isValidProtocol(p: string): p is keyof Protocols;
/**
* Async function that returns a `stream.Readable` instance to the
* callback function that will output the contents of the given URI.
* Async function that returns a `stream.Readable` instance that will output
* the contents of the given URI.
*

@@ -17,18 +31,5 @@ * For caching purposes, you can pass in a `stream` instance from a previous

* @param {Object} opts optional "options" object
* @param {Function} fn callback function
* @api public
*/
declare function getUri(uri: string, fn: getUri.GetUriCallback): void;
declare function getUri(uri: string, opts: getUri.GetUriOptions, fn: getUri.GetUriCallback): void;
declare function getUri(uri: string, opts?: getUri.GetUriOptions): Promise<Readable>;
declare namespace getUri {
interface GetUriOptions {
cache?: Readable;
}
type GetUriCallback = (err?: Error | null, res?: Readable) => void;
type GetUriProtocol = (parsed: UrlWithStringQuery, opts: getUri.GetUriOptions) => Promise<Readable>;
const protocols: {
[key: string]: getUri.GetUriProtocol;
};
}
export = getUri;
export declare function getUri<Uri extends string>(uri: Uri | URL, opts?: ProtocolOpts<Uri>): Promise<Readable>;
export {};

90

dist/index.js

@@ -5,52 +5,54 @@ "use strict";

};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getUri = exports.isValidProtocol = exports.protocols = void 0;
const debug_1 = __importDefault(require("debug"));
const url_1 = require("url");
// Built-in protocols
const data_1 = __importDefault(require("./data"));
const file_1 = __importDefault(require("./file"));
const ftp_1 = __importDefault(require("./ftp"));
const http_1 = __importDefault(require("./http"));
const https_1 = __importDefault(require("./https"));
const data_1 = require("./data");
const file_1 = require("./file");
const ftp_1 = require("./ftp");
const http_1 = require("./http");
const https_1 = require("./https");
const debug = (0, debug_1.default)('get-uri');
function getUri(uri, opts, fn) {
const p = new Promise((resolve, reject) => {
debug('getUri(%o)', uri);
if (typeof opts === 'function') {
fn = opts;
opts = undefined;
}
if (!uri) {
reject(new TypeError('Must pass in a URI to "get"'));
return;
}
const parsed = (0, url_1.parse)(uri);
// Strip trailing `:`
const protocol = (parsed.protocol || '').replace(/:$/, '');
if (!protocol) {
reject(new TypeError(`URI does not contain a protocol: ${uri}`));
return;
}
const getter = getUri.protocols[protocol];
if (typeof getter !== 'function') {
throw new TypeError(`Unsupported protocol "${protocol}" specified in URI: ${uri}`);
}
resolve(getter(parsed, opts || {}));
});
if (typeof fn === 'function') {
p.then(rtn => fn(null, rtn), err => fn(err));
exports.protocols = {
data: data_1.data,
file: file_1.file,
ftp: ftp_1.ftp,
http: http_1.http,
https: https_1.https,
};
const VALID_PROTOCOLS = new Set(Object.keys(exports.protocols));
function isValidProtocol(p) {
return VALID_PROTOCOLS.has(p);
}
exports.isValidProtocol = isValidProtocol;
/**
* Async function that returns a `stream.Readable` instance that will output
* the contents of the given URI.
*
* For caching purposes, you can pass in a `stream` instance from a previous
* `getUri()` call as a `cache: stream` option, and if the destination has
* not changed since the last time the endpoint was retreived then the callback
* will be invoked with an Error object with `code` set to "ENOTMODIFIED" and
* `null` for the "stream" instance argument. In this case, you can skip
* retreiving the file again and continue to use the previous payload.
*
* @param {String} uri URI to retrieve
* @param {Object} opts optional "options" object
* @api public
*/
async function getUri(uri, opts) {
debug('getUri(%o)', uri);
if (!uri) {
throw new TypeError('Must pass in a URI to "getUri()"');
}
else {
return p;
const url = typeof uri === 'string' ? new URL(uri) : uri;
// Strip trailing `:`
const protocol = url.protocol.replace(/:$/, '');
if (!isValidProtocol(protocol)) {
throw new TypeError(`Unsupported protocol "${protocol}" specified in URI: "${uri}"`);
}
const getter = exports.protocols[protocol];
return getter(url, opts);
}
(function (getUri) {
getUri.protocols = {
data: data_1.default,
file: file_1.default,
ftp: ftp_1.default,
http: http_1.default,
https: https_1.default
};
})(getUri || (getUri = {}));
module.exports = getUri;
exports.getUri = getUri;
//# sourceMappingURL=index.js.map

1

dist/notfound.js

@@ -13,3 +13,2 @@ "use strict";

this.code = 'ENOTFOUND';
Object.setPrototypeOf(this, new.target.prototype);
}

@@ -16,0 +15,0 @@ }

1

dist/notmodified.js

@@ -14,3 +14,2 @@ "use strict";

this.code = 'ENOTMODIFIED';
Object.setPrototypeOf(this, new.target.prototype);
}

@@ -17,0 +16,0 @@ }

35

package.json
{
"name": "get-uri",
"version": "4.0.0",
"version": "5.0.0",
"description": "Returns a `stream.Readable` from a URI string",

@@ -13,3 +13,3 @@ "main": "./dist/index.js",

"build": "tsc",
"test": "mocha --reporter spec",
"test": "jest",
"prepublishOnly": "npm run build"

@@ -41,24 +41,25 @@ },

"devDependencies": {
"@types/debug": "4",
"@types/fs-extra": "^8.0.1",
"@types/ftp": "^0.3.30",
"@types/node": "^12.12.11",
"@types/debug": "^4.1.7",
"@types/fs-extra": "^8.1.2",
"@types/ftpd": "^0.2.35",
"@types/jest": "^29.5.1",
"@types/node": "^14.18.43",
"async-listen": "^2.1.0",
"ftpd": "https://files-jg1s1zt9l.n8.io/ftpd-v0.2.14.tgz",
"mocha": "^6.2.2",
"rimraf": "^3.0.0",
"jest": "^29.5.0",
"rimraf": "^3.0.2",
"st": "^1.2.2",
"stream-to-array": "2",
"typescript": "^4.4.3"
"ts-jest": "^29.1.0",
"typescript": "^4.9.5"
},
"dependencies": {
"@tootallnate/once": "2",
"data-uri-to-buffer": "3",
"debug": "4",
"file-uri-to-path": "2",
"fs-extra": "^8.1.0",
"ftp": "^0.3.10"
"@tootallnate/once": "^2.0.0",
"basic-ftp": "^5.0.2",
"data-uri-to-buffer": "^3.0.1",
"debug": "^4.3.4",
"fs-extra": "^8.1.0"
},
"engines": {
"node": ">= 8"
"node": ">= 14"
}
}

75

README.md

@@ -34,10 +34,8 @@ get-uri

``` js
var getUri = require('get-uri');
```ts
import { getUri } from 'get-uri';
// `file:` maps to a `fs.ReadStream` instance…
getUri('file:///Users/nrajlich/wat.json', function (err, rs) {
if (err) throw err;
rs.pipe(process.stdout);
});
const stream = await getUri('file:///Users/nrajlich/wat.json');
stream.pipe(process.stdout);
```

@@ -54,15 +52,13 @@

``` js
getUri('http://example.com/resource.json', function (err, rs) {
if (err) {
if ('ENOTFOUND' == err.code) {
// bad file path requested
} else {
// something else bad happened...
throw err;
}
```ts
try {
await getUri('http://example.com/resource.json');
} catch (err) {
if (err.code === 'ENOTFOUND') {
// bad file path requested
} else {
// something else bad happened...
throw err;
}
// your app code…
});
}
```

@@ -88,25 +84,19 @@

``` js
// maps to a `fs.ReadStream` instance
getUri('http://example.com/resource.json', function (err, rs) {
if (err) throw err;
// First time fetches for real
const stream = await getUri('http://example.com/resource.json');
try {
// … some time later, if you need to get this same URI again, pass in the
// previous `stream.Readable` instance as `cache` option to potentially
// receive an "ENOTMODIFIED" response:
var opts = { cache: rs };
getUri('http://example.com/resource.json', opts, function (err, rs2) {
if (err) {
if ('ENOTFOUND' == err.code) {
// bad file path requested
} else if ('ENOTMODIFIED' == err.code) {
// source file has not been modified since last time it was requested,
// so `rs2` is undefined and you are expected to re-use results from
// a previous call to `getUri()`
} else {
// something else bad happened...
throw err;
}
}
});
});
// have an "ENOTMODIFIED" error thrown:
await getUri('http://example.com/resource.json', { cache: stream });
} catch (err) {
if (err.code === 'ENOTMODIFIED') {
// source file has not been modified since last time it was requested,
// so you are expected to re-use results from a previous call to `getUri()`
} else {
// something else bad happened...
throw err;
}
}
```

@@ -118,7 +108,7 @@

### getUri(String uri[, Object options,] Function callback)
### getUri(uri: string | URL, options?: Object]): Promise<Readable>
A `uri` String is required. An optional `options` object may be passed in:
A `uri` is required. An optional `options` object may be passed in:
- `cache` - A `stream.Readable` instance from a previous call to `getUri()` with the same URI. If this option is passed in, and the destination endpoint has not been modified, then an `ENOTMODIFIED` error is returned
- `cache` - A `stream.Readable` instance from a previous call to `getUri()` with the same URI. If this option is passed in, and the destination endpoint has not been modified, then an `ENOTMODIFIED` error is thrown

@@ -129,4 +119,3 @@ Any other options passed in to the `options` object will be passed through

Invokes the given `callback` function with a `stream.Readable` instance to
read the resource at the given `uri`.
Returns a `stream.Readable` instance to read the resource at the given `uri`.

@@ -133,0 +122,0 @@ License

dist/data.js.map

Sorry, the diff of this file is not supported yet

dist/file.js.map

Sorry, the diff of this file is not supported yet

dist/ftp.js.map

Sorry, the diff of this file is not supported yet

dist/http-error.js.map

Sorry, the diff of this file is not supported yet

dist/http.js.map

Sorry, the diff of this file is not supported yet

dist/https.js.map

Sorry, the diff of this file is not supported yet

dist/index.js.map

Sorry, the diff of this file is not supported yet

dist/notfound.js.map

Sorry, the diff of this file is not supported yet

dist/notmodified.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc