lean-s3 0.2.2 → 0.3.0

package/dist/S3Client.js

@@ -1,632 +0,0 @@
-import { request, Agent } from "undici";
-import { XMLParser, XMLBuilder } from "fast-xml-parser";
-import S3File from "./S3File.js";
-import S3Error from "./S3Error.js";
-import S3BucketEntry from "./S3BucketEntry.js";
-import KeyCache from "./KeyCache.js";
-import * as amzDate from "./AmzDate.js";
-import * as sign from "./sign.js";
-import { buildRequestUrl, getRangeHeader, prepareHeadersForSigning, } from "./url.js";
-import { getResponseError } from "./error.js";
-export const write = Symbol("write");
-export const stream = Symbol("stream");
-const xmlParser = new XMLParser();
-const xmlBuilder = new XMLBuilder({
-    attributeNamePrefix: "$",
-    ignoreAttributes: false,
-});
-/**
- * A configured S3 bucket instance for managing files.
- *
- * @example
- * ```js
- * // Basic bucket setup
- * const bucket = new S3Client({
- *   bucket: "my-bucket",
- *   accessKeyId: "key",
- *   secretAccessKey: "secret"
- * });
- * // Get file instance
- * const file = bucket.file("image.jpg");
- * await file.delete();
- * ```
- */
-export default class S3Client {
-    #options;
-    #keyCache = new KeyCache();
-    // TODO: pass options to this in client? Do we want to expose tjhe internal use of undici?
-    #dispatcher = new Agent();
-    /**
-     * Create a new instance of an S3 bucket so that credentials can be managed from a single instance instead of being passed to every method.
-     *
-     * @param  options The default options to use for the S3 client.
-     */
-    constructor(options) {
-        if (!options) {
-            throw new Error("`options` is required.");
-        }
-        const { accessKeyId, secretAccessKey, endpoint, region, bucket, sessionToken, } = options;
-        if (!accessKeyId || typeof accessKeyId !== "string") {
-            throw new Error("`accessKeyId` is required.");
-        }
-        if (!secretAccessKey || typeof secretAccessKey !== "string") {
-            throw new Error("`secretAccessKey` is required.");
-        }
-        if (!endpoint || typeof endpoint !== "string") {
-            throw new Error("`endpoint` is required.");
-        }
-        if (!region || typeof region !== "string") {
-            throw new Error("`region` is required.");
-        }
-        if (!bucket || typeof bucket !== "string") {
-            throw new Error("`bucket` is required.");
-        }
-        this.#options = {
-            accessKeyId,
-            secretAccessKey,
-            endpoint,
-            region,
-            bucket,
-            sessionToken,
-        };
-    }
-    /**
-     * Creates an S3File instance for the given path.
-     *
-     * @param {string} path The path to the object in the bucket. ALso known as [object key](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html).
-     * We recommend not using the following characters in a key name because of significant special character handling, which isn't consistent across all applications (see [AWS docs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html)):
-     * - Backslash (`\\`)
-     * - Left brace (`{`)
-     * - Non-printable ASCII characters (128–255 decimal characters)
-     * - Caret or circumflex (`^`)
-     * - Right brace (`}`)
-     * - Percent character (`%`)
-     * - Grave accent or backtick (`\``)
-     * - Right bracket (`]`)
-     * - Quotation mark (`"`)
-     * - Greater than sign (`>`)
-     * - Left bracket (`[`)
-     * - Tilde (`~`)
-     * - Less than sign (`<`)
-     * - Pound sign (`#`)
-     * - Vertical bar or pipe (`|`)
-     *
-     * lean-s3 does not enforce these restrictions.
-     *
-     * @param {Partial<CreateFileInstanceOptions>} [options] TODO
-     * @example
-     * ```js
-     * const file = client.file("image.jpg");
-     * await file.write(imageData);
-     *
-     * const configFile = client.file("config.json", {
-     *   type: "application/json",
-     *   acl: "private"
-     * });
-     * ```
-     */
-    file(path, options) {
-        // TODO: Check max path length in bytes
-        return new S3File(this, path, undefined, undefined, undefined);
-    }
-    /**
-     * Generate a presigned URL for temporary access to a file.
-     * Useful for generating upload/download URLs without exposing credentials.
-     * @returns The operation on {@link S3Client#presign.path} as a pre-signed URL.
-     *
-     * @example
-     * ```js
-     * const downloadUrl = client.presign("file.pdf", {
-     *   expiresIn: 3600 // 1 hour
-     * });
-     * ```
-     */
-    presign(path, { method = "GET", expiresIn = 3600, // TODO: Maybe rename this to expiresInSeconds
-    storageClass, acl, region: regionOverride, bucket: bucketOverride, endpoint: endpointOverride, } = {}) {
-        const now = new Date();
-        const date = amzDate.getAmzDate(now);
-        const options = this.#options;
-        const region = regionOverride ?? options.region;
-        const bucket = bucketOverride ?? options.bucket;
-        const endpoint = endpointOverride ?? options.endpoint;
-        const res = buildRequestUrl(endpoint, bucket, region, path);
-        const query = buildSearchParams(`${options.accessKeyId}/${date.date}/${region}/s3/aws4_request`, date, expiresIn, "host", undefined, storageClass, options.sessionToken, acl);
-        const dataDigest = sign.createCanonicalDataDigestHostOnly(method, res.pathname, query, res.host);
-        const signingKey = this.#keyCache.computeIfAbsent(date, region, options.accessKeyId, options.secretAccessKey);
-        const signature = sign.signCanonicalDataHash(signingKey, dataDigest, date, region);
-        // See `buildSearchParams` for casing on this parameter
-        res.search = `${query}&X-Amz-Signature=${signature}`;
-        return res.toString();
-    }
-    /**
-     * Uses [`DeleteObjects`](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjects.html) to delete multiple objects in a single request.
-     */
-    async deleteObjects(objects, options = {}) {
-        const body = xmlBuilder.build({
-            Delete: {
-                Quiet: true,
-                Object: objects.map(o => ({
-                    Key: typeof o === "string" ? o : o.key,
-                })),
-            },
-        });
-        const response = await this._signedRequest("POST", "", "delete=", // "=" is needed by minio for some reason
-        body, {
-            "content-md5": sign.md5Base64(body),
-        }, undefined, undefined, this.#options.bucket, options.signal);
-        if (response.statusCode === 200) {
-            const text = await response.body.text();
-            let res = undefined;
-            try {
-                // Quite mode omits all deleted elements, so it will be parsed as "", wich we need to coalasce to null/undefined
-                res = (xmlParser.parse(text)?.DeleteResult || undefined)?.Error ?? [];
-            }
-            catch (cause) {
-                // Possible according to AWS docs
-                throw new S3Error("Unknown", "", {
-                    message: "S3 service responded with invalid XML.",
-                    cause,
-                });
-            }
-            if (!res || !Array.isArray(res)) {
-                throw new S3Error("Unknown", "", {
-                    message: "Could not process response.",
-                });
-            }
-            const errors = res.map(e => ({
-                code: e.Code,
-                key: e.Key,
-                message: e.Message,
-                versionId: e.VersionId,
-            }));
-            return errors.length > 0 ? { errors } : null;
-        }
-        if (400 <= response.statusCode && response.statusCode < 500) {
-            throw await getResponseError(response, "");
-        }
-        response.body.dump(); // undici docs state that we should dump the body if not used
-        throw new Error(`Response code not implemented yet: ${response.statusCode}`);
-    }
-    /**
-     * Creates a new bucket on the S3 server.
-     *
-     * @param name The name of the bucket to create. AWS the name according to [some rules](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html). The most important ones are:
-     * - Bucket names must be between `3` (min) and `63` (max) characters long.
-     * - Bucket names can consist only of lowercase letters, numbers, periods (`.`), and hyphens (`-`).
-     * - Bucket names must begin and end with a letter or number.
-     * - Bucket names must not contain two adjacent periods.
-     * - Bucket names must not be formatted as an IP address (for example, `192.168.5.4`).
-     *
-     * @throws {Error} If the bucket name is invalid.
-     * @throws {S3Error} If the bucket could not be created, e.g. if it already exists.
-     * @remarks Uses [`CreateBucket`](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucket.html)
-     */
-    async createBucket(name, options) {
-        ensureValidBucketName(name);
-        let body = undefined;
-        if (options) {
-            const location = options.location && (options.location.name || options.location.type)
-                ? {
-                    Name: options.location.name ?? undefined,
-                    Type: options.location.type ?? undefined,
-                }
-                : undefined;
-            const bucket = options.info && (options.info.dataRedundancy || options.info.type)
-                ? {
-                    DataRedundancy: options.info.dataRedundancy ?? undefined,
-                    Type: options.info.type ?? undefined,
-                }
-                : undefined;
-            body =
-                location || bucket || options.locationConstraint
-                    ? xmlBuilder.build({
-                        CreateBucketConfiguration: {
-                            $xmlns: "http://s3.amazonaws.com/doc/2006-03-01/",
-                            LocationConstraint: options.locationConstraint ?? undefined,
-                            Location: location,
-                            Bucket: bucket,
-                        },
-                    })
-                    : undefined;
-        }
-        const additionalSignedHeaders = body
-            ? { "content-md5": sign.md5Base64(body) }
-            : undefined;
-        const response = await this._signedRequest("PUT", "", undefined, body, additionalSignedHeaders, undefined, undefined, name, options?.signal);
-        if (400 <= response.statusCode && response.statusCode < 500) {
-            throw await getResponseError(response, "");
-        }
-        await response.body.dump(); // undici docs state that we should dump the body if not used
-        if (response.statusCode === 200) {
-            return;
-        }
-        throw new Error(`Response code not supported: ${response.statusCode}`);
-    }
-    /**
-     * Deletes a bucket from the S3 server.
-     * @param name The name of the bucket to delete. Same restrictions as in {@link S3Client#createBucket}.
-     * @throws {Error} If the bucket name is invalid.
-     * @throws {S3Error} If the bucket could not be deleted, e.g. if it is not empty.
-     * @remarks Uses [`DeleteBucket`](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucket.html).
-     */
-    async deleteBucket(name, options) {
-        ensureValidBucketName(name);
-        const response = await this._signedRequest("DELETE", "", undefined, undefined, undefined, undefined, undefined, name, options?.signal);
-        if (400 <= response.statusCode && response.statusCode < 500) {
-            throw await getResponseError(response, "");
-        }
-        await response.body.dump(); // undici docs state that we should dump the body if not used
-        if (response.statusCode === 204) {
-            return;
-        }
-        throw new Error(`Response code not supported: ${response.statusCode}`);
-    }
-    /**
-     * Checks if a bucket exists.
-     * @param name The name of the bucket to delete. Same restrictions as in {@link S3Client#createBucket}.
-     * @throws {Error} If the bucket name is invalid.
-     * @remarks Uses [`HeadBucket`](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadBucket.html).
-     */
-    async bucketExists(name, options) {
-        ensureValidBucketName(name);
-        const response = await this._signedRequest("HEAD", "", undefined, undefined, undefined, undefined, undefined, name, options?.signal);
-        if (response.statusCode !== 404 &&
-            400 <= response.statusCode &&
-            response.statusCode < 500) {
-            throw await getResponseError(response, "");
-        }
-        await response.body.dump(); // undici docs state that we should dump the body if not used
-        if (response.statusCode === 200) {
-            return true;
-        }
-        if (response.statusCode === 404) {
-            return false;
-        }
-        throw new Error(`Response code not supported: ${response.statusCode}`);
-    }
-    //#region list
-    /**
-     * Uses [`ListObjectsV2`](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html) to iterate over all keys. Pagination and continuation is handled internally.
-     */
-    async *listIterating(options) {
-        // only used to get smaller pages, so we can test this properly
-        const maxKeys = options?.internalPageSize ?? undefined;
-        let res = undefined;
-        let continuationToken = undefined;
-        do {
-            res = await this.list({
-                ...options,
-                maxKeys,
-                continuationToken,
-            });
-            if (!res || res.contents.length === 0) {
-                break;
-            }
-            yield* res.contents;
-            continuationToken = res.nextContinuationToken;
-        } while (continuationToken);
-    }
-    /**
-     * Implements [`ListObjectsV2`](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html) to iterate over all keys.
-     */
-    async list(options = {}) {
-        // See `benchmark-operations.js` on why we don't use URLSearchParams but string concat
-        // tldr: This is faster and we know the params exactly, so we can focus our encoding
-        // ! minio requires these params to be in alphabetical order
-        let query = "";
-        if (typeof options.continuationToken !== "undefined") {
-            if (typeof options.continuationToken !== "string") {
-                throw new TypeError("`continuationToken` should be a `string`.");
-            }
-            query += `continuation-token=${encodeURIComponent(options.continuationToken)}&`;
-        }
-        query += "list-type=2";
-        if (typeof options.maxKeys !== "undefined") {
-            if (typeof options.maxKeys !== "number") {
-                throw new TypeError("`maxKeys` should be a `number`.");
-            }
-            query += `&max-keys=${options.maxKeys}`; // no encoding needed, it's a number
-        }
-        // TODO: delimiter?
-        // plan `if(a)` check, so empty strings will also not go into this branch, omitting the parameter
-        if (options.prefix) {
-            if (typeof options.prefix !== "string") {
-                throw new TypeError("`prefix` should be a `string`.");
-            }
-            query += `&prefix=${encodeURIComponent(options.prefix)}`;
-        }
-        if (typeof options.startAfter !== "undefined") {
-            if (typeof options.startAfter !== "string") {
-                throw new TypeError("`startAfter` should be a `string`.");
-            }
-            query += `&start-after=${encodeURIComponent(options.startAfter)}`;
-        }
-        const response = await this._signedRequest("GET", "", query, undefined, undefined, undefined, undefined, options.bucket ?? this.#options.bucket, options.signal);
-        if (response.statusCode === 200) {
-            const text = await response.body.text();
-            let res = undefined;
-            try {
-                res = xmlParser.parse(text)?.ListBucketResult;
-            }
-            catch (cause) {
-                // Possible according to AWS docs
-                throw new S3Error("Unknown", "", {
-                    message: "S3 service responded with invalid XML.",
-                    cause,
-                });
-            }
-            if (!res) {
-                throw new S3Error("Unknown", "", {
-                    message: "Could not read bucket contents.",
-                });
-            }
-            // S3 is weird and doesn't return an array if there is only one item
-            const contents = Array.isArray(res.Contents)
-                ? (res.Contents?.map(S3BucketEntry.parse) ?? [])
-                : res.Contents
-                    ? [res.Contents]
-                    : [];
-            return {
-                name: res.Name,
-                prefix: res.Prefix,
-                startAfter: res.StartAfter,
-                isTruncated: res.IsTruncated,
-                continuationToken: res.ContinuationToken,
-                maxKeys: res.MaxKeys,
-                keyCount: res.KeyCount,
-                nextContinuationToken: res.NextContinuationToken,
-                contents,
-            };
-        }
-        response.body.dump(); // undici docs state that we should dump the body if not used
-        throw new Error(`Response code not implemented yet: ${response.statusCode}`);
-    }
-    //#endregion
-    /**
-     * Do not use this. This is an internal method.
-     * TODO: Maybe move this into a separate free function?
-     * @internal
-     */
-    async _signedRequest(method, pathWithoutBucket, query, body, additionalSignedHeaders, additionalUnsignedHeaders, contentHash, bucket, signal = undefined) {
-        const endpoint = this.#options.endpoint;
-        const region = this.#options.region;
-        const effectiveBucket = bucket ?? this.#options.bucket;
-        const url = buildRequestUrl(endpoint, effectiveBucket, region, pathWithoutBucket);
-        if (query) {
-            url.search = query;
-        }
-        const now = amzDate.now();
-        const contentHashStr = contentHash?.toString("hex") ?? sign.unsignedPayload;
-        // Signed headers have to be sorted
-        // To enhance sorting, we're adding all possible values somehow pre-ordered
-        const headersToBeSigned = prepareHeadersForSigning({
-            host: url.host,
-            "x-amz-date": now.dateTime,
-            "x-amz-content-sha256": contentHashStr,
-            ...additionalSignedHeaders,
-        });
-        try {
-            return await request(url, {
-                method,
-                signal,
-                dispatcher: this.#dispatcher,
-                headers: {
-                    ...headersToBeSigned,
-                    authorization: this.#getAuthorizationHeader(method, url.pathname, query ?? "", now, headersToBeSigned, region, contentHashStr, this.#options.accessKeyId, this.#options.secretAccessKey),
-                    ...additionalUnsignedHeaders,
-                    "user-agent": "lean-s3",
-                },
-                body,
-            });
-        }
-        catch (cause) {
-            signal?.throwIfAborted();
-            throw new S3Error("Unknown", pathWithoutBucket, {
-                message: "Unknown error during S3 request.",
-                cause,
-            });
-        }
-    }
-    /**
-     * @internal
-     * @param {import("./index.d.ts").UndiciBodyInit} data TODO
-     */
-    async [write](path, data, contentType, contentLength, contentHash, rageStart, rangeEndExclusive, signal = undefined) {
-        const bucket = this.#options.bucket;
-        const endpoint = this.#options.endpoint;
-        const region = this.#options.region;
-        const url = buildRequestUrl(endpoint, bucket, region, path);
-        const now = amzDate.now();
-        const contentHashStr = contentHash?.toString("hex") ?? sign.unsignedPayload;
-        // Signed headers have to be sorted
-        // To enhance sorting, we're adding all possible values somehow pre-ordered
-        const headersToBeSigned = prepareHeadersForSigning({
-            "content-length": contentLength?.toString() ?? undefined,
-            "content-type": contentType,
-            host: url.host,
-            range: getRangeHeader(rageStart, rangeEndExclusive),
-            "x-amz-content-sha256": contentHashStr,
-            "x-amz-date": now.dateTime,
-        });
-        /** @type {import("undici").Dispatcher.ResponseData<unknown> | undefined} */
-        let response = undefined;
-        try {
-            response = await request(url, {
-                method: "PUT",
-                signal,
-                dispatcher: this.#dispatcher,
-                headers: {
-                    ...headersToBeSigned,
-                    authorization: this.#getAuthorizationHeader("PUT", url.pathname, url.search, now, headersToBeSigned, region, contentHashStr, this.#options.accessKeyId, this.#options.secretAccessKey),
-                    "user-agent": "lean-s3",
-                },
-                body: data,
-            });
-        }
-        catch (cause) {
-            signal?.throwIfAborted();
-            throw new S3Error("Unknown", path, {
-                message: "Unknown error during S3 request.",
-                cause,
-            });
-        }
-        const status = response.statusCode;
-        if (200 <= status && status < 300) {
-            // everything seemed to work, no need to process response body
-            return;
-        }
-        throw await getResponseError(response, path);
-    }
-    // TODO: Support abortSignal
-    /**
-     * @internal
-     */
-    [stream](path, contentHash, rageStart, rangeEndExclusive) {
-        const bucket = this.#options.bucket;
-        const endpoint = this.#options.endpoint;
-        const region = this.#options.region;
-        const now = amzDate.now();
-        const url = buildRequestUrl(endpoint, bucket, region, path);
-        const range = getRangeHeader(rageStart, rangeEndExclusive);
-        const contentHashStr = contentHash?.toString("hex") ?? sign.unsignedPayload;
-        const headersToBeSigned = prepareHeadersForSigning({
-            "amz-sdk-invocation-id": crypto.randomUUID(),
-            // TODO: Maybe support retries and do "amz-sdk-request": attempt=1; max=3
-            host: url.host,
-            range,
-            // Hetzner doesnt care if the x-amz-content-sha256 header is missing, R2 requires it to be present
-            "x-amz-content-sha256": contentHashStr,
-            "x-amz-date": now.dateTime,
-        });
-        const ac = new AbortController();
-        return new ReadableStream({
-            type: "bytes",
-            start: controller => {
-                const onNetworkError = (cause) => {
-                    controller.error(new S3Error("Unknown", path, {
-                        message: undefined,
-                        cause,
-                    }));
-                };
-                request(url, {
-                    method: "GET",
-                    signal: ac.signal,
-                    dispatcher: this.#dispatcher,
-                    headers: {
-                        ...headersToBeSigned,
-                        authorization: this.#getAuthorizationHeader("GET", url.pathname, url.search, now, headersToBeSigned, region, contentHashStr, this.#options.accessKeyId, this.#options.secretAccessKey),
-                        "user-agent": "lean-s3",
-                    },
-                }).then(response => {
-                    const onData = controller.enqueue.bind(controller);
-                    const onClose = controller.close.bind(controller);
-                    const expectPartialResponse = range !== undefined;
-                    const status = response.statusCode;
-                    if (status === 200) {
-                        if (expectPartialResponse) {
-                            return controller.error(new S3Error("Unknown", path, {
-                                message: "Expected partial response to range request.",
-                            }));
-                        }
-                        response.body.on("data", onData);
-                        response.body.once("error", onNetworkError);
-                        response.body.once("end", onClose);
-                        return;
-                    }
-                    if (status === 206) {
-                        if (!expectPartialResponse) {
-                            return controller.error(new S3Error("Unknown", path, {
-                                message: "Received partial response but expected a full response.",
-                            }));
-                        }
-                        response.body.on("data", onData);
-                        response.body.once("error", onNetworkError);
-                        response.body.once("end", onClose);
-                        return;
-                    }
-                    if (400 <= status && status < 500) {
-                        // Some providers actually support JSON via "accept: application/json", but we cant rely on it
-                        const responseText = undefined;
-                        const ct = response.headers["content-type"];
-                        if (response.headers["content-type"] === "application/xml") {
-                            return response.body.text().then(body => {
-                                let error = undefined;
-                                try {
-                                    error = xmlParser.parse(body);
-                                }
-                                catch (cause) {
-                                    return controller.error(new S3Error("Unknown", path, {
-                                        message: "Could not parse XML error response.",
-                                        cause,
-                                    }));
-                                }
-                                return controller.error(new S3Error(error.Code || "Unknown", path, {
-                                    message: error.Message || undefined, // Message might be "",
-                                }));
-                            }, onNetworkError);
-                        }
-                        return controller.error(new S3Error("Unknown", path, {
-                            message: undefined,
-                            cause: responseText,
-                        }));
-                    }
-                    // TODO: Support other status codes
-                    return controller.error(new Error(`Handling for status code ${status} not implemented yet. You might want to open an issue and describe your situation.`));
-                }, onNetworkError);
-            },
-            cancel(reason) {
-                ac.abort(reason);
-            },
-        });
-    }
-    #getAuthorizationHeader(method, path, query, date, sortedSignedHeaders, region, contentHashStr, accessKeyId, secretAccessKey) {
-        const dataDigest = sign.createCanonicalDataDigest(method, path, query, sortedSignedHeaders, contentHashStr);
-        const signingKey = this.#keyCache.computeIfAbsent(date, region, accessKeyId, secretAccessKey);
-        const signature = sign.signCanonicalDataHash(signingKey, dataDigest, date, region);
-        // no encodeURIComponent because because we assume that all headers don't need escaping
-        const signedHeadersSpec = Object.keys(sortedSignedHeaders).join(";");
-        const credentialSpec = `${accessKeyId}/${date.date}/${region}/s3/aws4_request`;
-        return `AWS4-HMAC-SHA256 Credential=${credentialSpec}, SignedHeaders=${signedHeadersSpec}, Signature=${signature}`;
-    }
-}
-export function buildSearchParams(amzCredential, date, expiresIn, headerList, contentHashStr, storageClass, sessionToken, acl) {
-    // We tried to make these query params entirely lower-cased, just like the headers
-    // but Cloudflare R2 requires them to have this exact casing
-    // We didn't have any issues with them being in non-alphaetical order, but as some implementations decide to require sorting
-    // in non-pre-signed cases, we do it here as well
-    // See `benchmark-operations.js` on why we don't use URLSearchParams but string concat
-    let res = "";
-    if (acl) {
-        res += `X-Amz-Acl=${encodeURIComponent(acl)}&`;
-    }
-    res += "X-Amz-Algorithm=AWS4-HMAC-SHA256";
-    if (contentHashStr) {
-        // We assume that this is always hex-encoded, so no encoding needed
-        res += `&X-Amz-Content-Sha256=${contentHashStr}`;
-    }
-    res += `&X-Amz-Credential=${encodeURIComponent(amzCredential)}`;
-    res += `&X-Amz-Date=${date.dateTime}`; // internal dateTimes don't need encoding
-    res += `&X-Amz-Expires=${expiresIn}`; // number -> no encoding
-    if (sessionToken) {
-        res += `&X-Amz-Security-Token=${encodeURIComponent(sessionToken)}`;
-    }
-    res += `&X-Amz-SignedHeaders=${encodeURIComponent(headerList)}`;
-    if (storageClass) {
-        res += `&X-Amz-Storage-Class=${storageClass}`;
-    }
-    return res;
-}
-function ensureValidBucketName(name) {
-    if (name.length < 3 || name.length > 63) {
-        throw new Error("`name` must be between 3 and 63 characters long.");
-    }
-    if (name.startsWith(".") || name.endsWith(".")) {
-        throw new Error("`name` must not start or end with a period (.)");
-    }
-    if (!/^[a-z0-9.-]+$/.test(name)) {
-        throw new Error("`name` can only contain lowercase letters, numbers, periods (.), and hyphens (-).");
-    }
-    if (name.includes("..")) {
-        throw new Error("`name` must not contain two adjacent periods (..)");
-    }
-}

package/dist/S3Error.d.ts

@@ -1,14 +0,0 @@
-export default class S3Error extends Error {
-    readonly code: string;
-    readonly path: string;
-    readonly message: string;
-    readonly requestId: string | undefined;
-    readonly hostId: string | undefined;
-    constructor(code: string, path: string, { message, requestId, hostId, cause }?: S3ErrorOptions);
-}
-export type S3ErrorOptions = {
-    message?: string | undefined;
-    requestId?: string | undefined;
-    hostId?: string | undefined;
-    cause?: unknown;
-};

package/dist/S3Error.js

@@ -1,15 +0,0 @@
-export default class S3Error extends Error {
-    code;
-    path;
-    message;
-    requestId;
-    hostId;
-    constructor(code, path, { message = undefined, requestId = undefined, hostId = undefined, cause = undefined, } = {}) {
-        super(message, { cause });
-        this.code = code;
-        this.path = path;
-        this.message = message ?? "Some unknown error occurred.";
-        this.requestId = requestId;
-        this.hostId = hostId;
-    }
-}