@bessemer/cornerstone 0.5.97 → 0.5.99

package/dist/net/uri.d.ts

@@ -0,0 +1,249 @@
+import { NominalType, TaggedType } from '@bessemer/cornerstone/types';
+import * as ResourceKeys from '@bessemer/cornerstone/resource-key';
+import { Result } from '@bessemer/cornerstone/result';
+import { ErrorEvent } from '@bessemer/cornerstone/error/error-event';
+import Zod from 'zod';
+import { ValueOf } from 'type-fest';
+import { Equalitor } from '@bessemer/cornerstone/equalitor';
+import { UriHostName } from '@bessemer/cornerstone/net/uri-host-name';
+export type UriString = TaggedType<string, 'UriString'>;
+export type UriComponent = string;
+export type UriScheme = string;
+export type UriAuthentication = {
+    principal: string;
+    password: string | null;
+};
+export type UriHost = {
+    value: UriHostName;
+    port: number | null;
+};
+export interface UriLocation {
+    path: string | null;
+    query: string | null;
+    fragment: string | null;
+}
+export declare const Namespace: ResourceKeys.ResourceNamespace<"uri">;
+export declare const UrlNamespace: ResourceKeys.ResourceNamespace<"url">;
+export declare const EqualBy: Equalitor<Uri>;
+export type UriLiteral = NominalType<string, typeof Namespace>;
+export interface UriStructure {
+    _type: typeof Namespace | typeof UrlNamespace;
+    scheme: UriScheme | null;
+    host: UriHost | null;
+    authentication: UriAuthentication | null;
+    location: UriLocation;
+}
+export interface Uri extends UriStructure {
+    href: UriLiteral;
+}
+type UriBuilderAuthentication = {
+    principal: string;
+    password?: string | null;
+} | string;
+type UriBuilderHost = {
+    value: string;
+    port?: number | null;
+} | string;
+type UriBuilderLocation = {
+    path?: string | null;
+    query?: string | null;
+    fragment?: string | null;
+} | string;
+export type UriBuilder = {
+    scheme?: string | null | undefined;
+    authentication?: UriBuilderAuthentication | null | undefined;
+    host?: UriBuilderHost | null | undefined;
+    location?: UriBuilderLocation | null | undefined;
+};
+export type UriLike = Uri | UriLiteral | UriBuilder;
+/**
+ * Parses a string into a Uri object, handling all URI components including scheme,
+ * authority (host and authentication), and location (path, query, fragment).
+ * Returns a Result containing either the parsed Uri or an ErrorEvent on failure.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Uris } from "@bessemer/cornerstone"
+ *
+ * // Parse a complete HTTPS URI
+ * const result = Uris.parseString('https://user:pass@example.com:8080/api/v1?q=test#section')
+ * if (result.isSuccess) {
+ *   console.log(result.value.scheme) // 'https'
+ *   console.log(result.value.host?.value) // 'example.com'
+ *   console.log(result.value.authentication?.principal) // 'user'
+ * }
+ *
+ * // Parse a simple URI without authority
+ * const urnResult = Uris.parseString('urn:isbn:0451450523')
+ * if (urnResult.isSuccess) {
+ *   console.log(urnResult.value.scheme) // 'urn'
+ *   console.log(urnResult.value.location.path) // 'isbn:0451450523'
+ * }
+ * ```
+ *
+ * @category parsing
+ */
+export declare const parseString: (value: string) => Result<Uri, ErrorEvent>;
+/**
+ * Converts various URI-like inputs into a Uri object. Handles Uri instances,
+ * string literals, and builder objects, returning them as-is when already a Uri
+ * or converting them appropriately.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Uris } from "@bessemer/cornerstone"
+ *
+ * // String literal parsed into Uri
+ * const fromString = Uris.from('https://api.example.com/v1')
+ * console.log(fromString.scheme) // 'https'
+ * console.log(fromString.host?.value) // 'api.example.com'
+ *
+ * // Builder object converted to Uri
+ * const fromBuilder = Uris.from({
+ *   scheme: 'https',
+ *   host: { value: 'example.com', port: 8080 },
+ *   location: { path: '/api' }
+ * })
+ * console.log(fromBuilder.host?.port) // 8080
+ *
+ * @category conversion
+ */
+export declare function from(value: UriLike | string): Uri;
+export declare function from(value: UriLike | string | null): Uri | null;
+export declare function from(value: UriLike | string | undefined): Uri | undefined;
+export declare function from(value: UriLike | string | null | undefined): Uri | null | undefined;
+/**
+ * Converts various URI-like inputs into a normalized string literal representation.
+ * Takes any URI-like value and returns its canonical string form
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Uris } from "@bessemer/cornerstone"
+ *
+ * // Convert Uri instance to string literal
+ * const uri = Uris.build({ scheme: 'https', host: 'example.com', location: { path: '/api' } })
+ * const literal = Uris.toLiteral(uri)
+ * console.log(literal) // "https://example.com/api"
+ *
+ * // Convert builder object to string literal
+ * const fromBuilder = Uris.toLiteral({
+ *   scheme: 'https',
+ *   host: { value: 'api.example.com', port: 8080 },
+ *   authentication: { principal: 'user', password: 'pass' },
+ *   location: { path: '/v1', parameters: { q: 'search' } }
+ * })
+ * console.log(fromBuilder) // "https://user:pass@api.example.com:8080/v1?q=search"
+ * ```
+ *
+ * @category serialization
+ */
+export declare function toLiteral(likeValue: UriLike): UriLiteral;
+export declare function toLiteral(likeValue: UriLike | null): UriLiteral | null;
+export declare function toLiteral(likeValue: UriLike | undefined): UriLiteral | undefined;
+export declare function toLiteral(likeValue: UriLike | null | undefined): UriLiteral | null | undefined;
+export declare const SchemaLiteral: Zod.ZodPipe<Zod.ZodString, Zod.ZodTransform<UriLiteral, string>>;
+/**
+ * Tests if the provided value is a Uri.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Uris } from "@bessemer/cornerstone"
+ *
+ * // Check if unknown value is a Uri
+ * function processValue(value: unknown) {
+ *   if (Uris.isUri(value)) {
+ *     console.log(value.scheme) // Type-safe access
+ *     console.log(value.location.path)
+ *   }
+ * }
+ * ```
+ *
+ * @category type-guards
+ */
+export declare const isUri: (value: unknown) => value is Uri;
+/**
+ * Merges an existing URI with partial changes to create a new URI instance.
+ * Allows selective updates without replacing the entire URI.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Uris } from "@bessemer/cornerstone"
+ *
+ * // Start with a base URI
+ * const baseUri = Uris.build({
+ *   scheme: 'https',
+ *   host: { value: 'api.example.com', port: 443 },
+ *   authentication: { principal: 'user', password: 'pass' },
+ *   location: { path: '/v1', parameters: { format: 'json' } }
+ * })
+ *
+ * // Change just the host and add query parameter
+ * const updatedUri = Uris.merge(baseUri, {
+ *   host: { value: 'api.production.com' }, // Port preserved from original
+ *   location: {
+ *     parameters: { version: '2.0' } // Merges with existing parameters
+ *   }
+ * })
+ *
+ * console.log(updatedUri.host?.value) // 'api.production.com'
+ * console.log(updatedUri.host?.port) // 443 (preserved)
+ * console.log(updatedUri.location.parameters) // { format: 'json', version: '2.0' }
+ * ```
+ *
+ * @category transformation
+ */
+export declare const merge: (element: UriLike, builder: UriBuilder) => Uri;
+export declare const UriComponentType: {
+    readonly Scheme: "Scheme";
+    readonly Authentication: "Authentication";
+    readonly Host: "Host";
+    readonly Location: "Location";
+    readonly Path: "Path";
+    readonly Query: "Query";
+    readonly Fragment: "Fragment";
+};
+export type UriComponentType = ValueOf<typeof UriComponentType>;
+/**
+ * Converts a URI object into its string representation, with optional exclusion of specific URI components.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Uris, UriComponentType } from "@bessemer/cornerstone"
+ *
+ * const uri = Uris.build({
+ *   scheme: 'https',
+ *   authentication: { principal: 'user', password: 'secret' },
+ *   host: { value: 'api.example.com', port: 8080 },
+ *   location: { path: '/v1/data', parameters: { format: 'json' }, fragment: 'results' }
+ * })
+ *
+ * // Format complete URI
+ * const fullUri = Uris.format(uri)
+ * console.log(fullUri) // "https://user:secret@api.example.com:8080/v1/data?format=json#results"
+ *
+ * // Exclude authentication for public sharing
+ * const publicUri = Uris.format(uri, [UriComponentType.Authentication])
+ * console.log(publicUri) // "https://api.example.com:8080/v1/data?format=json#results"
+ *
+ * // Format path-only URI
+ * const pathOnly = Uris.format(uri, [
+ *   UriComponentType.Scheme,
+ *   UriComponentType.Host,
+ *   UriComponentType.Authentication
+ * ])
+ * console.log(pathOnly) // "/v1/data?format=json#results"
+ * ```
+ *
+ * @category serialization
+ */
+export declare const format: (uriLike: UriLike, excludedUriComponents?: Array<UriComponentType>) => UriLiteral;
+export declare const encode: (uriComponent: UriComponent) => string;
+export declare const decode: (uriComponent: UriComponent) => string;
+export {};
+//# sourceMappingURL=uri.d.ts.map

