@geekmidas/storage 9.0.2 → 10.0.0-alpha.0

package/dist/errors-D5UnAd-X.mjs

@@ -0,0 +1,79 @@
+//#region src/errors.ts
+/**
+* Storage errors — shared by every implementation, not just S3.
+*
+* A `gs://` or Azure client hits the same three problems as the S3 one: the
+* string is not a URL, it is a URL for a different provider, or it addresses no
+* bucket. Each carries the provider-specific detail as a field, so the type is
+* common while the specifics stay accurate.
+*
+* Messages state the rule, which is constant, and never interpolate the value.
+* An interpolated message cannot be matched on, reads differently every time it
+* is thrown, and carries user input into every log line that touches it.
+*/
+/** Base for anything wrong with a storage URL, so callers may catch broadly. */
+var StorageUrlError = class extends Error {
+	/** The URL that could not be used. */
+	url;
+	constructor(url, message) {
+		super(message);
+		this.url = url;
+		this.name = new.target.name;
+	}
+};
+/** The string is not a URL at all. */
+var MalformedStorageUrl = class extends StorageUrlError {
+	constructor(url) {
+		super(url, "Not a valid URL");
+	}
+};
+/**
+* A URL, but for a different provider — a `gs://` URL reaching the S3 client,
+* or the reverse. The usual cause is a construct resolving against the wrong
+* target, which is worth distinguishing from a malformed string.
+*/
+var UnexpectedStorageScheme = class extends StorageUrlError {
+	/** The scheme this client handles, e.g. `'s3:'`. */
+	expected;
+	/** The scheme the URL actually carried, e.g. `'gs:'`. */
+	actual;
+	constructor(url, expected, actual) {
+		super(url, "Storage URL is for a different provider");
+		this.expected = expected;
+		this.actual = actual;
+	}
+};
+/**
+* A well-formed URL that addresses no bucket.
+*
+* "Bucket" is the term S3 and GCS share; Azure calls the same thing a
+* container. One error covers all three — the word in the message is the
+* common one rather than a new abstraction nobody uses.
+*/
+var MissingStorageBucket = class extends StorageUrlError {
+	constructor(url) {
+		super(url, "Storage URL must address a bucket");
+	}
+};
+/**
+* No driver is registered for the URL's scheme.
+*
+* Usually means the build pinned a driver for a different target, or an entry
+* point registered nothing at all — so the registered schemes are carried
+* alongside, since "what *is* available" is the actionable half.
+*/
+var UnregisteredStorageScheme = class extends StorageUrlError {
+	/** The scheme that had no driver, e.g. `'gs:'`. */
+	scheme;
+	/** What is registered, so the caller can see what was pinned instead. */
+	registered;
+	constructor(url, scheme, registered) {
+		super(url, "No storage driver is registered for this URL scheme");
+		this.scheme = scheme;
+		this.registered = registered;
+	}
+};
+
+//#endregion
+export { MalformedStorageUrl, MissingStorageBucket, StorageUrlError, UnexpectedStorageScheme, UnregisteredStorageScheme };
+//# sourceMappingURL=errors-D5UnAd-X.mjs.map

package/dist/errors-D5UnAd-X.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-D5UnAd-X.mjs","names":["url: string","message: string","expected: string","actual: string","scheme: string","registered: readonly string[]"],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Storage errors — shared by every implementation, not just S3.\n *\n * A `gs://` or Azure client hits the same three problems as the S3 one: the\n * string is not a URL, it is a URL for a different provider, or it addresses no\n * bucket. Each carries the provider-specific detail as a field, so the type is\n * common while the specifics stay accurate.\n *\n * Messages state the rule, which is constant, and never interpolate the value.\n * An interpolated message cannot be matched on, reads differently every time it\n * is thrown, and carries user input into every log line that touches it.\n */\n\n/** Base for anything wrong with a storage URL, so callers may catch broadly. */\nexport abstract class StorageUrlError extends Error {\n\t/** The URL that could not be used. */\n\treadonly url: string;\n\n\tconstructor(url: string, message: string) {\n\t\tsuper(message);\n\t\tthis.url = url;\n\t\tthis.name = new.target.name;\n\t}\n}\n\n/** The string is not a URL at all. */\nexport class MalformedStorageUrl extends StorageUrlError {\n\tconstructor(url: string) {\n\t\tsuper(url, 'Not a valid URL');\n\t}\n}\n\n/**\n * A URL, but for a different provider — a `gs://` URL reaching the S3 client,\n * or the reverse. The usual cause is a construct resolving against the wrong\n * target, which is worth distinguishing from a malformed string.\n */\nexport class UnexpectedStorageScheme extends StorageUrlError {\n\t/** The scheme this client handles, e.g. `'s3:'`. */\n\treadonly expected: string;\n\t/** The scheme the URL actually carried, e.g. `'gs:'`. */\n\treadonly actual: string;\n\n\tconstructor(url: string, expected: string, actual: string) {\n\t\tsuper(url, 'Storage URL is for a different provider');\n\t\tthis.expected = expected;\n\t\tthis.actual = actual;\n\t}\n}\n\n/**\n * A well-formed URL that addresses no bucket.\n *\n * \"Bucket\" is the term S3 and GCS share; Azure calls the same thing a\n * container. One error covers all three — the word in the message is the\n * common one rather than a new abstraction nobody uses.\n */\nexport class MissingStorageBucket extends StorageUrlError {\n\tconstructor(url: string) {\n\t\tsuper(url, 'Storage URL must address a bucket');\n\t}\n}\n\n/**\n * No driver is registered for the URL's scheme.\n *\n * Usually means the build pinned a driver for a different target, or an entry\n * point registered nothing at all — so the registered schemes are carried\n * alongside, since \"what *is* available\" is the actionable half.\n */\nexport class UnregisteredStorageScheme extends StorageUrlError {\n\t/** The scheme that had no driver, e.g. `'gs:'`. */\n\treadonly scheme: string;\n\t/** What is registered, so the caller can see what was pinned instead. */\n\treadonly registered: readonly string[];\n\n\tconstructor(url: string, scheme: string, registered: readonly string[]) {\n\t\tsuper(url, 'No storage driver is registered for this URL scheme');\n\t\tthis.scheme = scheme;\n\t\tthis.registered = registered;\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,IAAsB,kBAAtB,cAA8C,MAAM;;CAEnD,AAAS;CAET,YAAYA,KAAaC,SAAiB;AACzC,QAAM,QAAQ;AACd,OAAK,MAAM;AACX,OAAK,OAAO,IAAI,OAAO;CACvB;AACD;;AAGD,IAAa,sBAAb,cAAyC,gBAAgB;CACxD,YAAYD,KAAa;AACxB,QAAM,KAAK,kBAAkB;CAC7B;AACD;;;;;;AAOD,IAAa,0BAAb,cAA6C,gBAAgB;;CAE5D,AAAS;;CAET,AAAS;CAET,YAAYA,KAAaE,UAAkBC,QAAgB;AAC1D,QAAM,KAAK,0CAA0C;AACrD,OAAK,WAAW;AAChB,OAAK,SAAS;CACd;AACD;;;;;;;;AASD,IAAa,uBAAb,cAA0C,gBAAgB;CACzD,YAAYH,KAAa;AACxB,QAAM,KAAK,oCAAoC;CAC/C;AACD;;;;;;;;AASD,IAAa,4BAAb,cAA+C,gBAAgB;;CAE9D,AAAS;;CAET,AAAS;CAET,YAAYA,KAAaI,QAAgBC,YAA+B;AACvE,QAAM,KAAK,sDAAsD;AACjE,OAAK,SAAS;AACd,OAAK,aAAa;CAClB;AACD"}

