ovsx 1.2.0 → 1.3.0

package/src/registry.ts

@@ -10,10 +10,11 @@
 
 import * as http from 'http';
 import * as fs from 'fs';
-import { pipeline, Writable } from 'stream';
-import * as followRedirects from 'follow-redirects';
+import * as semver from 'semver';
+import { pipeline } from 'stream';
+import { jsonResponse, send } from './http';
 import { RegistryOptions } from './registry-options';
-import { DEFAULT_TIMEOUT, redactUrl, rejectError, statusError, withStatus } from './util';
+import { DEFAULT_TIMEOUT, redactUrl, rejectError, statusError } from './util';
 
 export const DEFAULT_URL = 'https://open-vsx.org';
 export const DEFAULT_NAMESPACE_SIZE = 1024;
@@ -22,6 +23,18 @@ export { DEFAULT_TIMEOUT };
 export const DEFAULT_TOKEN_REQUEST_SIZE = 8 * 1024;
 export const DEFAULT_DELETE_SIZE = 64 * 1024;
 
+// Fallback only, for when Authorization is already claimed by Basic auth to a fronting proxy (see
+// tokenHeaders/getRequestOptions).
+// Must stay in the credential headers http.ts drops on a cross-origin redirect.
+const TOKEN_HEADER = 'X-OpenVSX-Token';
+
+/**
+ * Oldest registry version that resolves the personal access token from a header (see #1344).
+ * Registries older than this only look at the `token` query parameter, so `tokenQuery` keeps
+ * sending it to anything below this version.
+ */
+export const MIN_TOKEN_HEADER_REGISTRY_VERSION = '1.3.0';
+
 export class Registry {
 
     readonly url: string;
@@ -30,6 +43,10 @@ export class Registry {
     readonly timeout: number;
     readonly username?: string;
     readonly password?: string;
+    /** Whether the caller pinned a publish size, which then wins over any limit the registry reports. */
+    private readonly publishSizePinned: boolean;
+    private registryVersion?: Promise<RegistryVersion>;
+    private tokenHeaderSupport?: Promise<boolean>;
 
     constructor(options: RegistryOptions = {}) {
         if (options.registryUrl?.endsWith('/'))
@@ -40,6 +57,7 @@ export class Registry {
             this.url = DEFAULT_URL;
 
         this.maxNamespaceSize = options.maxNamespaceSize ?? DEFAULT_NAMESPACE_SIZE;
+        this.publishSizePinned = options.maxPublishSize !== undefined;
         this.maxPublishSize = options.maxPublishSize ?? DEFAULT_PUBLISH_SIZE;
         this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
         this.username = options.username;
@@ -51,45 +69,81 @@ export class Registry {
         return url.hostname === 'open-vsx.org' || url.hostname.endsWith('.open-vsx.org');
     }
 
-    createNamespace(name: string, pat: string): Promise<Response> {
+    async createNamespace(name: string, pat: string): Promise<Response> {
         try {
-            const url = this.getUrl(['api', '-', 'namespace', 'create'], { token: pat });
+            const url = this.getUrl(['api', '-', 'namespace', 'create'], await this.tokenQuery(pat));
             const namespace = { name };
-            return this.post(JSON.stringify(namespace), url, {
-                'Content-Type': 'application/json'
+            return await this.post(JSON.stringify(namespace), url, {
+                'Content-Type': 'application/json',
+                ...this.tokenHeaders(pat)
             }, this.maxNamespaceSize);
         } catch (err) {
             return rejectError(err);
         }
     }
 
-    verifyPat(namespace: string, pat: string): Promise<Response> {
+    async verifyPat(namespace: string, pat: string): Promise<Response> {
+        try {
+            const url = this.getUrl(['api', namespace, 'verify-pat'], await this.tokenQuery(pat));
+            return await this.getJson(url, this.tokenHeaders(pat));
+        } catch (err) {
+            return rejectError(err);
+        }
+    }
+
+    /**
+     * The size limit that applies to this namespace/extension, which a size override can raise above
+     * the registry default. Neither needs to exist yet - a first publish asks about both before
+     * creating either.
+     */
+    async getSizeLimit(namespace: string, extension: string, pat: string): Promise<SizeLimit> {
         try {
-            return this.getJson(this.getUrl(['api', namespace, 'verify-pat'], { token: pat }));
+            const query = { namespace, extension, ...(await this.tokenQuery(pat)) };
+            const url = this.getUrl(['api', '-', 'size-limit'], query);
+            return await this.getJson(url, this.tokenHeaders(pat));
         } catch (err) {
             return rejectError(err);
         }
     }
 
+    /**
+     * Cached per `Registry` instance - callers like `tokenQuery` and `unpublish`'s own version check
+     * would otherwise each fetch it separately, doubling the round trip for a single command.
+     */
     getRegistryVersion(): Promise<RegistryVersion> {
         try {
-            return this.getJson(this.getUrl(['api', 'version']));
+            return this.registryVersion ??= this.getJson(this.getUrl(['api', 'version']));
         } catch (err) {
             return rejectError(err);
         }
     }
 
-    publish(file: string, pat: string): Promise<Extension> {
+    /**
+     * `sizeLimit` is the limit the registry reports for this package, when it could report one. The
+     * transport body cap is raised to it, because a namespace granted more than the default would
+     * otherwise have its upload refused here - by the body size check, before anything reached the
+     * registry that allowed it.
+     */
+    async publish(file: string, pat: string, sizeLimit?: number): Promise<Extension> {
         try {
-            const url = this.getUrl(['api', '-', 'publish'], { token: pat });
-            return this.postFile(file, url, {
-                'Content-Type': 'application/octet-stream'
-            }, this.maxPublishSize);
+            const url = this.getUrl(['api', '-', 'publish'], await this.tokenQuery(pat));
+            return await this.postFile(file, url, {
+                'Content-Type': 'application/octet-stream',
+                ...this.tokenHeaders(pat)
+            }, this.publishBodyLimit(sizeLimit));
         } catch (err) {
             return rejectError(err);
         }
     }
 
+    /** The body cap for a publish. A pinned `maxPublishSize` wins; otherwise it never sits below the registry's own limit. */
+    publishBodyLimit(sizeLimit?: number): number {
+        if (this.publishSizePinned || sizeLimit === undefined) {
+            return this.maxPublishSize;
+        }
+        return Math.max(this.maxPublishSize, sizeLimit);
+    }
+
     requestTrustedPublishingToken(namespace: string, extension: string, idToken: string): Promise<AccessToken> {
         try {
             const url = this.getUrl(['api', '-', 'trusted-publishing', 'token']);
@@ -106,7 +160,7 @@ export class Registry {
      * Deletes extension versions. Omitting `targetVersions` deletes the extension as a whole,
      * i.e. all versions the personal access token's user is allowed to delete.
      */
-    deleteExtension(
+    async deleteExtension(
         namespace: string,
         extension: string,
         targetVersions: TargetPlatformVersion[] | undefined,
@@ -114,13 +168,15 @@ export class Registry {
     ): Promise<Response> {
         try {
             if (!targetVersions) {
-                const url = this.getUrl(['api', namespace, extension, 'delete'], { token: pat, allVersions: 'true' });
-                return this.post('', url, undefined, DEFAULT_DELETE_SIZE);
+                const query = { ...await this.tokenQuery(pat), allVersions: 'true' };
+                const url = this.getUrl(['api', namespace, extension, 'delete'], query);
+                return await this.post('', url, this.tokenHeaders(pat), DEFAULT_DELETE_SIZE);
             }
 
-            const url = this.getUrl(['api', namespace, extension, 'delete'], { token: pat });
-            return this.post(JSON.stringify(targetVersions), url, {
-                'Content-Type': 'application/json'
+            const url = this.getUrl(['api', namespace, extension, 'delete'], await this.tokenQuery(pat));
+            return await this.post(JSON.stringify(targetVersions), url, {
+                'Content-Type': 'application/json',
+                ...this.tokenHeaders(pat)
             }, DEFAULT_DELETE_SIZE);
         } catch (err) {
             return rejectError(err);
@@ -232,9 +288,7 @@ export class Registry {
                 fs.rm(partial, { force: true }, () => reject(err));
             };
 
-            const requestOptions = this.getRequestOptions();
-            const request = this.getProtocol(url)
-                                .request(url, requestOptions, response => {
+            send(url, this.getRequestOptions(), undefined, response => {
                 if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode > 299)) {
                     response.resume();
                     reject(statusError(response));
@@ -261,55 +315,64 @@ export class Registry {
                         fs.rename(partial, file, renameErr => renameErr ? fail(renameErr) : resolve());
                     }
                 });
-            });
-            request.on('error', (err: Error) => fail(err));
-            this.failOnTimeout(request, url, fail);
-            request.end();
+            }, fail);
         });
     }
 
-    getJson<T extends Response>(url: URL): Promise<T> {
+    getJson<T extends Response>(url: URL, headers?: http.OutgoingHttpHeaders): Promise<T> {
         return new Promise((resolve, reject) => {
-            const requestOptions = this.getRequestOptions();
-            const request = this.getProtocol(url)
-                                .request(url, requestOptions, this.getJsonResponse<T>(resolve, reject));
-            request.on('error', reject);
-            this.failOnTimeout(request, url, reject);
-            request.end();
+            send(url, this.getRequestOptions('GET', headers), undefined, jsonResponse<T>(resolve, reject), reject);
         });
     }
 
     post<T extends Response>(content: string | Buffer | Uint8Array, url: URL, headers?: http.OutgoingHttpHeaders, maxBodyLength?: number): Promise<T> {
         return new Promise((resolve, reject) => {
-            const requestOptions = this.getRequestOptions('POST', headers, maxBodyLength);
-            const request = this.getProtocol(url)
-                                .request(url, requestOptions, this.getJsonResponse<T>(resolve, reject));
-            request.on('error', reject);
-            this.failOnTimeout(request, url, reject);
-            request.write(content);
-            request.end();
+            const size = typeof content === 'string' ? Buffer.byteLength(content) : content.byteLength;
+            checkBodySize(size, maxBodyLength);
+            send(url, this.getRequestOptions('POST', headers), () => content, jsonResponse<T>(resolve, reject), reject);
         });
     }
 
-    postFile<T extends Response>(file: string, url: URL, headers?: http.OutgoingHttpHeaders, maxBodyLength?: number): Promise<T> {
+    async postFile<T extends Response>(file: string, url: URL, headers?: http.OutgoingHttpHeaders, maxBodyLength?: number): Promise<T> {
+        checkBodySize((await fs.promises.stat(file)).size, maxBodyLength);
         return new Promise((resolve, reject) => {
-            const stream = fs.createReadStream(file);
-            const requestOptions = this.getRequestOptions('POST', headers, maxBodyLength);
-            const request = this.getProtocol(url)
-                                .request(url, requestOptions, this.getJsonResponse<T>(resolve, reject));
-            stream.on('error', (err: Error) => {
-                request.destroy();
-                reject(err);
-            });
-            request.on('error', (err: Error) => {
-                stream.close();
-                reject(err);
-            });
-            this.failOnTimeout(request, url, reject);
-            stream.on('open', () => stream.pipe(request));
+            // a stream can be read once, so each redirect hop opens the file again
+            send(url, this.getRequestOptions('POST', headers), () => fs.createReadStream(file),
+                jsonResponse<T>(resolve, reject), reject);
         });
     }
 
+    /**
+     * The header a personal access token travels in. `Authorization: Bearer` is standard and what
+     * log/proxy redaction and secret scanners already expect, so it's preferred - except when
+     * `username`/`password` are set, where `Authorization` is already claimed by Basic auth to a
+     * fronting reverse proxy (see `getRequestOptions`) and the token falls back to `TOKEN_HEADER`.
+     */
+    private tokenHeaders(pat: string): http.OutgoingHttpHeaders {
+        return (this.username && this.password)
+            ? { [TOKEN_HEADER]: pat }
+            : { Authorization: `Bearer ${pat}` };
+    }
+
+    /**
+     * The `token` query parameter to add alongside the header, for registries that predate header
+     * support (see #1344) - empty once the registry is known to be new enough to not need it.
+     *
+     * Best-effort and cached per `Registry` instance: a registry that doesn't expose `/api/version`,
+     * or reports a version that doesn't parse as semver, is assumed too old to know about the header,
+     * same as before this method existed - the query parameter is kept rather than risking a request
+     * that only carries a header such a registry never looks at.
+     */
+    private tokenQuery(pat: string): Promise<Record<string, string>> {
+        return (this.tokenHeaderSupport ??= this.getRegistryVersion()
+            .then(({ version }) => {
+                const parsed = semver.coerce(version);
+                return !!parsed && semver.gte(parsed, MIN_TOKEN_HEADER_REGISTRY_VERSION);
+            })
+            .catch(() => false)
+        ).then(supported => supported ? {} : { token: pat } as Record<string, string>);
+    }
+
     private getUrl(segments: string[], query?: Record<string, string>): URL {
         const url = new URL(this.url);
         const basePath = url.pathname.replace(/\/+$/, '');
@@ -321,33 +384,7 @@ export class Registry {
         return url;
     }
 
-    private getProtocol(url: URL) {
-        return url.protocol === 'https:' ? followRedirects.https : followRedirects.http;
-    }
-
-    /**
-     * Node's `timeout` option only raises an event - the request stays open, which is why a server
-     * that accepts a connection and then says nothing used to hold a command open indefinitely.
-     * Destroying the request with an error routes through the error handling each caller already
-     * has, so a stalled request rejects the way any other failure does. With a timeout of zero the
-     * event never fires and this does nothing.
-     */
-    // Typed on Writable because both http.ClientRequest and follow-redirects' wrapper are ones, and
-    // all this needs is the timeout event and destroy.
-    private failOnTimeout(request: Writable, url: URL, fail: (err: Error) => void): void {
-        request.on('timeout', () => {
-            // Reported before the request is torn down, rather than by destroying it with the error.
-            // Destroying raises errors of its own - ECONNRESET on the response, a premature close
-            // from pipeline - and node guarantees no order between those and the request's own. In
-            // practice the request's arrives first, so this is belt and braces rather than the thing
-            // that stops the wrong error being reported; that is the caller claiming the failure
-            // before it does any asynchronous cleanup.
-            fail(new Error(`No response from ${redactUrl(url)} for ${this.timeout} ms.`));
-            request.destroy();
-        });
-    }
-
-    private getRequestOptions(method?: string, headers?: http.OutgoingHttpHeaders, maxBodyLength?: number): http.RequestOptions {
+    private getRequestOptions(method?: string, headers?: http.OutgoingHttpHeaders): http.RequestOptions {
         if (this.username && this.password) {
             headers ??= {};
             const credentials = Buffer.from(this.username + ':' + this.password).toString('base64');
@@ -356,52 +393,19 @@ export class Registry {
         return {
             method,
             headers,
-            maxBodyLength,
             timeout: this.timeout
-        } as http.RequestOptions;
-    }
-
-    private getJsonResponse<T extends Response>(resolve: (value: T) => void, reject: (reason: any) => void): (res: http.IncomingMessage) => void {
-        return response => {
-            response.setEncoding('utf-8');
-            let json = '';
-            // A connection lost after the headers have arrived ends the response without 'end' ever
-            // firing, so without this the promise is never settled and the command waits on a body
-            // that is not coming. The configured timeout would eventually rescue it, but rejecting
-            // here reports what actually happened instead of thirty seconds of silence.
-            response.on('error', reject);
-            response.on('data', chunk => json += chunk);
-            response.on('end', () => {
-                if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode > 299)) {
-                    if (json.startsWith('{')) {
-                        try {
-                            const parsed = JSON.parse(json) as ErrorResponse;
-                            const message = parsed.message || parsed.error;
-                            if (message) {
-                                // keep the status: the message alone cannot say whether retrying is worth it
-                                reject(withStatus(new Error(message), response.statusCode));
-                                return;
-                            }
-                        } catch (err) {
-                            // Ignore the error and reject with response status
-                        }
-                    }
-                    reject(statusError(response));
-                } else if (json.startsWith('<!DOCTYPE html>')) {
-                    reject(json);
-                } else {
-                    try {
-                        resolve(JSON.parse(json));
-                    } catch (err) {
-                        reject(err);
-                    }
-                }
-            });
         };
     }
 
 }
 
+/** Refuses a request body larger than `maxBodyLength` before anything is sent. */
+function checkBodySize(size: number, maxBodyLength?: number): void {
+    if (maxBodyLength !== undefined && size > maxBodyLength) {
+        throw new Error(`The request body of ${size} bytes is larger than the limit of ${maxBodyLength} bytes.`);
+    }
+}
+
 export interface Response {
     success?: string;
     warning?: string;
@@ -466,6 +470,10 @@ export interface RegistryVersion extends Response {
     trustedPublishingAudience?: string;
 }
 
+export interface SizeLimit extends Response {
+    maxSize: number;
+}
+
 export interface AccessToken extends Response {
     id: number;
     value?: string;

package/src/util.ts

@@ -8,15 +8,14 @@
  * SPDX-License-Identifier: EPL-2.0
  ********************************************************************************/
 
+import * as crypto from 'crypto';
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
-import * as tmp from 'tmp';
 import * as http from 'http';
 import { RegistryOptions } from './registry-options';
 import { TrustedPublishingOptions } from './trusted-publishing-options';
 
-export { promisify } from 'util';
-
 export function addEnvOptions(options: RegistryOptions): void {
     options.registryUrl ??= process.env.OVSX_REGISTRY_URL;
     options.pat ??= process.env.OVSX_PAT;
@@ -76,36 +75,39 @@ export function matchExtensionId(id: string): RegExpExecArray | null {
     return /^([\w-]+)(?:\.|\/)([\w-]+)$/.exec(id);
 }
 
-export function optionalStat(path: fs.PathLike): Promise<fs.Stats | undefined> {
-    return new Promise((resolve, reject) => {
-        fs.stat(path, (err, stats) => resolve(stats));
-    });
-}
-
-export function makeDirs(path: fs.PathLike): Promise<void> {
-    return new Promise((resolve, reject) => {
-        if (fs.existsSync(path)) {
-            resolve();
-        } else {
-            fs.mkdir(path, { recursive: true }, (err: NodeJS.ErrnoException | null) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve();
-            });
+/**
+ * Levenshtein distance between `a` and `b`: the minimum number of single-character insertions,
+ * deletions or substitutions needed to turn one into the other. Used to suggest the closest known
+ * command for a typo.
+ */
+export function levenshtein(a: string, b: string): number {
+    if (a === b) {
+        return 0;
+    }
+    // The distance is symmetric, so keep the shorter string in `b` to bound the row size.
+    if (b.length > a.length) {
+        [a, b] = [b, a];
+    }
+    // A single row of the edit distance matrix, seeded with the distance between the empty prefix
+    // of `a` and every prefix of `b`.
+    const row = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i++) {
+        let diagonal = row[0];
+        row[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const above = row[j];
+            row[j] = Math.min(row[j - 1] + 1, above + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
+            diagonal = above;
         }
-    });
+    }
+    return row[b.length];
 }
 
-export function createTempFile(options: tmp.TmpNameOptions): Promise<string> {
-    return new Promise((resolve, reject) => {
-        tmp.tmpName(options, (err: Error | null, name: string) => {
-            if (err)
-                reject(err);
-            else
-                resolve(name);
-        });
-    });
+/**
+ * Returns a random, not-yet-created file path ending in `postfix`, directly in the OS temp directory.
+ */
+export function getTempFilePath(postfix = ''): string {
+    return path.join(os.tmpdir(), `ovsx-${crypto.randomUUID()}${postfix}`);
 }
 
 export function rejectError(err: any) {
@@ -167,10 +169,12 @@ export function withStatus(error: Error, status?: number): StatusError {
 /**
  * A URL in the form it can safely be printed: no user info and no query string.
  *
- * `createNamespace`, `verifyPat`, `publish` and `delete` all put the personal access token in a
- * `token` query parameter, and an error message goes straight to stderr and from there into CI logs.
- * The query carries nothing an error needs, so it is dropped whole rather than filtered key by key -
- * a filter has to be kept in step with every parameter anyone ever adds.
+ * The personal access token travels in a header now, but `createNamespace`, `verifyPat`, `publish`
+ * and `delete` still carry it in the query string too when talking to a registry too old to resolve
+ * it from the header (see `Registry.tokenQuery`, #1344). An error message goes straight to stderr
+ * and from there into CI logs, and the query carries nothing an error needs - so it stays dropped
+ * whole rather than filtered key by key, a filter having to be kept in step with every parameter
+ * anyone ever adds.
  */
 export function redactUrl(url: URL | string): string {
     try {
@@ -189,24 +193,8 @@ export function statusError(response: http.IncomingMessage): StatusError {
     return withStatus(new Error(message), response.statusCode);
 }
 
-export function readFile(name: string, packagePath?: string, encoding: BufferEncoding = 'utf-8'): Promise<string> {
-    return new Promise((resolve, reject) => {
-        fs.readFile(
-            path.join(packagePath ?? process.cwd(), name),
-            { encoding },
-            (err: NodeJS.ErrnoException | null, content: string) => {
-                if (err) {
-                    reject(err);
-                } else {
-                    resolve(content);
-                }
-            }
-        );
-    });
-}
-
 export async function readManifest(packagePath?: string): Promise<Manifest> {
-    const content = await readFile('package.json', packagePath);
+    const content = await fs.promises.readFile(path.join(packagePath ?? process.cwd(), 'package.json'), 'utf-8');
     return JSON.parse(content);
 }
 
@@ -222,26 +210,9 @@ export function validateManifest(manifest: Manifest): void {
     }
 }
 
-export function writeFile(name: string, content: string, packagePath?: string, encoding: BufferEncoding = 'utf-8'): Promise<void> {
-    return new Promise((resolve, reject) => {
-        fs.writeFile(
-            path.join(packagePath ?? process.cwd(), name),
-            content,
-            { encoding },
-            (err: NodeJS.ErrnoException | null) => {
-                if (err) {
-                    reject(err);
-                } else {
-                    resolve();
-                }
-            }
-        );
-    });
-}
-
 export function writeManifest(manifest: Manifest, packagePath?: string): Promise<void> {
     const content = JSON.stringify(manifest, null, 4);
-    return writeFile('package.json', content, packagePath);
+    return fs.promises.writeFile(path.join(packagePath ?? process.cwd(), 'package.json'), content, 'utf-8');
 }
 
 export interface Manifest {

package/src/verify.ts

@@ -14,7 +14,7 @@
 import * as crypto from 'crypto';
 import * as fs from 'fs';
 import { Registry, Extension } from './registry';
-import { addEnvOptions, createTempFile } from './util';
+import { addEnvOptions, getTempFilePath } from './util';
 import { readVSIXPackage, readZip } from './zip';
 import { VerifyOptions } from './verify-options';
 
@@ -82,7 +82,7 @@ async function resolveVersion(registry: Registry, extension: Extension, version:
 }
 
 async function downloadSignature(registry: Registry, url: string): Promise<Buffer> {
-    const sigzipPath = await createTempFile({ postfix: '.sigzip' });
+    const sigzipPath = getTempFilePath('.sigzip');
     try {
         await registry.download(sigzipPath, new URL(url));
         const entries = await readZip(sigzipPath, name => name === SIGNATURE_ENTRY);
@@ -97,7 +97,7 @@ async function downloadSignature(registry: Registry, url: string): Promise<Buffe
 }
 
 async function downloadPublicKey(registry: Registry, url: string): Promise<string> {
-    const publicKeyPath = await createTempFile({ postfix: '.pem' });
+    const publicKeyPath = getTempFilePath('.pem');
     try {
         await registry.download(publicKeyPath, new URL(url));
         return await fs.promises.readFile(publicKeyPath, 'utf-8');

package/src/zip.ts

@@ -9,19 +9,10 @@
  ********************************************************************************/
 import * as crypto from 'crypto';
 import * as yauzl from 'yauzl-promise';
-import { Readable } from 'stream';
+import { buffer } from 'stream/consumers';
 import { pipeline } from 'stream/promises';
 import { Manifest } from './util';
 
-async function bufferStream(stream: Readable): Promise<Buffer> {
-	return await new Promise((resolve, reject) => {
-		const buffers: Buffer[] = [];
-		stream.on('data', buffer => buffers.push(buffer));
-		stream.once('error', reject);
-		stream.once('end', () => resolve(Buffer.concat(buffers)));
-	});
-}
-
 export async function readZip(packagePath: string, filter: (name: string) => boolean): Promise<Map<string, Buffer>> {
 	const result = new Map<string, Buffer>();
 	const zipfile = await yauzl.open(packagePath);
@@ -30,8 +21,7 @@ export async function readZip(packagePath: string, filter: (name: string) => boo
 			const name = entry.filename.toLowerCase();
 			if (filter(name)) {
 				const stream = await zipfile.openReadStream(entry);
-				const buffer = await bufferStream(stream);
-				result.set(name, buffer);
+				result.set(name, await buffer(stream));
 			}
 		}
 	} finally {

package/lib/version.d.ts

@@ -1,2 +0,0 @@
-export declare const LIB_VERSION = "1.2.0";
-//# sourceMappingURL=version.d.ts.map

package/lib/version.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,UAAU,CAAC"}

package/lib/version.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIB_VERSION = void 0;
-exports.LIB_VERSION = "1.2.0";
-//# sourceMappingURL=version.js.map

package/lib/version.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":";;;AAAa,QAAA,WAAW,GAAG,OAAO,CAAC"}

package/src/version.ts

@@ -1 +0,0 @@
-export const LIB_VERSION = "1.2.0";