package/dist/net/uri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uri.d.ts","sourceRoot":"","sources":["../../src/net/uri.ts"],"names":[],"mappings":"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"}

package/dist/net/uri.js

@@ -0,0 +1,444 @@
+// src/net/uri.ts
+import * as Strings from "@bessemer/cornerstone/string";
+import * as Objects from "@bessemer/cornerstone/object";
+import * as Arrays from "@bessemer/cornerstone/array";
+import * as ResourceKeys from "@bessemer/cornerstone/resource-key";
+import * as Results from "@bessemer/cornerstone/result";
+import { success as success2 } from "@bessemer/cornerstone/result";
+import * as ErrorEvents from "@bessemer/cornerstone/error/error-event";
+import { structuredTransform } from "@bessemer/cornerstone/zod-util";
+import Zod from "zod";
+import * as IpV6Addresses from "@bessemer/cornerstone/net/ipv6-address";
+import * as Equalitors from "@bessemer/cornerstone/equalitor";
+import * as UriHostNames from "@bessemer/cornerstone/net/uri-host-name";
+var Namespace = ResourceKeys.createNamespace("uri");
+var UrlNamespace = ResourceKeys.createNamespace("url");
+var EqualBy = Equalitors.deepNatural();
+var parseString3 = (value) => {
+  if (Strings.isBlank(value)) {
+    return Results.failure(
+      ErrorEvents.required({
+        namespace: Namespace,
+        message: `[${Namespace}]: Unable to parse Uri from empty string.`
+      })
+    );
+  }
+  const schemeResult = parseSchemePart(value);
+  if (!schemeResult.isSuccess) {
+    return Results.failure(
+      ErrorEvents.invalidValue(value, {
+        namespace: Namespace,
+        message: `[${Namespace}]: Unable to parse Uri from uri string: [${value}]`,
+        causes: schemeResult.value.causes
+      })
+    );
+  }
+  const [scheme, rest1] = schemeResult.value;
+  const authorityPartResult = parseAuthorityPart(rest1);
+  if (!authorityPartResult.isSuccess) {
+    return Results.failure(
+      ErrorEvents.invalidValue(value, {
+        namespace: Namespace,
+        message: `[${Namespace}]: Unable to parse Uri from uri string: [${value}]`,
+        causes: authorityPartResult.value.causes
+      })
+    );
+  }
+  const [authority, rest2] = authorityPartResult.value;
+  const location = parseLocation(rest2);
+  const structure = {
+    _type: Namespace,
+    scheme,
+    host: authority.host,
+    authentication: authority.authentication,
+    location
+  };
+  return Results.success({
+    ...structure,
+    href: formatInternal(structure)
+  });
+};
+function from2(value) {
+  if (Objects.isNil(value)) {
+    return value;
+  }
+  if (isUri(value)) {
+    return value;
+  }
+  if (Strings.isString(value)) {
+    return ErrorEvents.unpackResult(parseString3(value));
+  }
+  return build(value);
+}
+function toLiteral(likeValue) {
+  if (Objects.isNil(likeValue)) {
+    return likeValue;
+  }
+  const value = from2(likeValue);
+  return format(value);
+}
+var SchemaLiteral = structuredTransform(Zod.string(), (it) => Results.mapResult(parseString3(it), (it2) => toLiteral(it2)));
+var isUri = (value) => {
+  if (!Objects.isObject(value)) {
+    return false;
+  }
+  const uriValue = value;
+  return uriValue._type === Namespace || uriValue._type === UrlNamespace;
+};
+var merge = (element, builder) => {
+  const uri = from2(element);
+  let location;
+  if (Strings.isString(builder.location) || Objects.isNull(builder.location)) {
+    location = builder.location;
+  } else {
+    location = { ...uri.location, ...builder.location ?? {} };
+  }
+  const uriBuilder = {
+    scheme: Objects.isUndefined(builder.scheme) ? uri.scheme : builder.scheme,
+    host: Objects.isUndefined(builder.host) ? uri.host : builder.host,
+    authentication: Objects.isUndefined(builder.authentication) ? uri.authentication : builder.authentication,
+    location
+  };
+  return from2(uriBuilder);
+};
+var parseSchemePart = (url) => {
+  const schemeMatch = Strings.splitFirst(url, /(\/\/|:)/);
+  if (Objects.isNil(schemeMatch.selection) || schemeMatch.separator === "//") {
+    return Results.success([null, url]);
+  }
+  if (Strings.isEmpty(schemeMatch.selection)) {
+    return Results.success([null, ":" + schemeMatch.rest]);
+  } else {
+    const schemeResult = parseScheme(schemeMatch.selection);
+    if (!schemeResult.isSuccess) {
+      return schemeResult;
+    }
+    return Results.success([schemeResult.value, schemeMatch.rest]);
+  }
+};
+var parseScheme = (scheme) => {
+  const schemeRegex = /^[a-zA-Z][a-zA-Z0-9+.-]*$/;
+  if (!schemeRegex.test(scheme)) {
+    return Results.failure(
+      ErrorEvents.invalidValue(scheme, {
+        namespace: Namespace,
+        message: `[${Namespace}]: Invalid characters in Scheme.`
+      })
+    );
+  }
+  return Results.success(scheme);
+};
+var parseAuthorityPart = (initialUrl) => {
+  if (!initialUrl.startsWith("//")) {
+    return success2([{ host: null, authentication: null }, initialUrl]);
+  }
+  const url = Strings.removeStart(initialUrl, "//");
+  const authenticationPartResult = parseAuthenticationPart(url);
+  if (!authenticationPartResult.isSuccess) {
+    return authenticationPartResult;
+  }
+  const [authentication, rest1] = authenticationPartResult.value;
+  const hostPartResult = parseHostPart(rest1);
+  if (!hostPartResult.isSuccess) {
+    return hostPartResult;
+  }
+  const [host, rest2] = hostPartResult.value;
+  return success2([{ host, authentication }, rest2]);
+};
+var parseAuthenticationPart = (url) => {
+  let targetPart = url;
+  const queryMatch = Strings.splitFirst(targetPart, "?");
+  const fragmentMatch = Strings.splitFirst(targetPart, "#");
+  if (Objects.isPresent(queryMatch.selection)) {
+    targetPart = queryMatch.selection;
+  } else if (Objects.isPresent(fragmentMatch.selection)) {
+    targetPart = fragmentMatch.selection;
+  }
+  const { selection: authentication } = Strings.splitFirst(targetPart, "@");
+  if (Objects.isNil(authentication)) {
+    return Results.success([null, url]);
+  }
+  const { rest } = Strings.splitFirst(url, "@");
+  const authenticationParseResult = parseAuthentication(authentication);
+  if (!authenticationParseResult.isSuccess) {
+    return authenticationParseResult;
+  }
+  return Results.success([authenticationParseResult.value, rest]);
+};
+var parseAuthentication = (authentication) => {
+  const { selection: principal, rest: authenticationRest } = Strings.splitFirst(authentication, ":");
+  if (Objects.isNil(principal)) {
+    if (!isAuthenticationComponentValid(authenticationRest)) {
+      return Results.failure(
+        ErrorEvents.invalidValue(authenticationRest, {
+          namespace: Namespace,
+          message: `[${Namespace}]: Invalid characters for UriAuthentication in principal string: [${authenticationRest}]`
+        })
+      );
+    }
+    return Results.success({ principal: decode(authenticationRest), password: null });
+  }
+  if (Strings.isEmpty(principal)) {
+    return Results.failure(
+      ErrorEvents.invalidValue(authentication, {
+        namespace: Namespace,
+        message: `[${Namespace}]: Unable to parse UriAuthentication from authentication string: [${authentication}]`
+      })
+    );
+  }
+  if (!isAuthenticationComponentValid(principal)) {
+    return Results.failure(
+      ErrorEvents.invalidValue(principal, {
+        namespace: Namespace,
+        message: `[${Namespace}]: Invalid characters for UriAuthentication in principal string: [${principal}]`
+      })
+    );
+  }
+  if (!isAuthenticationComponentValid(authenticationRest)) {
+    return Results.failure(
+      ErrorEvents.invalidValue(authenticationRest, {
+        namespace: Namespace,
+        message: `[${Namespace}]: Invalid characters for UriAuthentication in password string: [${authenticationRest}]`
+      })
+    );
+  }
+  return Results.success({ principal: decode(principal), password: decode(authenticationRest) });
+};
+var isAuthenticationComponentValid = (component) => {
+  const userinfoRegex = /^[A-Za-z0-9\-._~!$&'()*+,;=%]*$/;
+  if (component.includes("%")) {
+    const percentEncodingRegex = /%[0-9A-Fa-f]{2}/g;
+    const percentMatches = component.match(/%/g) || [];
+    const validEncodingMatches = component.match(percentEncodingRegex) || [];
+    if (percentMatches.length !== validEncodingMatches.length) {
+      return false;
+    }
+  }
+  return userinfoRegex.test(component);
+};
+var parseHostPart = (url) => {
+  if (url.startsWith("?") || url.startsWith("#")) {
+    return Results.success([null, url]);
+  }
+  const urlMatch = Strings.splitFirst(url, /[\/?#]/);
+  let host = urlMatch.rest;
+  let rest = "";
+  if (Objects.isPresent(urlMatch.selection)) {
+    host = urlMatch.selection;
+    rest = urlMatch.separator + urlMatch.rest;
+  }
+  if (Strings.isEmpty(host)) {
+    return Results.success([null, rest]);
+  }
+  const parseHostResult = parseHost(host);
+  if (!parseHostResult.isSuccess) {
+    return parseHostResult;
+  }
+  return Results.success([parseHostResult.value, rest]);
+};
+var parseHost = (host) => {
+  if (host.startsWith("[")) {
+    const ipMatch = Strings.splitFirst(Strings.removeStart(host, "["), "]");
+    if (Objects.isPresent(ipMatch.selection)) {
+      const ipV6Result = IpV6Addresses.parseString(ipMatch.selection);
+      if (!ipV6Result.isSuccess) {
+        return ipV6Result;
+      }
+      const portMatch = Strings.splitFirst(ipMatch.rest, ":");
+      if (Objects.isPresent(portMatch.selection) && Strings.isEmpty(portMatch.selection)) {
+        if (!Strings.isNumber(portMatch.rest)) {
+          return Results.failure(ErrorEvents.invalidValue(host, { namespace: Namespace, message: `[${Namespace}]: Unable to parse Host: [${host}]` }));
+        }
+        return Results.success({ value: `[${ipMatch.selection}]`, port: Number(portMatch.rest) });
+      } else {
+        return Results.success({ value: `[${ipMatch.selection}]`, port: null });
+      }
+    }
+  }
+  let hostMatch = Strings.splitFirst(host, ":");
+  if (Objects.isNil(hostMatch.selection)) {
+    const hostNameResult2 = UriHostNames.parseString(hostMatch.rest);
+    if (!hostNameResult2.isSuccess) {
+      return Results.failure(
+        ErrorEvents.invalidValue(host, {
+          namespace: Namespace,
+          message: `[${Namespace}]: Unable to parse Host from host string: [${host}]`,
+          causes: hostNameResult2.value.causes
+        })
+      );
+    }
+    return Results.success({ value: hostNameResult2.value, port: null });
+  }
+  if (Strings.isEmpty(hostMatch.selection)) {
+    return Results.failure(
+      ErrorEvents.invalidValue(host, { namespace: Namespace, message: `[${Namespace}]: Unable to parse Host from host string: [${host}]` })
+    );
+  }
+  const hostName = hostMatch.selection;
+  if (!Strings.isNumber(hostMatch.rest)) {
+    return Results.failure(
+      ErrorEvents.invalidValue(host, { namespace: Namespace, message: `[${Namespace}]: Unable to parse Host from host string: [${host}]` })
+    );
+  }
+  const hostNameResult = UriHostNames.parseString(hostName);
+  if (!hostNameResult.isSuccess) {
+    return Results.failure(
+      ErrorEvents.invalidValue(host, {
+        namespace: Namespace,
+        message: `[${Namespace}]: Unable to parse Host from host string: [${host}]`,
+        causes: hostNameResult.value.causes
+      })
+    );
+  }
+  return Results.success({ value: hostNameResult.value, port: Number(hostMatch.rest) });
+};
+var parseLocation = (url) => {
+  const location = { path: null, query: null, fragment: null };
+  const fragmentMatch = Strings.splitFirst(url, "#");
+  if (Objects.isPresent(fragmentMatch.selection) && !Strings.isEmpty(fragmentMatch.rest)) {
+    location.fragment = encodeWhitespace(fragmentMatch.rest);
+  }
+  const queryMatch = Strings.splitFirst(fragmentMatch.selection ?? fragmentMatch.rest, "?");
+  if (Objects.isPresent(queryMatch.selection) && !Strings.isEmpty(queryMatch.rest)) {
+    location.query = encodeWhitespace(queryMatch.rest);
+  }
+  const path = Strings.emptyToNull(queryMatch.selection ?? queryMatch.rest);
+  if (Objects.isPresent(path)) {
+    location.path = encodeWhitespace(path);
+  }
+  return location;
+};
+var build = (builder) => {
+  const scheme = Objects.isPresent(builder.scheme) ? ErrorEvents.unpackResult(parseScheme(builder.scheme)) : null;
+  let host = null;
+  let authentication = null;
+  if (Objects.isPresent(builder.host)) {
+    if (Strings.isString(builder.host)) {
+      host = ErrorEvents.unpackResult(parseHost(builder.host));
+    } else {
+      host = {
+        value: UriHostNames.from(builder.host.value),
+        port: builder.host.port ?? null
+      };
+    }
+    if (Objects.isPresent(builder.authentication)) {
+      if (Strings.isString(builder.authentication)) {
+        authentication = ErrorEvents.unpackResult(parseAuthentication(builder.authentication));
+      } else {
+        authentication = {
+          principal: builder.authentication.principal,
+          password: builder.authentication.password ?? null
+        };
+      }
+    }
+  }
+  let location = {
+    path: null,
+    query: null,
+    fragment: null
+  };
+  if (Objects.isPresent(builder.location)) {
+    if (Strings.isString(builder.location)) {
+      let locationString = builder.location;
+      if (Objects.isPresent(builder.host) && !locationString.startsWith("/") && !locationString.startsWith("?") && !locationString.startsWith("#")) {
+        locationString = "/" + locationString;
+      }
+      location = parseLocation(locationString);
+    } else {
+      let path = builder.location.path ?? null;
+      if (Objects.isPresent(path) && !path.startsWith("/") && Objects.isPresent(builder.host)) {
+        path = "/" + path;
+      }
+      location = {
+        path: Objects.isPresent(path) ? encodeWhitespace(path) : null,
+        query: Objects.isPresent(builder.location.query) ? encodeWhitespace(builder.location.query) : null,
+        fragment: Objects.isPresent(builder.location.fragment) ? encodeWhitespace(builder.location.fragment) : null
+      };
+    }
+  }
+  const structure = {
+    _type: Namespace,
+    scheme,
+    host,
+    authentication,
+    location
+  };
+  return {
+    ...structure,
+    href: formatInternal(structure)
+  };
+};
+var UriComponentType = {
+  Scheme: "Scheme",
+  Authentication: "Authentication",
+  Host: "Host",
+  Location: "Location",
+  Path: "Path",
+  Query: "Query",
+  Fragment: "Fragment"
+};
+var format = (uriLike, excludedUriComponents = []) => {
+  return formatInternal(from2(uriLike), excludedUriComponents);
+};
+var formatInternal = (uri, excludedUriComponents = []) => {
+  let urlString = "";
+  if (Objects.isPresent(uri.scheme) && !Arrays.contains(excludedUriComponents, UriComponentType.Scheme)) {
+    urlString = urlString + uri.scheme + ":";
+  }
+  if (Objects.isPresent(uri.host) && !Arrays.contains(excludedUriComponents, UriComponentType.Host)) {
+    urlString = urlString + "//";
+    if (Objects.isPresent(uri.authentication) && !Arrays.contains(excludedUriComponents, UriComponentType.Authentication)) {
+      urlString = urlString + encode(uri.authentication.principal);
+      if (Objects.isPresent(uri.authentication.password)) {
+        urlString = urlString + ":" + encode(uri.authentication.password);
+      }
+      urlString = urlString + "@";
+    }
+    urlString = urlString + uri.host.value;
+    if (Objects.isPresent(uri.host.port)) {
+      urlString = urlString + ":" + uri.host.port;
+    }
+  }
+  if (!Arrays.contains(excludedUriComponents, UriComponentType.Location)) {
+    urlString = urlString + formatLocation(uri.location, excludedUriComponents);
+  }
+  return urlString;
+};
+var formatLocation = (location, excludedUriComponents = []) => {
+  let urlString = "";
+  if (Objects.isPresent(location.path) && !Arrays.contains(excludedUriComponents, UriComponentType.Path)) {
+    urlString = urlString + location.path;
+  }
+  if (Objects.isPresent(location.query) && !Arrays.contains(excludedUriComponents, UriComponentType.Query)) {
+    urlString = urlString + "?" + location.query;
+  }
+  if (Objects.isPresent(location.fragment) && !Arrays.contains(excludedUriComponents, UriComponentType.Fragment)) {
+    urlString = urlString + "#" + location.fragment;
+  }
+  return urlString;
+};
+var encodeWhitespace = (uriComponent) => {
+  return uriComponent.replaceAll(" ", "%20");
+};
+var encode = (uriComponent) => {
+  return encodeURIComponent(uriComponent);
+};
+var decode = (uriComponent) => {
+  return decodeURIComponent(uriComponent);
+};
+export {
+  EqualBy,
+  Namespace,
+  SchemaLiteral,
+  UriComponentType,
+  UrlNamespace,
+  decode,
+  encode,
+  format,
+  from2 as from,
+  isUri,
+  merge,
+  parseString3 as parseString,
+  toLiteral
+};
+//# sourceMappingURL=uri.js.map