package/dist/index.cjs

@@ -0,0 +1,39 @@
+const require_errors = require('./errors-Bce0CJ11.cjs');
+
+//#region src/registry.ts
+const drivers = /* @__PURE__ */ new Map();
+/** Make a driver available to {@link createStorageClient}. Idempotent. */
+function registerStorageDriver(driver) {
+	drivers.set(driver.scheme, driver);
+}
+/** Which schemes are currently registered — the useful half of a failure. */
+function registeredStorageSchemes() {
+	return [...drivers.keys()].sort();
+}
+/**
+* Build a client for a URL.
+*
+* @throws {UnregisteredStorageScheme} when no driver handles the scheme, which
+* in practice means the build pinned a different one, or nothing registered.
+*/
+function createStorageClient(url) {
+	const scheme = schemeOf(url);
+	const driver = drivers.get(scheme);
+	if (!driver) throw new require_errors.UnregisteredStorageScheme(url, scheme, registeredStorageSchemes());
+	return driver.create(url);
+}
+function schemeOf(url) {
+	const separator = url.indexOf(":");
+	return separator === -1 ? "" : url.slice(0, separator + 1);
+}
+
+//#endregion
+exports.MalformedStorageUrl = require_errors.MalformedStorageUrl;
+exports.MissingStorageBucket = require_errors.MissingStorageBucket;
+exports.StorageUrlError = require_errors.StorageUrlError;
+exports.UnexpectedStorageScheme = require_errors.UnexpectedStorageScheme;
+exports.UnregisteredStorageScheme = require_errors.UnregisteredStorageScheme;
+exports.createStorageClient = createStorageClient;
+exports.registerStorageDriver = registerStorageDriver;
+exports.registeredStorageSchemes = registeredStorageSchemes;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["driver: StorageDriver","url: string","UnregisteredStorageScheme"],"sources":["../src/registry.ts"],"sourcesContent":["/**\n * Driver registry — how a storage URL becomes a client without the caller\n * naming a cloud.\n *\n * A construct declares that it needs object storage and receives one URL. It\n * must not import `AmazonStorageClient` to use it: that would name a provider in\n * the neutral layer and drag the AWS SDK into an app that only ever talks to\n * GCS. So the protocol selects the driver, and whoever assembles the\n * application decides which drivers exist — a generated handler registering the\n * one its target needs, or a dev entry registering several.\n *\n * Registration is explicit rather than an import side effect, because a\n * side-effecting module is exactly what a bundler is entitled to drop.\n */\n\nimport { UnregisteredStorageScheme } from './errors';\nimport type { StorageClient } from './StorageClient';\n\n/**\n * Builds a client from a URL it recognises.\n *\n * The driver owns parsing: the shape of an `s3://` URL is S3's business, and a\n * `gs://` driver shares nothing with it beyond this signature.\n */\nexport interface StorageDriver {\n\t/** The URL scheme this driver handles, including the colon — e.g. `'s3:'`. */\n\treadonly scheme: string;\n\tcreate(url: string): StorageClient;\n}\n\nconst drivers = new Map<string, StorageDriver>();\n\n/** Make a driver available to {@link createStorageClient}. Idempotent. */\nexport function registerStorageDriver(driver: StorageDriver): void {\n\tdrivers.set(driver.scheme, driver);\n}\n\n/** Which schemes are currently registered — the useful half of a failure. */\nexport function registeredStorageSchemes(): string[] {\n\treturn [...drivers.keys()].sort();\n}\n\n/**\n * Build a client for a URL.\n *\n * @throws {UnregisteredStorageScheme} when no driver handles the scheme, which\n * in practice means the build pinned a different one, or nothing registered.\n */\nexport function createStorageClient(url: string): StorageClient {\n\tconst scheme = schemeOf(url);\n\tconst driver = drivers.get(scheme);\n\n\tif (!driver) {\n\t\tthrow new UnregisteredStorageScheme(\n\t\t\turl,\n\t\t\tscheme,\n\t\t\tregisteredStorageSchemes(),\n\t\t);\n\t}\n\n\treturn driver.create(url);\n}\n\nfunction schemeOf(url: string): string {\n\tconst separator = url.indexOf(':');\n\treturn separator === -1 ? '' : url.slice(0, separator + 1);\n}\n"],"mappings":";;;AA8BA,MAAM,0BAAU,IAAI;;AAGpB,SAAgB,sBAAsBA,QAA6B;AAClE,SAAQ,IAAI,OAAO,QAAQ,OAAO;AAClC;;AAGD,SAAgB,2BAAqC;AACpD,QAAO,CAAC,GAAG,QAAQ,MAAM,AAAC,EAAC,MAAM;AACjC;;;;;;;AAQD,SAAgB,oBAAoBC,KAA4B;CAC/D,MAAM,SAAS,SAAS,IAAI;CAC5B,MAAM,SAAS,QAAQ,IAAI,OAAO;AAElC,MAAK,OACJ,OAAM,IAAIC,yCACT,KACA,QACA,0BAA0B;AAI5B,QAAO,OAAO,OAAO,IAAI;AACzB;AAED,SAAS,SAASD,KAAqB;CACtC,MAAM,YAAY,IAAI,QAAQ,IAAI;AAClC,QAAO,cAAc,KAAK,KAAK,IAAI,MAAM,GAAG,YAAY,EAAE;AAC1D"}

