@effect/platform 0.18.1 → 0.18.3

package/{mjs/internal/http/platform.mjs → internal/http/platform.esm.js}

@@ -1,16 +1,19 @@
-import * as FileSystem from "@effect/platform/FileSystem";
-import * as Etag from "@effect/platform/Http/Etag";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import { pipe } from "effect/Function";
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import { pipe } from 'effect/Function';
+import { FileSystem } from '../../FileSystem/dist/effect-platform-FileSystem.esm.js';
+import { Generator, toString } from '../../Http/Http/Etag/dist/effect-platform-Http-Etag.esm.js';
+
 /** @internal */
-export const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Platform");
+const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Platform");
+
 /** @internal */
-export const tag = /*#__PURE__*/Context.Tag(TypeId);
+const tag = /*#__PURE__*/Context.Tag(TypeId);
+
 /** @internal */
-export const make = impl => Effect.gen(function* (_) {
-  const fs = yield* _(FileSystem.FileSystem);
-  const etagGen = yield* _(Etag.Generator);
+const make = impl => Effect.gen(function* (_) {
+  const fs = yield* _(FileSystem);
+  const etagGen = yield* _(Generator);
   return tag.of({
     [TypeId]: TypeId,
     fileResponse(path, options) {
@@ -24,7 +27,7 @@ export const make = impl => Effect.gen(function* (_) {
         const end = options?.bytesToRead !== undefined ? start + Number(options.bytesToRead) : undefined;
         const headers = {
           ...(options?.headers ?? {}),
-          etag: Etag.toString(etag)
+          etag: toString(etag)
         };
         if (info.mtime._tag === "Some") {
           headers["last-modified"] = info.mtime.value.toUTCString();
@@ -37,7 +40,7 @@ export const make = impl => Effect.gen(function* (_) {
       return Effect.map(etagGen.fromFileWeb(file), etag => {
         const headers = {
           ...(options?.headers ?? {}),
-          etag: Etag.toString(etag),
+          etag: toString(etag),
           "last-modified": new Date(file.lastModified).toUTCString()
         };
         return impl.fileWebResponse(file, options?.status ?? 200, options?.statusText, headers, options);
@@ -45,4 +48,5 @@ export const make = impl => Effect.gen(function* (_) {
     }
   });
 });
-//# sourceMappingURL=platform.mjs.map
+
+export { TypeId, make, tag };

package/internal/http/router.esm.js

@@ -0,0 +1,199 @@
+import * as Schema from '@effect/schema/Schema';
+import * as Chunk from 'effect/Chunk';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Effectable from 'effect/Effectable';
+import { dual } from 'effect/Function';
+import * as Inspectable from 'effect/Inspectable';
+import * as Option from 'effect/Option';
+import FindMyWay from 'find-my-way';
+import { RouteNotFound } from '../../Http/Http/ServerError/dist/effect-platform-Http-ServerError.esm.js';
+import { ServerRequest } from '../../Http/Http/ServerRequest/dist/effect-platform-Http-ServerRequest.esm.js';
+
+/** @internal */
+const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Router");
+
+/** @internal */
+const RouteTypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Router/Route");
+
+/** @internal */
+const RouteContextTypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Router/RouteContext");
+
+/** @internal */
+const RouteContext = /*#__PURE__*/Context.Tag("@effect/platform/Http/Router/RouteContext");
+
+/** @internal */
+const params = /*#__PURE__*/Effect.map(RouteContext, _ => _.params);
+
+/** @internal */
+const searchParams = /*#__PURE__*/Effect.map(RouteContext, _ => _.searchParams);
+
+/** @internal */
+const schemaParams = schema => {
+  const parse = Schema.parse(schema);
+  return Effect.flatMap(RouteContext, _ => parse({
+    ..._.searchParams,
+    ..._.params
+  }));
+};
+class RouterImpl extends Effectable.Effectable {
+  constructor(routes, mounts) {
+    super();
+    this.routes = routes;
+    this.mounts = mounts;
+    this[TypeId] = TypeId;
+  }
+  commit() {
+    if (this.httpApp === undefined) {
+      this.httpApp = toHttpApp(this);
+    }
+    return this.httpApp;
+  }
+  toJSON() {
+    return {
+      _id: "Router",
+      routes: this.routes.toJSON(),
+      mounts: this.mounts.toJSON()
+    };
+  }
+  toString() {
+    return Inspectable.toString(this);
+  }
+  [Inspectable.NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+}
+const toHttpApp = self => {
+  const router = FindMyWay();
+  const mounts = Chunk.toReadonlyArray(self.mounts);
+  const mountsLen = mounts.length;
+  Chunk.forEach(self.routes, route => {
+    function fn() {
+      return route;
+    }
+    if (route.method === "*") {
+      router.all(route.path, fn);
+    } else {
+      router.on(route.method, route.path, fn);
+    }
+  });
+  return Effect.flatMap(ServerRequest, request => {
+    if (mountsLen > 0) {
+      for (let i = 0; i < mountsLen; i++) {
+        const [path, app] = mounts[i];
+        if (request.url.startsWith(path)) {
+          return Effect.provideService(app, ServerRequest, sliceRequestUrl(request, path));
+        }
+      }
+    }
+    let result = router.find(request.method, request.url);
+    if (result === null && request.method === "HEAD") {
+      result = router.find("GET", request.url);
+    }
+    if (result === null) {
+      return Effect.fail(RouteNotFound({
+        request
+      }));
+    }
+    const route = result.handler();
+    if (route.prefix._tag === "Some") {
+      request = sliceRequestUrl(request, route.prefix.value);
+    }
+    return Effect.mapInputContext(route.handler, context => Context.add(Context.add(context, ServerRequest, request), RouteContext, new RouteContextImpl(result.params, result.searchParams)));
+  });
+};
+function sliceRequestUrl(request, prefix) {
+  const prefexLen = prefix.length;
+  return request.modify({
+    url: request.url.length <= prefexLen ? "/" : request.url.slice(prefexLen)
+  });
+}
+class RouteImpl {
+  constructor(method, path, handler, prefix = Option.none()) {
+    this.method = method;
+    this.path = path;
+    this.handler = handler;
+    this.prefix = prefix;
+    this[RouteTypeId] = RouteTypeId;
+  }
+}
+class RouteContextImpl {
+  constructor(params, searchParams) {
+    this.params = params;
+    this.searchParams = searchParams;
+    this[RouteContextTypeId] = RouteContextTypeId;
+  }
+}
+
+/** @internal */
+const empty = /*#__PURE__*/new RouterImpl( /*#__PURE__*/Chunk.empty(), /*#__PURE__*/Chunk.empty());
+
+/** @internal */
+const fromIterable = routes => new RouterImpl(Chunk.fromIterable(routes), Chunk.empty());
+
+/** @internal */
+const makeRoute = (method, path, handler, prefix = Option.none()) => new RouteImpl(method, path, handler, prefix);
+
+/** @internal */
+const concat = /*#__PURE__*/dual(2, (self, that) => new RouterImpl(Chunk.appendAll(self.routes, that.routes), self.mounts));
+const removeTrailingSlash = path => path.endsWith("/") ? path.slice(0, -1) : path;
+
+/** @internal */
+const prefixAll = /*#__PURE__*/dual(2, (self, prefix) => {
+  prefix = removeTrailingSlash(prefix);
+  return new RouterImpl(Chunk.map(self.routes, route => new RouteImpl(route.method, route.path === "/" ? prefix : prefix + route.path, route.handler, Option.orElse(Option.map(route.prefix, _ => prefix + _), () => Option.some(prefix)))), Chunk.map(self.mounts, ([path, app]) => [path === "/" ? prefix : prefix + path, app]));
+});
+
+/** @internal */
+const mount = /*#__PURE__*/dual(3, (self, path, that) => concat(self, prefixAll(that, path)));
+
+/** @internal */
+const mountApp = /*#__PURE__*/dual(3, (self, path, that) => new RouterImpl(self.routes, Chunk.append(self.mounts, [removeTrailingSlash(path), that])));
+
+/** @internal */
+const route = method => dual(3, (self, path, handler) => new RouterImpl(Chunk.append(self.routes, new RouteImpl(method, path, handler)), self.mounts));
+
+/** @internal */
+const all = /*#__PURE__*/route("*");
+
+/** @internal */
+const get = /*#__PURE__*/route("GET");
+
+/** @internal */
+const post = /*#__PURE__*/route("POST");
+
+/** @internal */
+const put = /*#__PURE__*/route("PUT");
+
+/** @internal */
+const patch = /*#__PURE__*/route("PATCH");
+
+/** @internal */
+const del = /*#__PURE__*/route("DELETE");
+
+/** @internal */
+const head = /*#__PURE__*/route("HEAD");
+
+/** @internal */
+const options = /*#__PURE__*/route("OPTIONS");
+
+/** @internal */
+const use = /*#__PURE__*/dual(2, (self, f) => new RouterImpl(Chunk.map(self.routes, route => new RouteImpl(route.method, route.path, f(route.handler), route.prefix)), Chunk.map(self.mounts, ([path, app]) => [path, f(app)])));
+
+/** @internal */
+const catchAll = /*#__PURE__*/dual(2, (self, f) => use(self, Effect.catchAll(f)));
+
+/** @internal */
+const catchAllCause = /*#__PURE__*/dual(2, (self, f) => use(self, Effect.catchAllCause(f)));
+
+/** @internal */
+const catchTag = /*#__PURE__*/dual(3, (self, k, f) => use(self, Effect.catchTag(k, f)));
+
+/** @internal */
+const catchTags = /*#__PURE__*/dual(2, (self, cases) => use(self, Effect.catchTags(cases)));
+const provideService = /*#__PURE__*/dual(3, (self, tag, service) => use(self, Effect.provideService(tag, service)));
+
+/* @internal */
+const provideServiceEffect = /*#__PURE__*/dual(3, (self, tag, effect) => use(self, Effect.provideServiceEffect(tag, effect)));
+
+export { RouteContext, RouteContextTypeId, RouteTypeId, TypeId, all, catchAll, catchAllCause, catchTag, catchTags, concat, del, empty, fromIterable, get, head, makeRoute, mount, mountApp, options, params, patch, post, prefixAll, provideService, provideServiceEffect, put, route, schemaParams, searchParams, use };

package/internal/http/server.esm.js

@@ -0,0 +1,20 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import { dual } from 'effect/Function';
+
+/** @internal */
+const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Server");
+
+/** @internal */
+const serverTag = /*#__PURE__*/Context.Tag(TypeId);
+const serverProto = {
+  [TypeId]: TypeId
+};
+
+/** @internal */
+const make = options => Object.assign(Object.create(serverProto), options);
+
+/** @internal */
+const serve = /*#__PURE__*/dual(args => Effect.isEffect(args[0]), (httpApp, middleware) => Effect.flatMap(serverTag, server => server.serve(httpApp, middleware)));
+
+export { TypeId, make, serve, serverTag };

package/internal/http/serverError.esm.js

@@ -0,0 +1,23 @@
+import * as Data from 'effect/Data';
+
+/** @internal */
+const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/Error");
+const make = tag => props => Data.struct({
+  [TypeId]: TypeId,
+  _tag: tag,
+  ...props
+});
+
+/** @internal */
+const requestError = /*#__PURE__*/make("RequestError");
+
+/** @internal */
+const responseError = /*#__PURE__*/make("ResponseError");
+
+/** @internal */
+const routeNotFound = /*#__PURE__*/make("RouteNotFound");
+
+/** @internal */
+const serveError = /*#__PURE__*/make("ServeError");
+
+export { TypeId, requestError, responseError, routeNotFound, serveError };

package/internal/http/serverRequest.esm.js

@@ -0,0 +1,50 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import { toRecord, schemaRecord, schemaJson } from '../../Http/Http/FormData/dist/effect-platform-Http-FormData.esm.js';
+import { schemaHeaders as schemaHeaders$1, schemaBodyJson as schemaBodyJson$1, schemaBodyUrlParams as schemaBodyUrlParams$1 } from '../../Http/Http/IncomingMessage/dist/effect-platform-Http-IncomingMessage.esm.js';
+import { RequestError } from '../../Http/Http/ServerError/dist/effect-platform-Http-ServerError.esm.js';
+
+/** @internal */
+const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/ServerRequest");
+
+/** @internal */
+const serverRequestTag = /*#__PURE__*/Context.Tag(TypeId);
+
+/** @internal */
+const formDataRecord = /*#__PURE__*/Effect.map( /*#__PURE__*/Effect.flatMap(serverRequestTag, request => request.formData), toRecord);
+
+/** @internal */
+const schemaHeaders = schema => {
+  const parse = schemaHeaders$1(schema);
+  return Effect.flatMap(serverRequestTag, parse);
+};
+
+/** @internal */
+const schemaBodyJson = schema => {
+  const parse = schemaBodyJson$1(schema);
+  return Effect.flatMap(serverRequestTag, parse);
+};
+
+/** @internal */
+const schemaBodyUrlParams = schema => {
+  const parse = schemaBodyUrlParams$1(schema);
+  return Effect.flatMap(serverRequestTag, parse);
+};
+
+/** @internal */
+const schemaFormData = schema => {
+  const parse = schemaRecord(schema);
+  return Effect.flatMap(Effect.flatMap(serverRequestTag, request => request.formData), parse);
+};
+
+/** @internal */
+const schemaFormDataJson = schema => {
+  const parse = schemaJson(schema);
+  return field => Effect.flatMap(serverRequestTag, request => Effect.flatMap(request.formData, formData => Effect.catchTag(parse(formData, field), "FormDataError", error => Effect.fail(RequestError({
+    reason: "Decode",
+    request,
+    error: error.error
+  })))));
+};
+
+export { TypeId, formDataRecord, schemaBodyJson, schemaBodyUrlParams, schemaFormData, schemaFormDataJson, schemaHeaders, serverRequestTag };

package/internal/http/serverResponse.esm.js

@@ -0,0 +1,105 @@
+import * as Effect from 'effect/Effect';
+import { dual } from 'effect/Function';
+import { pipeArguments } from 'effect/Pipeable';
+import { empty as empty$1, set, setAll, remove } from '../../Http/Http/Headers/dist/effect-platform-Http-Headers.esm.js';
+import { Platform } from '../../Http/Http/Platform/dist/effect-platform-Http-Platform.esm.js';
+import { toString, fromInput } from '../../Http/Http/UrlParams/dist/effect-platform-Http-UrlParams.esm.js';
+import { empty as empty$2, uint8Array as uint8Array$1, text as text$1, json as json$1, unsafeJson as unsafeJson$1, jsonSchema, raw as raw$1, formData as formData$1, stream as stream$1 } from './body.esm.js';
+
+/** @internal */
+const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/Http/ServerResponse");
+class ServerResponseImpl {
+  constructor(status, statusText, headers, body) {
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this[TypeId] = TypeId;
+    if (body.contentType || body.contentLength) {
+      const newHeaders = {
+        ...headers
+      };
+      if (body.contentType) {
+        newHeaders["content-type"] = body.contentType;
+      }
+      if (body.contentLength) {
+        newHeaders["content-length"] = body.contentLength.toString();
+      }
+      this.headers = newHeaders;
+    } else {
+      this.headers = headers;
+    }
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}
+
+/** @internal */
+const isServerResponse = u => typeof u === "object" && u !== null && TypeId in u;
+
+/** @internal */
+const empty = options => new ServerResponseImpl(options?.status ?? 204, options?.statusText, options?.headers ?? empty$1, empty$2);
+
+/** @internal */
+const uint8Array = (body, options) => new ServerResponseImpl(options?.status ?? 200, options?.statusText, options?.headers ?? empty$1, uint8Array$1(body, getContentType(options)));
+
+/** @internal */
+const text = (body, options) => new ServerResponseImpl(options?.status ?? 200, options?.statusText, options?.headers ?? empty$1, text$1(body, getContentType(options)));
+
+/** @internal */
+const json = (body, options) => Effect.map(json$1(body), body => new ServerResponseImpl(options?.status ?? 200, options?.statusText, options?.headers ?? empty$1, body));
+
+/** @internal */
+const unsafeJson = (body, options) => new ServerResponseImpl(options?.status ?? 200, options?.statusText, options?.headers ?? empty$1, unsafeJson$1(body));
+
+/** @internal */
+const schemaJson = schema => {
+  const encode = jsonSchema(schema);
+  return (body, options) => Effect.map(encode(body), body => new ServerResponseImpl(options?.status ?? 200, options?.statusText, options?.headers ?? empty$1, body));
+};
+
+/** @internal */
+const file = (path, options) => Effect.flatMap(Platform, platform => platform.fileResponse(path, options));
+
+/** @internal */
+const fileWeb = (file, options) => Effect.flatMap(Platform, platform => platform.fileWebResponse(file, options));
+
+/** @internal */
+const urlParams = (body, options) => new ServerResponseImpl(options?.status ?? 200, options?.statusText, options?.headers ?? empty$1, text$1(toString(fromInput(body)), "application/x-www-form-urlencoded"));
+
+/** @internal */
+const raw = (body, options) => new ServerResponseImpl(options?.status ?? 200, options?.statusText, options?.headers ?? empty$1, raw$1(body));
+
+/** @internal */
+const formData = (body, options) => new ServerResponseImpl(options?.status ?? 200, options?.statusText, options?.headers ?? empty$1, formData$1(body));
+
+/** @internal */
+const stream = (body, options) => new ServerResponseImpl(options?.status ?? 200, options?.statusText, options?.headers ?? empty$1, stream$1(body, getContentType(options), options?.contentLength));
+
+/** @internal */
+const getContentType = options => {
+  if (options?.contentType) {
+    return options.contentType;
+  } else if (options?.headers) {
+    return options.headers["content-type"];
+  } else {
+    return;
+  }
+};
+
+/** @internal */
+const setHeader = /*#__PURE__*/dual(3, (self, key, value) => new ServerResponseImpl(self.status, self.statusText, set(self.headers, key, value), self.body));
+
+/** @internal */
+const setHeaders = /*#__PURE__*/dual(2, (self, input) => new ServerResponseImpl(self.status, self.statusText, setAll(self.headers, input), self.body));
+
+/** @internal */
+const setBody = /*#__PURE__*/dual(2, (self, body) => {
+  let headers = self.headers;
+  if (body._tag === "Empty") {
+    headers = remove(remove(headers, "Content-Type"), "Content-length");
+  }
+  return new ServerResponseImpl(self.status, self.statusText, headers, body);
+});
+
+export { TypeId, empty, file, fileWeb, formData, getContentType, isServerResponse, json, raw, schemaJson, setBody, setHeader, setHeaders, stream, text, uint8Array, unsafeJson, urlParams };

package/{mjs/internal/keyValueStore.mjs → internal/keyValueStore.esm.js}

@@ -1,17 +1,20 @@
-import * as FileSystem from "@effect/platform/FileSystem";
-import * as Path from "@effect/platform/Path";
-import * as Schema from "@effect/schema/Schema";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import { dual, pipe } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
+import * as Schema from '@effect/schema/Schema';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import { dual, pipe } from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import { FileSystem } from '../FileSystem/dist/effect-platform-FileSystem.esm.js';
+import { Path } from '../Path/dist/effect-platform-Path.esm.js';
+
 /** @internal */
-export const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/KeyValueStore");
+const TypeId = /*#__PURE__*/Symbol.for("@effect/platform/KeyValueStore");
+
 /** @internal */
-export const keyValueStoreTag = /*#__PURE__*/Context.Tag(TypeId);
+const keyValueStoreTag = /*#__PURE__*/Context.Tag(TypeId);
+
 /** @internal */
-export const make = impl => keyValueStoreTag.of({
+const make = impl => keyValueStoreTag.of({
   [TypeId]: TypeId,
   has: key => Effect.map(impl.get(key), Option.isSome),
   isEmpty: Effect.map(impl.size, size => size === 0),
@@ -27,8 +30,9 @@ export const make = impl => keyValueStoreTag.of({
   },
   ...impl
 });
+
 /** @internal */
-export const prefix = /*#__PURE__*/dual(2, (self, prefix) => ({
+const prefix = /*#__PURE__*/dual(2, (self, prefix) => ({
   ...self,
   get: key => self.get(`${prefix}${key}`),
   set: (key, value) => self.set(`${prefix}${key}`, value),
@@ -36,8 +40,10 @@ export const prefix = /*#__PURE__*/dual(2, (self, prefix) => ({
   has: key => self.has(`${prefix}${key}`),
   modify: (key, f) => self.modify(`${prefix}${key}`, f)
 }));
+
 /** @internal */
-export const SchemaStoreTypeId = /*#__PURE__*/Symbol.for("@effect/platform/KeyValueStore/SchemaStore");
+const SchemaStoreTypeId = /*#__PURE__*/Symbol.for("@effect/platform/KeyValueStore/SchemaStore");
+
 /** @internal */
 const makeSchemaStore = (store, schema) => {
   const jsonSchema = Schema.compose(Schema.ParseJson, schema);
@@ -67,8 +73,9 @@ const makeSchemaStore = (store, schema) => {
     isEmpty: store.isEmpty
   };
 };
+
 /** @internal */
-export const layerMemory = /*#__PURE__*/Layer.sync(keyValueStoreTag, () => {
+const layerMemory = /*#__PURE__*/Layer.sync(keyValueStoreTag, () => {
   const store = new Map();
   return make({
     get: key => Effect.sync(() => Option.fromNullable(store.get(key))),
@@ -78,10 +85,11 @@ export const layerMemory = /*#__PURE__*/Layer.sync(keyValueStoreTag, () => {
     size: Effect.sync(() => store.size)
   });
 });
+
 /** @internal */
-export const layerFileSystem = directory => Layer.effect(keyValueStoreTag, Effect.gen(function* (_) {
-  const fs = yield* _(FileSystem.FileSystem);
-  const path = yield* _(Path.Path);
+const layerFileSystem = directory => Layer.effect(keyValueStoreTag, Effect.gen(function* (_) {
+  const fs = yield* _(FileSystem);
+  const path = yield* _(Path);
   const keyPath = key => path.join(directory, encodeURIComponent(key));
   if (!(yield* _(fs.exists(directory)))) {
     yield* _(fs.makeDirectory(directory, {
@@ -101,8 +109,9 @@ export const layerFileSystem = directory => Layer.effect(keyValueStoreTag, Effec
     size: Effect.map(fs.readDirectory(directory), files => files.length)
   });
 }));
+
 /** @internal */
-export const layerSchema = (schema, tagIdentifier) => {
+const layerSchema = (schema, tagIdentifier) => {
   const tag = Context.Tag(tagIdentifier);
   const layer = Layer.effect(tag, Effect.map(keyValueStoreTag, store => store.forSchema(schema)));
   return {
@@ -110,4 +119,5 @@ export const layerSchema = (schema, tagIdentifier) => {
     layer
   };
 };
-//# sourceMappingURL=keyValueStore.mjs.map
+
+export { SchemaStoreTypeId, TypeId, keyValueStoreTag, layerFileSystem, layerMemory, layerSchema, make, prefix };

package/{mjs/internal/path.mjs → internal/path.esm.js}

@@ -1,18 +1,21 @@
-import { BadArgument } from "@effect/platform/Error";
-import { Tag } from "effect/Context";
-import * as Effect from "effect/Effect";
-import { identity } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as PathB from "path-browserify";
+import { Tag } from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import { identity } from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import * as PathB from 'path-browserify';
+import { BadArgument } from '../Error/dist/effect-platform-Error.esm.js';
+
 /** @internal */
-export const Path = /*#__PURE__*/Tag("@effect/platform/Path");
+const Path = /*#__PURE__*/Tag("@effect/platform/Path");
+
 /** @internal */
-export const layer = /*#__PURE__*/Layer.succeed(Path, /*#__PURE__*/Path.of({
+const layer = /*#__PURE__*/Layer.succeed(Path, /*#__PURE__*/Path.of({
   ...PathB,
   fromFileUrl,
   toFileUrl,
   toNamespacedPath: identity
 }));
+
 /**
  * The following functions are adapted from the Node.js source code:
  * https://github.com/nodejs/node/blob/main/lib/internal/url.js
@@ -20,6 +23,7 @@ export const layer = /*#__PURE__*/Layer.succeed(Path, /*#__PURE__*/Path.of({
  * The following license applies to these functions:
  * - MIT
  */
+
 function fromFileUrl(url) {
   if (url.protocol !== "file:") {
     return Effect.fail(BadArgument({
@@ -84,4 +88,5 @@ function encodePathChars(filepath) {
   }
   return filepath;
 }
-//# sourceMappingURL=path.mjs.map
+
+export { Path, layer };