package/dist/index.d.cts

@@ -1,2 +1,66 @@
-import { StorageClient } from "./StorageClient-COs9SOsU.cjs";
-export { StorageClient };
+import { StorageClient, StorageDriver, createStorageClient, registerStorageDriver, registeredStorageSchemes } from "./registry-DBsAUTT3.cjs";
+
+//#region src/errors.d.ts
+
+/**
+ * Storage errors — shared by every implementation, not just S3.
+ *
+ * A `gs://` or Azure client hits the same three problems as the S3 one: the
+ * string is not a URL, it is a URL for a different provider, or it addresses no
+ * bucket. Each carries the provider-specific detail as a field, so the type is
+ * common while the specifics stay accurate.
+ *
+ * Messages state the rule, which is constant, and never interpolate the value.
+ * An interpolated message cannot be matched on, reads differently every time it
+ * is thrown, and carries user input into every log line that touches it.
+ */
+/** Base for anything wrong with a storage URL, so callers may catch broadly. */
+declare abstract class StorageUrlError extends Error {
+  /** The URL that could not be used. */
+  readonly url: string;
+  constructor(url: string, message: string);
+}
+/** The string is not a URL at all. */
+declare class MalformedStorageUrl extends StorageUrlError {
+  constructor(url: string);
+}
+/**
+ * A URL, but for a different provider — a `gs://` URL reaching the S3 client,
+ * or the reverse. The usual cause is a construct resolving against the wrong
+ * target, which is worth distinguishing from a malformed string.
+ */
+declare class UnexpectedStorageScheme extends StorageUrlError {
+  /** The scheme this client handles, e.g. `'s3:'`. */
+  readonly expected: string;
+  /** The scheme the URL actually carried, e.g. `'gs:'`. */
+  readonly actual: string;
+  constructor(url: string, expected: string, actual: string);
+}
+/**
+ * A well-formed URL that addresses no bucket.
+ *
+ * "Bucket" is the term S3 and GCS share; Azure calls the same thing a
+ * container. One error covers all three — the word in the message is the
+ * common one rather than a new abstraction nobody uses.
+ */
+declare class MissingStorageBucket extends StorageUrlError {
+  constructor(url: string);
+}
+/**
+ * No driver is registered for the URL's scheme.
+ *
+ * Usually means the build pinned a driver for a different target, or an entry
+ * point registered nothing at all — so the registered schemes are carried
+ * alongside, since "what *is* available" is the actionable half.
+ */
+declare class UnregisteredStorageScheme extends StorageUrlError {
+  /** The scheme that had no driver, e.g. `'gs:'`. */
+  readonly scheme: string;
+  /** What is registered, so the caller can see what was pinned instead. */
+  readonly registered: readonly string[];
+  constructor(url: string, scheme: string, registered: readonly string[]);
+}
+//# sourceMappingURL=errors.d.ts.map
+//#endregion
+export { MalformedStorageUrl, MissingStorageBucket, StorageClient, StorageDriver, StorageUrlError, UnexpectedStorageScheme, UnregisteredStorageScheme, createStorageClient, registerStorageDriver, registeredStorageSchemes };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/errors.ts"],"sourcesContent":[],"mappings":";;;;;;;AAcA;AAYA;AAWA;AAoBA;AAaA;;;;;;uBAxDsB,eAAA,SAAwB,KAAK;;;;;;cAYtC,mBAAA,SAA4B,eAAe;;;;;;;;cAW3C,uBAAA,SAAgC,eAAe;;;;;;;;;;;;;;cAoB/C,oBAAA,SAA6B,eAAe;;;;;;;;;;cAa5C,yBAAA,SAAkC,eAAe"}

package/dist/index.d.mts

@@ -1,2 +1,66 @@
-import { StorageClient } from "./StorageClient-DH4tP-Mf.mjs";
-export { StorageClient };
+import { StorageClient, StorageDriver, createStorageClient, registerStorageDriver, registeredStorageSchemes } from "./registry-DEqSHjx-.mjs";
+
+//#region src/errors.d.ts
+
+/**
+ * Storage errors — shared by every implementation, not just S3.
+ *
+ * A `gs://` or Azure client hits the same three problems as the S3 one: the
+ * string is not a URL, it is a URL for a different provider, or it addresses no
+ * bucket. Each carries the provider-specific detail as a field, so the type is
+ * common while the specifics stay accurate.
+ *
+ * Messages state the rule, which is constant, and never interpolate the value.
+ * An interpolated message cannot be matched on, reads differently every time it
+ * is thrown, and carries user input into every log line that touches it.
+ */
+/** Base for anything wrong with a storage URL, so callers may catch broadly. */
+declare abstract class StorageUrlError extends Error {
+  /** The URL that could not be used. */
+  readonly url: string;
+  constructor(url: string, message: string);
+}
+/** The string is not a URL at all. */
+declare class MalformedStorageUrl extends StorageUrlError {
+  constructor(url: string);
+}
+/**
+ * A URL, but for a different provider — a `gs://` URL reaching the S3 client,
+ * or the reverse. The usual cause is a construct resolving against the wrong
+ * target, which is worth distinguishing from a malformed string.
+ */
+declare class UnexpectedStorageScheme extends StorageUrlError {
+  /** The scheme this client handles, e.g. `'s3:'`. */
+  readonly expected: string;
+  /** The scheme the URL actually carried, e.g. `'gs:'`. */
+  readonly actual: string;
+  constructor(url: string, expected: string, actual: string);
+}
+/**
+ * A well-formed URL that addresses no bucket.
+ *
+ * "Bucket" is the term S3 and GCS share; Azure calls the same thing a
+ * container. One error covers all three — the word in the message is the
+ * common one rather than a new abstraction nobody uses.
+ */
+declare class MissingStorageBucket extends StorageUrlError {
+  constructor(url: string);
+}
+/**
+ * No driver is registered for the URL's scheme.
+ *
+ * Usually means the build pinned a driver for a different target, or an entry
+ * point registered nothing at all — so the registered schemes are carried
+ * alongside, since "what *is* available" is the actionable half.
+ */
+declare class UnregisteredStorageScheme extends StorageUrlError {
+  /** The scheme that had no driver, e.g. `'gs:'`. */
+  readonly scheme: string;
+  /** What is registered, so the caller can see what was pinned instead. */
+  readonly registered: readonly string[];
+  constructor(url: string, scheme: string, registered: readonly string[]);
+}
+//# sourceMappingURL=errors.d.ts.map
+//#endregion
+export { MalformedStorageUrl, MissingStorageBucket, StorageClient, StorageDriver, StorageUrlError, UnexpectedStorageScheme, UnregisteredStorageScheme, createStorageClient, registerStorageDriver, registeredStorageSchemes };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/errors.ts"],"sourcesContent":[],"mappings":";;;;;;;AAcA;AAYA;AAWA;AAoBA;AAaA;;;;;;uBAxDsB,eAAA,SAAwB,KAAK;;;;;;cAYtC,mBAAA,SAA4B,eAAe;;;;;;;;cAW3C,uBAAA,SAAgC,eAAe;;;;;;;;;;;;;;cAoB/C,oBAAA,SAA6B,eAAe;;;;;;;;;;cAa5C,yBAAA,SAAkC,eAAe"}

package/dist/index.mjs

@@ -0,0 +1,32 @@
+import { MalformedStorageUrl, MissingStorageBucket, StorageUrlError, UnexpectedStorageScheme, UnregisteredStorageScheme } from "./errors-D5UnAd-X.mjs";
+
+//#region src/registry.ts
+const drivers = /* @__PURE__ */ new Map();
+/** Make a driver available to {@link createStorageClient}. Idempotent. */
+function registerStorageDriver(driver) {
+	drivers.set(driver.scheme, driver);
+}
+/** Which schemes are currently registered — the useful half of a failure. */
+function registeredStorageSchemes() {
+	return [...drivers.keys()].sort();
+}
+/**
+* Build a client for a URL.
+*
+* @throws {UnregisteredStorageScheme} when no driver handles the scheme, which
+* in practice means the build pinned a different one, or nothing registered.
+*/
+function createStorageClient(url) {
+	const scheme = schemeOf(url);
+	const driver = drivers.get(scheme);
+	if (!driver) throw new UnregisteredStorageScheme(url, scheme, registeredStorageSchemes());
+	return driver.create(url);
+}
+function schemeOf(url) {
+	const separator = url.indexOf(":");
+	return separator === -1 ? "" : url.slice(0, separator + 1);
+}
+
+//#endregion
+export { MalformedStorageUrl, MissingStorageBucket, StorageUrlError, UnexpectedStorageScheme, UnregisteredStorageScheme, createStorageClient, registerStorageDriver, registeredStorageSchemes };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["driver: StorageDriver","url: string"],"sources":["../src/registry.ts"],"sourcesContent":["/**\n * Driver registry — how a storage URL becomes a client without the caller\n * naming a cloud.\n *\n * A construct declares that it needs object storage and receives one URL. It\n * must not import `AmazonStorageClient` to use it: that would name a provider in\n * the neutral layer and drag the AWS SDK into an app that only ever talks to\n * GCS. So the protocol selects the driver, and whoever assembles the\n * application decides which drivers exist — a generated handler registering the\n * one its target needs, or a dev entry registering several.\n *\n * Registration is explicit rather than an import side effect, because a\n * side-effecting module is exactly what a bundler is entitled to drop.\n */\n\nimport { UnregisteredStorageScheme } from './errors';\nimport type { StorageClient } from './StorageClient';\n\n/**\n * Builds a client from a URL it recognises.\n *\n * The driver owns parsing: the shape of an `s3://` URL is S3's business, and a\n * `gs://` driver shares nothing with it beyond this signature.\n */\nexport interface StorageDriver {\n\t/** The URL scheme this driver handles, including the colon — e.g. `'s3:'`. */\n\treadonly scheme: string;\n\tcreate(url: string): StorageClient;\n}\n\nconst drivers = new Map<string, StorageDriver>();\n\n/** Make a driver available to {@link createStorageClient}. Idempotent. */\nexport function registerStorageDriver(driver: StorageDriver): void {\n\tdrivers.set(driver.scheme, driver);\n}\n\n/** Which schemes are currently registered — the useful half of a failure. */\nexport function registeredStorageSchemes(): string[] {\n\treturn [...drivers.keys()].sort();\n}\n\n/**\n * Build a client for a URL.\n *\n * @throws {UnregisteredStorageScheme} when no driver handles the scheme, which\n * in practice means the build pinned a different one, or nothing registered.\n */\nexport function createStorageClient(url: string): StorageClient {\n\tconst scheme = schemeOf(url);\n\tconst driver = drivers.get(scheme);\n\n\tif (!driver) {\n\t\tthrow new UnregisteredStorageScheme(\n\t\t\turl,\n\t\t\tscheme,\n\t\t\tregisteredStorageSchemes(),\n\t\t);\n\t}\n\n\treturn driver.create(url);\n}\n\nfunction schemeOf(url: string): string {\n\tconst separator = url.indexOf(':');\n\treturn separator === -1 ? '' : url.slice(0, separator + 1);\n}\n"],"mappings":";;;AA8BA,MAAM,0BAAU,IAAI;;AAGpB,SAAgB,sBAAsBA,QAA6B;AAClE,SAAQ,IAAI,OAAO,QAAQ,OAAO;AAClC;;AAGD,SAAgB,2BAAqC;AACpD,QAAO,CAAC,GAAG,QAAQ,MAAM,AAAC,EAAC,MAAM;AACjC;;;;;;;AAQD,SAAgB,oBAAoBC,KAA4B;CAC/D,MAAM,SAAS,SAAS,IAAI;CAC5B,MAAM,SAAS,QAAQ,IAAI,OAAO;AAElC,MAAK,OACJ,OAAM,IAAI,0BACT,KACA,QACA,0BAA0B;AAI5B,QAAO,OAAO,OAAO,IAAI;AACzB;AAED,SAAS,SAASA,KAAqB;CACtC,MAAM,YAAY,IAAI,QAAQ,IAAI;AAClC,QAAO,cAAc,KAAK,KAAK,IAAI,MAAM,GAAG,YAAY,EAAE;AAC1D"}

package/dist/{StorageClient-COs9SOsU.d.cts → registry-DBsAUTT3.d.cts}

@@ -95,5 +95,30 @@ interface File {
 }
 //# sourceMappingURL=StorageClient.d.ts.map
 //#endregion
-export { DocumentVersion, File, GetUploadParams, GetUploadResponse, StorageClient, StorageProvider, UploadField };
-//# sourceMappingURL=StorageClient-COs9SOsU.d.cts.map
+//#region src/registry.d.ts
+/**
+ * Builds a client from a URL it recognises.
+ *
+ * The driver owns parsing: the shape of an `s3://` URL is S3's business, and a
+ * `gs://` driver shares nothing with it beyond this signature.
+ */
+interface StorageDriver {
+  /** The URL scheme this driver handles, including the colon — e.g. `'s3:'`. */
+  readonly scheme: string;
+  create(url: string): StorageClient;
+}
+/** Make a driver available to {@link createStorageClient}. Idempotent. */
+declare function registerStorageDriver(driver: StorageDriver): void;
+/** Which schemes are currently registered — the useful half of a failure. */
+declare function registeredStorageSchemes(): string[];
+/**
+ * Build a client for a URL.
+ *
+ * @throws {UnregisteredStorageScheme} when no driver handles the scheme, which
+ * in practice means the build pinned a different one, or nothing registered.
+ */
+declare function createStorageClient(url: string): StorageClient;
+//# sourceMappingURL=registry.d.ts.map
+//#endregion
+export { DocumentVersion, File, GetUploadParams, GetUploadResponse, StorageClient, StorageDriver, StorageProvider, createStorageClient, registerStorageDriver, registeredStorageSchemes };
+//# sourceMappingURL=registry-DBsAUTT3.d.cts.map

package/dist/registry-DBsAUTT3.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-DBsAUTT3.d.cts","names":[],"sources":["../src/StorageClient.ts","../src/registry.ts"],"sourcesContent":[],"mappings":";;;UACiB,eAAA;;EAAA,SAAA,EAEL,IAFK;AAKjB;AAMiB,aANL,eAAA;EAMkB,KAAA,GAAA,kCAAA;EAAA,GACV,GAAA,+BAAA;EAAe,KACjB,GAAA,iCAAA;;AAS0C,UAX3C,aAAA,CAW2C;EAAO,SAU7C,QAAA,EApBF,eAoBE;EAAI,SAAuB,KAAA,CAAA,EAnB/B,KAmB+B;EAAO;;;;;;;;EAmC3B,YAAzB,CAAA,MAAA,EA7CkB,eA6ClB,EAAA,SAAA,CAAA,EAAA,MAAA,CAAA,EA7CwD,OA6CxD,CAAA,MAAA,CAAA;EAAO;AAMkB;AAG7B;AAMA;AAKA;AAKA;;;uBA5DsB,2BAA2B;ECThC;AASjB;AAKA;AAUA;;4BDT2B,QAAQ;;;;;;;8BAQN,0BAA0B;;;;;;;qCAStC,8BAEb;;;;;;;oBAQM,sCAEN,QAAQ;;;;;;uBAMU;;UAGL,eAAA;;;;;KAML,WAAA;;;;KAKA,iBAAA;;UAEH;;UAGQ,IAAA;;;;;;;;;;;;;;;;;;;;;;;;AAzBb,UC5Ca,aAAA,CD4Cb;EAAO;EAMkB,SAAA,MAAA,EAAA,MAAA;EAGZ,MAAA,CAAA,GAAA,EAAA,MAAe,CAAA,EClDV,aDkDU;AAMhC;AAKA;AAKiB,iBC5DD,qBAAA,CD4DK,MAAA,EC5DyB,aD4DzB,CAAA,EAAA,IAAA;;iBCvDL,wBAAA,CAAA;;AAdhB;AASA;AAKA;AAUA;;iBAAgB,mBAAA,eAAkC"}

package/dist/{StorageClient-DH4tP-Mf.d.mts → registry-DEqSHjx-.d.mts}

@@ -95,5 +95,30 @@ interface File {
 }
 //# sourceMappingURL=StorageClient.d.ts.map
 //#endregion
-export { DocumentVersion, File, GetUploadParams, GetUploadResponse, StorageClient, StorageProvider, UploadField };
-//# sourceMappingURL=StorageClient-DH4tP-Mf.d.mts.map
+//#region src/registry.d.ts
+/**
+ * Builds a client from a URL it recognises.
+ *
+ * The driver owns parsing: the shape of an `s3://` URL is S3's business, and a
+ * `gs://` driver shares nothing with it beyond this signature.
+ */
+interface StorageDriver {
+  /** The URL scheme this driver handles, including the colon — e.g. `'s3:'`. */
+  readonly scheme: string;
+  create(url: string): StorageClient;
+}
+/** Make a driver available to {@link createStorageClient}. Idempotent. */
+declare function registerStorageDriver(driver: StorageDriver): void;
+/** Which schemes are currently registered — the useful half of a failure. */
+declare function registeredStorageSchemes(): string[];
+/**
+ * Build a client for a URL.
+ *
+ * @throws {UnregisteredStorageScheme} when no driver handles the scheme, which
+ * in practice means the build pinned a different one, or nothing registered.
+ */
+declare function createStorageClient(url: string): StorageClient;
+//# sourceMappingURL=registry.d.ts.map
+//#endregion
+export { DocumentVersion, File, GetUploadParams, GetUploadResponse, StorageClient, StorageDriver, StorageProvider, createStorageClient, registerStorageDriver, registeredStorageSchemes };
+//# sourceMappingURL=registry-DEqSHjx-.d.mts.map

package/dist/registry-DEqSHjx-.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-DEqSHjx-.d.mts","names":[],"sources":["../src/StorageClient.ts","../src/registry.ts"],"sourcesContent":[],"mappings":";;;UACiB,eAAA;;EAAA,SAAA,EAEL,IAFK;AAKjB;AAMiB,aANL,eAAA;EAMkB,KAAA,GAAA,kCAAA;EAAA,GACV,GAAA,+BAAA;EAAe,KACjB,GAAA,iCAAA;;AAS0C,UAX3C,aAAA,CAW2C;EAAO,SAU7C,QAAA,EApBF,eAoBE;EAAI,SAAuB,KAAA,CAAA,EAnB/B,KAmB+B;EAAO;;;;;;;;EAmC3B,YAAzB,CAAA,MAAA,EA7CkB,eA6ClB,EAAA,SAAA,CAAA,EAAA,MAAA,CAAA,EA7CwD,OA6CxD,CAAA,MAAA,CAAA;EAAO;AAMkB;AAG7B;AAMA;AAKA;AAKA;;;uBA5DsB,2BAA2B;ECThC;AASjB;AAKA;AAUA;;4BDT2B,QAAQ;;;;;;;8BAQN,0BAA0B;;;;;;;qCAStC,8BAEb;;;;;;;oBAQM,sCAEN,QAAQ;;;;;;uBAMU;;UAGL,eAAA;;;;;KAML,WAAA;;;;KAKA,iBAAA;;UAEH;;UAGQ,IAAA;;;;;;;;;;;;;;;;;;;;;;;;AAzBb,UC5Ca,aAAA,CD4Cb;EAAO;EAMkB,SAAA,MAAA,EAAA,MAAA;EAGZ,MAAA,CAAA,GAAA,EAAA,MAAe,CAAA,EClDV,aDkDU;AAMhC;AAKA;AAKiB,iBC5DD,qBAAA,CD4DK,MAAA,EC5DyB,aD4DzB,CAAA,EAAA,IAAA;;iBCvDL,wBAAA,CAAA;;AAdhB;AASA;AAKA;AAUA;;iBAAgB,mBAAA,eAAkC"}

package/dist/s3Url-BfztIltX.d.cts

@@ -0,0 +1,39 @@
+declare namespace s3Url_d_exports {
+  export { S3Address, build, parse };
+}
+/**
+ * The `s3://` URL codec — how an S3 bucket is addressed as a single string.
+ *
+ * It lives beside the client rather than in a neutral package because `bucket`,
+ * `region`, and `forcePathStyle` are S3's vocabulary. The neutral layer only
+ * knows that a construct provides *one URL*; what that URL says is between the
+ * component that composes it and the client that parses it. A `gs://` codec
+ * would sit beside its own client and share nothing with this one.
+ *
+ * Both directions live here so they cannot drift: `parse(build(x))` is `x`.
+ */
+/** What an S3 URL addresses. Credentials are deliberately absent — see below. */
+interface S3Address {
+  bucket: string;
+  /** Read off the bucket, never inherited: a bucket may live in another region. */
+  region?: string;
+  /** Set for S3-compatible backends such as MinIO. */
+  endpoint?: string;
+  /** MinIO and most S3-compatible servers need path-style addressing. */
+  forcePathStyle?: boolean;
+}
+/**
+ * Compose an address into a URL.
+ *
+ * Credentials never appear. The AWS SDK resolves them from its own chain — an
+ * execution role when deployed, `AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY`
+ * locally — so the URL stays safe to log and identical across environments that
+ * differ only in who is calling.
+ */
+declare function build(address: S3Address): string;
+/** Parse a URL back into an address. Throws if it is not an `s3://` URL. */
+declare function parse(url: string): S3Address;
+//# sourceMappingURL=s3Url.d.ts.map
+//#endregion
+export { S3Address, build, parse, s3Url_d_exports };
+//# sourceMappingURL=s3Url-BfztIltX.d.cts.map

package/dist/s3Url-BfztIltX.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3Url-BfztIltX.d.cts","names":[],"sources":["../src/s3Url.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;UAmBiB,SAAA;;;;;EAAA,QAAA,CAAA,EAAA,MAAS;EAoBV;EAYA,cAAK,CAAA,EAAA,OAAe;;;;;;;;;;iBAZpB,KAAA,UAAe;;iBAYf,KAAA,eAAoB"}

package/dist/s3Url-Bo32UTTA.cjs

@@ -0,0 +1,103 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_errors = require('./errors-Bce0CJ11.cjs');
+
+//#region src/s3Url.ts
+var s3Url_exports = {};
+__export(s3Url_exports, {
+	build: () => build,
+	parse: () => parse
+});
+const SCHEME = "s3:";
+/**
+* Compose an address into a URL.
+*
+* Credentials never appear. The AWS SDK resolves them from its own chain — an
+* execution role when deployed, `AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY`
+* locally — so the URL stays safe to log and identical across environments that
+* differ only in who is calling.
+*/
+function build(address) {
+	const { bucket, region, endpoint, forcePathStyle } = address;
+	if (!bucket) throw new require_errors.MissingStorageBucket("");
+	const url = new URL(`${SCHEME}//${bucket}`);
+	if (region) url.searchParams.set("region", region);
+	if (endpoint) url.searchParams.set("endpoint", endpoint);
+	if (forcePathStyle) url.searchParams.set("forcePathStyle", "true");
+	return url.toString();
+}
+/** Parse a URL back into an address. Throws if it is not an `s3://` URL. */
+function parse(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new require_errors.MalformedStorageUrl(url);
+	}
+	if (parsed.protocol !== SCHEME) throw new require_errors.UnexpectedStorageScheme(url, SCHEME, parsed.protocol);
+	const bucket = parsed.hostname;
+	if (!bucket) throw new require_errors.MissingStorageBucket(url);
+	const region = parsed.searchParams.get("region") ?? void 0;
+	const endpoint = parsed.searchParams.get("endpoint") ?? void 0;
+	const forcePathStyle = parsed.searchParams.get("forcePathStyle") === "true" ? true : void 0;
+	return {
+		bucket,
+		...region ? { region } : {},
+		...endpoint ? { endpoint } : {},
+		...forcePathStyle ? { forcePathStyle } : {}
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'build', {
+  enumerable: true,
+  get: function () {
+    return build;
+  }
+});
+Object.defineProperty(exports, 'parse', {
+  enumerable: true,
+  get: function () {
+    return parse;
+  }
+});
+Object.defineProperty(exports, 's3Url_exports', {
+  enumerable: true,
+  get: function () {
+    return s3Url_exports;
+  }
+});
+//# sourceMappingURL=s3Url-Bo32UTTA.cjs.map

package/dist/s3Url-Bo32UTTA.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3Url-Bo32UTTA.cjs","names":["address: S3Address","MissingStorageBucket","url: string","parsed: URL","MalformedStorageUrl","UnexpectedStorageScheme"],"sources":["../src/s3Url.ts"],"sourcesContent":["/**\n * The `s3://` URL codec — how an S3 bucket is addressed as a single string.\n *\n * It lives beside the client rather than in a neutral package because `bucket`,\n * `region`, and `forcePathStyle` are S3's vocabulary. The neutral layer only\n * knows that a construct provides *one URL*; what that URL says is between the\n * component that composes it and the client that parses it. A `gs://` codec\n * would sit beside its own client and share nothing with this one.\n *\n * Both directions live here so they cannot drift: `parse(build(x))` is `x`.\n */\n\nimport {\n\tMalformedStorageUrl,\n\tMissingStorageBucket,\n\tUnexpectedStorageScheme,\n} from './errors';\n\n/** What an S3 URL addresses. Credentials are deliberately absent — see below. */\nexport interface S3Address {\n\tbucket: string;\n\t/** Read off the bucket, never inherited: a bucket may live in another region. */\n\tregion?: string;\n\t/** Set for S3-compatible backends such as MinIO. */\n\tendpoint?: string;\n\t/** MinIO and most S3-compatible servers need path-style addressing. */\n\tforcePathStyle?: boolean;\n}\n\nconst SCHEME = 's3:';\n\n/**\n * Compose an address into a URL.\n *\n * Credentials never appear. The AWS SDK resolves them from its own chain — an\n * execution role when deployed, `AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY`\n * locally — so the URL stays safe to log and identical across environments that\n * differ only in who is calling.\n */\nexport function build(address: S3Address): string {\n\tconst { bucket, region, endpoint, forcePathStyle } = address;\n\tif (!bucket) throw new MissingStorageBucket('');\n\n\tconst url = new URL(`${SCHEME}//${bucket}`);\n\tif (region) url.searchParams.set('region', region);\n\tif (endpoint) url.searchParams.set('endpoint', endpoint);\n\tif (forcePathStyle) url.searchParams.set('forcePathStyle', 'true');\n\treturn url.toString();\n}\n\n/** Parse a URL back into an address. Throws if it is not an `s3://` URL. */\nexport function parse(url: string): S3Address {\n\tlet parsed: URL;\n\ttry {\n\t\tparsed = new URL(url);\n\t} catch {\n\t\tthrow new MalformedStorageUrl(url);\n\t}\n\n\tif (parsed.protocol !== SCHEME) {\n\t\tthrow new UnexpectedStorageScheme(url, SCHEME, parsed.protocol);\n\t}\n\n\tconst bucket = parsed.hostname;\n\tif (!bucket) throw new MissingStorageBucket(url);\n\n\tconst region = parsed.searchParams.get('region') ?? undefined;\n\tconst endpoint = parsed.searchParams.get('endpoint') ?? undefined;\n\tconst forcePathStyle =\n\t\tparsed.searchParams.get('forcePathStyle') === 'true' ? true : undefined;\n\n\treturn {\n\t\tbucket,\n\t\t...(region ? { region } : {}),\n\t\t...(endpoint ? { endpoint } : {}),\n\t\t...(forcePathStyle ? { forcePathStyle } : {}),\n\t};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAM,SAAS;;;;;;;;;AAUf,SAAgB,MAAMA,SAA4B;CACjD,MAAM,EAAE,QAAQ,QAAQ,UAAU,gBAAgB,GAAG;AACrD,MAAK,OAAQ,OAAM,IAAIC,oCAAqB;CAE5C,MAAM,MAAM,IAAI,KAAK,EAAE,OAAO,IAAI,OAAO;AACzC,KAAI,OAAQ,KAAI,aAAa,IAAI,UAAU,OAAO;AAClD,KAAI,SAAU,KAAI,aAAa,IAAI,YAAY,SAAS;AACxD,KAAI,eAAgB,KAAI,aAAa,IAAI,kBAAkB,OAAO;AAClE,QAAO,IAAI,UAAU;AACrB;;AAGD,SAAgB,MAAMC,KAAwB;CAC7C,IAAIC;AACJ,KAAI;AACH,WAAS,IAAI,IAAI;CACjB,QAAO;AACP,QAAM,IAAIC,mCAAoB;CAC9B;AAED,KAAI,OAAO,aAAa,OACvB,OAAM,IAAIC,uCAAwB,KAAK,QAAQ,OAAO;CAGvD,MAAM,SAAS,OAAO;AACtB,MAAK,OAAQ,OAAM,IAAIJ,oCAAqB;CAE5C,MAAM,SAAS,OAAO,aAAa,IAAI,SAAS;CAChD,MAAM,WAAW,OAAO,aAAa,IAAI,WAAW;CACpD,MAAM,iBACL,OAAO,aAAa,IAAI,iBAAiB,KAAK,SAAS;AAExD,QAAO;EACN;EACA,GAAI,SAAS,EAAE,OAAQ,IAAG,CAAE;EAC5B,GAAI,WAAW,EAAE,SAAU,IAAG,CAAE;EAChC,GAAI,iBAAiB,EAAE,eAAgB,IAAG,CAAE;CAC5C;AACD"}

package/dist/s3Url-C8FGPNrG.mjs

@@ -0,0 +1,52 @@
+import { __export } from "./chunk-B9dir_RE.mjs";
+import { MalformedStorageUrl, MissingStorageBucket, UnexpectedStorageScheme } from "./errors-D5UnAd-X.mjs";
+
+//#region src/s3Url.ts
+var s3Url_exports = {};
+__export(s3Url_exports, {
+	build: () => build,
+	parse: () => parse
+});
+const SCHEME = "s3:";
+/**
+* Compose an address into a URL.
+*
+* Credentials never appear. The AWS SDK resolves them from its own chain — an
+* execution role when deployed, `AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY`
+* locally — so the URL stays safe to log and identical across environments that
+* differ only in who is calling.
+*/
+function build(address) {
+	const { bucket, region, endpoint, forcePathStyle } = address;
+	if (!bucket) throw new MissingStorageBucket("");
+	const url = new URL(`${SCHEME}//${bucket}`);
+	if (region) url.searchParams.set("region", region);
+	if (endpoint) url.searchParams.set("endpoint", endpoint);
+	if (forcePathStyle) url.searchParams.set("forcePathStyle", "true");
+	return url.toString();
+}
+/** Parse a URL back into an address. Throws if it is not an `s3://` URL. */
+function parse(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new MalformedStorageUrl(url);
+	}
+	if (parsed.protocol !== SCHEME) throw new UnexpectedStorageScheme(url, SCHEME, parsed.protocol);
+	const bucket = parsed.hostname;
+	if (!bucket) throw new MissingStorageBucket(url);
+	const region = parsed.searchParams.get("region") ?? void 0;
+	const endpoint = parsed.searchParams.get("endpoint") ?? void 0;
+	const forcePathStyle = parsed.searchParams.get("forcePathStyle") === "true" ? true : void 0;
+	return {
+		bucket,
+		...region ? { region } : {},
+		...endpoint ? { endpoint } : {},
+		...forcePathStyle ? { forcePathStyle } : {}
+	};
+}
+
+//#endregion
+export { build, parse, s3Url_exports };
+//# sourceMappingURL=s3Url-C8FGPNrG.mjs.map

package/dist/s3Url-C8FGPNrG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3Url-C8FGPNrG.mjs","names":["address: S3Address","url: string","parsed: URL"],"sources":["../src/s3Url.ts"],"sourcesContent":["/**\n * The `s3://` URL codec — how an S3 bucket is addressed as a single string.\n *\n * It lives beside the client rather than in a neutral package because `bucket`,\n * `region`, and `forcePathStyle` are S3's vocabulary. The neutral layer only\n * knows that a construct provides *one URL*; what that URL says is between the\n * component that composes it and the client that parses it. A `gs://` codec\n * would sit beside its own client and share nothing with this one.\n *\n * Both directions live here so they cannot drift: `parse(build(x))` is `x`.\n */\n\nimport {\n\tMalformedStorageUrl,\n\tMissingStorageBucket,\n\tUnexpectedStorageScheme,\n} from './errors';\n\n/** What an S3 URL addresses. Credentials are deliberately absent — see below. */\nexport interface S3Address {\n\tbucket: string;\n\t/** Read off the bucket, never inherited: a bucket may live in another region. */\n\tregion?: string;\n\t/** Set for S3-compatible backends such as MinIO. */\n\tendpoint?: string;\n\t/** MinIO and most S3-compatible servers need path-style addressing. */\n\tforcePathStyle?: boolean;\n}\n\nconst SCHEME = 's3:';\n\n/**\n * Compose an address into a URL.\n *\n * Credentials never appear. The AWS SDK resolves them from its own chain — an\n * execution role when deployed, `AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY`\n * locally — so the URL stays safe to log and identical across environments that\n * differ only in who is calling.\n */\nexport function build(address: S3Address): string {\n\tconst { bucket, region, endpoint, forcePathStyle } = address;\n\tif (!bucket) throw new MissingStorageBucket('');\n\n\tconst url = new URL(`${SCHEME}//${bucket}`);\n\tif (region) url.searchParams.set('region', region);\n\tif (endpoint) url.searchParams.set('endpoint', endpoint);\n\tif (forcePathStyle) url.searchParams.set('forcePathStyle', 'true');\n\treturn url.toString();\n}\n\n/** Parse a URL back into an address. Throws if it is not an `s3://` URL. */\nexport function parse(url: string): S3Address {\n\tlet parsed: URL;\n\ttry {\n\t\tparsed = new URL(url);\n\t} catch {\n\t\tthrow new MalformedStorageUrl(url);\n\t}\n\n\tif (parsed.protocol !== SCHEME) {\n\t\tthrow new UnexpectedStorageScheme(url, SCHEME, parsed.protocol);\n\t}\n\n\tconst bucket = parsed.hostname;\n\tif (!bucket) throw new MissingStorageBucket(url);\n\n\tconst region = parsed.searchParams.get('region') ?? undefined;\n\tconst endpoint = parsed.searchParams.get('endpoint') ?? undefined;\n\tconst forcePathStyle =\n\t\tparsed.searchParams.get('forcePathStyle') === 'true' ? true : undefined;\n\n\treturn {\n\t\tbucket,\n\t\t...(region ? { region } : {}),\n\t\t...(endpoint ? { endpoint } : {}),\n\t\t...(forcePathStyle ? { forcePathStyle } : {}),\n\t};\n}\n"],"mappings":";;;;;;;;;AA6BA,MAAM,SAAS;;;;;;;;;AAUf,SAAgB,MAAMA,SAA4B;CACjD,MAAM,EAAE,QAAQ,QAAQ,UAAU,gBAAgB,GAAG;AACrD,MAAK,OAAQ,OAAM,IAAI,qBAAqB;CAE5C,MAAM,MAAM,IAAI,KAAK,EAAE,OAAO,IAAI,OAAO;AACzC,KAAI,OAAQ,KAAI,aAAa,IAAI,UAAU,OAAO;AAClD,KAAI,SAAU,KAAI,aAAa,IAAI,YAAY,SAAS;AACxD,KAAI,eAAgB,KAAI,aAAa,IAAI,kBAAkB,OAAO;AAClE,QAAO,IAAI,UAAU;AACrB;;AAGD,SAAgB,MAAMC,KAAwB;CAC7C,IAAIC;AACJ,KAAI;AACH,WAAS,IAAI,IAAI;CACjB,QAAO;AACP,QAAM,IAAI,oBAAoB;CAC9B;AAED,KAAI,OAAO,aAAa,OACvB,OAAM,IAAI,wBAAwB,KAAK,QAAQ,OAAO;CAGvD,MAAM,SAAS,OAAO;AACtB,MAAK,OAAQ,OAAM,IAAI,qBAAqB;CAE5C,MAAM,SAAS,OAAO,aAAa,IAAI,SAAS;CAChD,MAAM,WAAW,OAAO,aAAa,IAAI,WAAW;CACpD,MAAM,iBACL,OAAO,aAAa,IAAI,iBAAiB,KAAK,SAAS;AAExD,QAAO;EACN;EACA,GAAI,SAAS,EAAE,OAAQ,IAAG,CAAE;EAC5B,GAAI,WAAW,EAAE,SAAU,IAAG,CAAE;EAChC,GAAI,iBAAiB,EAAE,eAAgB,IAAG,CAAE;CAC5C;AACD"}