touch-all 1.2.0 → 2.0.0

package/dist/lib/index.js

@@ -1,11 +1,777 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+// node_modules/@effect/platform/dist/esm/FileSystem.js
+var exports_FileSystem = {};
+__export(exports_FileSystem, {
+  makeNoop: () => makeNoop2,
+  make: () => make2,
+  layerNoop: () => layerNoop2,
+  isFile: () => isFile,
+  WatchEventUpdate: () => WatchEventUpdate,
+  WatchEventRemove: () => WatchEventRemove,
+  WatchEventCreate: () => WatchEventCreate,
+  WatchBackend: () => WatchBackend,
+  TiB: () => TiB2,
+  Size: () => Size2,
+  PiB: () => PiB2,
+  MiB: () => MiB2,
+  KiB: () => KiB2,
+  GiB: () => GiB2,
+  FileTypeId: () => FileTypeId,
+  FileSystem: () => FileSystem,
+  FileDescriptor: () => FileDescriptor
+});
+import * as Brand from "effect/Brand";
+import * as Context from "effect/Context";
+import * as Data2 from "effect/Data";
+
+// node_modules/@effect/platform/dist/esm/internal/fileSystem.js
+import * as Channel from "effect/Channel";
+import * as Chunk from "effect/Chunk";
+import { GenericTag } from "effect/Context";
+import * as Effect from "effect/Effect";
+import { identity, pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+
+// node_modules/@effect/platform/dist/esm/Error.js
+import * as Data from "effect/Data";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+var TypeId = /* @__PURE__ */ Symbol.for("@effect/platform/Error");
+var Module = /* @__PURE__ */ Schema.Literal("Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal");
+
+class BadArgument extends (/* @__PURE__ */ Schema.TaggedError("@effect/platform/Error/BadArgument")("BadArgument", {
+  module: Module,
+  method: Schema.String,
+  description: /* @__PURE__ */ Schema.optional(Schema.String),
+  cause: /* @__PURE__ */ Schema.optional(Schema.Defect)
+})) {
+  [TypeId] = TypeId;
+  get message() {
+    return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`;
+  }
+}
+var SystemErrorReason = /* @__PURE__ */ Schema.Literal("AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero");
+
+class SystemError extends (/* @__PURE__ */ Schema.TaggedError("@effect/platform/Error/SystemError")("SystemError", {
+  reason: SystemErrorReason,
+  module: Module,
+  method: Schema.String,
+  description: /* @__PURE__ */ Schema.optional(Schema.String),
+  syscall: /* @__PURE__ */ Schema.optional(Schema.String),
+  pathOrDescriptor: /* @__PURE__ */ Schema.optional(/* @__PURE__ */ Schema.Union(Schema.String, Schema.Number)),
+  cause: /* @__PURE__ */ Schema.optional(Schema.Defect)
+})) {
+  [TypeId] = TypeId;
+  get message() {
+    return `${this.reason}: ${this.module}.${this.method}${this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""}${this.description ? `: ${this.description}` : ""}`;
+  }
+}
+
+// node_modules/@effect/platform/dist/esm/internal/fileSystem.js
+var tag = /* @__PURE__ */ GenericTag("@effect/platform/FileSystem");
+var Size = (bytes) => typeof bytes === "bigint" ? bytes : BigInt(bytes);
+var KiB = (n) => Size(n * 1024);
+var MiB = (n) => Size(n * 1024 * 1024);
+var GiB = (n) => Size(n * 1024 * 1024 * 1024);
+var TiB = (n) => Size(n * 1024 * 1024 * 1024 * 1024);
+var bigint1024 = /* @__PURE__ */ BigInt(1024);
+var bigintPiB = bigint1024 * bigint1024 * bigint1024 * bigint1024 * bigint1024;
+var PiB = (n) => Size(BigInt(n) * bigintPiB);
+var make = (impl) => {
+  return tag.of({
+    ...impl,
+    exists: (path) => pipe(impl.access(path), Effect.as(true), Effect.catchTag("SystemError", (e) => e.reason === "NotFound" ? Effect.succeed(false) : Effect.fail(e))),
+    readFileString: (path, encoding) => Effect.tryMap(impl.readFile(path), {
+      try: (_) => new TextDecoder(encoding).decode(_),
+      catch: (cause) => new BadArgument({
+        module: "FileSystem",
+        method: "readFileString",
+        description: "invalid encoding",
+        cause
+      })
+    }),
+    stream: (path, options) => pipe(impl.open(path, {
+      flag: "r"
+    }), options?.offset ? Effect.tap((file) => file.seek(options.offset, "start")) : identity, Effect.map((file) => stream(file, options)), Stream.unwrapScoped),
+    sink: (path, options) => pipe(impl.open(path, {
+      flag: "w",
+      ...options
+    }), Effect.map((file) => Sink.forEach((_) => file.writeAll(_))), Sink.unwrapScoped),
+    writeFileString: (path, data, options) => Effect.flatMap(Effect.try({
+      try: () => new TextEncoder().encode(data),
+      catch: (cause) => new BadArgument({
+        module: "FileSystem",
+        method: "writeFileString",
+        description: "could not encode string",
+        cause
+      })
+    }), (_) => impl.writeFile(path, _, options))
+  });
+};
+var notFound = (method, path) => new SystemError({
+  module: "FileSystem",
+  method,
+  reason: "NotFound",
+  description: "No such file or directory",
+  pathOrDescriptor: path
+});
+var makeNoop = (fileSystem) => {
+  return {
+    access(path) {
+      return Effect.fail(notFound("access", path));
+    },
+    chmod(path) {
+      return Effect.fail(notFound("chmod", path));
+    },
+    chown(path) {
+      return Effect.fail(notFound("chown", path));
+    },
+    copy(path) {
+      return Effect.fail(notFound("copy", path));
+    },
+    copyFile(path) {
+      return Effect.fail(notFound("copyFile", path));
+    },
+    exists() {
+      return Effect.succeed(false);
+    },
+    link(path) {
+      return Effect.fail(notFound("link", path));
+    },
+    makeDirectory() {
+      return Effect.die("not implemented");
+    },
+    makeTempDirectory() {
+      return Effect.die("not implemented");
+    },
+    makeTempDirectoryScoped() {
+      return Effect.die("not implemented");
+    },
+    makeTempFile() {
+      return Effect.die("not implemented");
+    },
+    makeTempFileScoped() {
+      return Effect.die("not implemented");
+    },
+    open(path) {
+      return Effect.fail(notFound("open", path));
+    },
+    readDirectory(path) {
+      return Effect.fail(notFound("readDirectory", path));
+    },
+    readFile(path) {
+      return Effect.fail(notFound("readFile", path));
+    },
+    readFileString(path) {
+      return Effect.fail(notFound("readFileString", path));
+    },
+    readLink(path) {
+      return Effect.fail(notFound("readLink", path));
+    },
+    realPath(path) {
+      return Effect.fail(notFound("realPath", path));
+    },
+    remove() {
+      return Effect.void;
+    },
+    rename(oldPath) {
+      return Effect.fail(notFound("rename", oldPath));
+    },
+    sink(path) {
+      return Sink.fail(notFound("sink", path));
+    },
+    stat(path) {
+      return Effect.fail(notFound("stat", path));
+    },
+    stream(path) {
+      return Stream.fail(notFound("stream", path));
+    },
+    symlink(fromPath) {
+      return Effect.fail(notFound("symlink", fromPath));
+    },
+    truncate(path) {
+      return Effect.fail(notFound("truncate", path));
+    },
+    utimes(path) {
+      return Effect.fail(notFound("utimes", path));
+    },
+    watch(path) {
+      return Stream.fail(notFound("watch", path));
+    },
+    writeFile(path) {
+      return Effect.fail(notFound("writeFile", path));
+    },
+    writeFileString(path) {
+      return Effect.fail(notFound("writeFileString", path));
+    },
+    ...fileSystem
+  };
+};
+var layerNoop = (fileSystem) => Layer.succeed(tag, makeNoop(fileSystem));
+var stream = (file, {
+  bufferSize = 16,
+  bytesToRead: bytesToRead_,
+  chunkSize: chunkSize_ = Size(64 * 1024)
+} = {}) => {
+  const bytesToRead = bytesToRead_ !== undefined ? Size(bytesToRead_) : undefined;
+  const chunkSize = Size(chunkSize_);
+  function loop(totalBytesRead) {
+    if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
+      return Channel.void;
+    }
+    const toRead = bytesToRead !== undefined && bytesToRead - totalBytesRead < chunkSize ? bytesToRead - totalBytesRead : chunkSize;
+    return Channel.flatMap(file.readAlloc(toRead), Option.match({
+      onNone: () => Channel.void,
+      onSome: (buf) => Channel.flatMap(Channel.write(Chunk.of(buf)), (_) => loop(totalBytesRead + BigInt(buf.length)))
+    }));
+  }
+  return Stream.bufferChunks(Stream.fromChannel(loop(BigInt(0))), {
+    capacity: bufferSize
+  });
+};
+
+// node_modules/@effect/platform/dist/esm/FileSystem.js
+var Size2 = Size;
+var KiB2 = KiB;
+var MiB2 = MiB;
+var GiB2 = GiB;
+var TiB2 = TiB;
+var PiB2 = PiB;
+var FileSystem = tag;
+var make2 = make;
+var makeNoop2 = makeNoop;
+var layerNoop2 = layerNoop;
+var FileTypeId = /* @__PURE__ */ Symbol.for("@effect/platform/FileSystem/File");
+var isFile = (u) => typeof u === "object" && u !== null && (FileTypeId in u);
+var FileDescriptor = /* @__PURE__ */ Brand.nominal();
+var WatchEventCreate = /* @__PURE__ */ Data2.tagged("Create");
+var WatchEventUpdate = /* @__PURE__ */ Data2.tagged("Update");
+var WatchEventRemove = /* @__PURE__ */ Data2.tagged("Remove");
+
+class WatchBackend extends (/* @__PURE__ */ Context.Tag("@effect/platform/FileSystem/WatchBackend")()) {
+}
+// node_modules/@effect/platform/dist/esm/Path.js
+var exports_Path = {};
+__export(exports_Path, {
+  layer: () => layer2,
+  TypeId: () => TypeId3,
+  Path: () => Path2
+});
+
+// node_modules/@effect/platform/dist/esm/internal/path.js
+import { GenericTag as GenericTag2 } from "effect/Context";
+import * as Effect2 from "effect/Effect";
+import { identity as identity2 } from "effect/Function";
+import * as Layer2 from "effect/Layer";
+var TypeId2 = /* @__PURE__ */ Symbol.for("@effect/platform/Path");
+var Path = /* @__PURE__ */ GenericTag2("@effect/platform/Path");
+function normalizeStringPosix(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let code;
+  for (let i = 0;i <= path.length; ++i) {
+    if (i < path.length) {
+      code = path.charCodeAt(i);
+    } else if (code === 47) {
+      break;
+    } else {
+      code = 47;
+    }
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1) {} else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1) {
+                res = "";
+                lastSegmentLength = 0;
+              } else {
+                res = res.slice(0, lastSlashIndex);
+                lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              }
+              lastSlash = i;
+              dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0) {
+            res += "/..";
+          } else {
+            res = "..";
+          }
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += "/" + path.slice(lastSlash + 1, i);
+        } else {
+          res = path.slice(lastSlash + 1, i);
+        }
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === 46 && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  const dir = pathObject.dir || pathObject.root;
+  const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir) {
+    return base;
+  }
+  if (dir === pathObject.root) {
+    return dir + base;
+  }
+  return dir + sep + base;
+}
+function fromFileUrl(url) {
+  if (url.protocol !== "file:") {
+    return Effect2.fail(new BadArgument({
+      module: "Path",
+      method: "fromFileUrl",
+      description: "URL must be of scheme file"
+    }));
+  } else if (url.hostname !== "") {
+    return Effect2.fail(new BadArgument({
+      module: "Path",
+      method: "fromFileUrl",
+      description: "Invalid file URL host"
+    }));
+  }
+  const pathname = url.pathname;
+  for (let n = 0;n < pathname.length; n++) {
+    if (pathname[n] === "%") {
+      const third = pathname.codePointAt(n + 2) | 32;
+      if (pathname[n + 1] === "2" && third === 102) {
+        return Effect2.fail(new BadArgument({
+          module: "Path",
+          method: "fromFileUrl",
+          description: "must not include encoded / characters"
+        }));
+      }
+    }
+  }
+  return Effect2.succeed(decodeURIComponent(pathname));
+}
+var resolve = function resolve2() {
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  let cwd = undefined;
+  for (let i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    let path;
+    if (i >= 0) {
+      path = arguments[i];
+    } else {
+      const process = globalThis.process;
+      if (cwd === undefined && "process" in globalThis && typeof process === "object" && process !== null && typeof process.cwd === "function") {
+        cwd = process.cwd();
+      }
+      path = cwd;
+    }
+    if (path.length === 0) {
+      continue;
+    }
+    resolvedPath = path + "/" + resolvedPath;
+    resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute) {
+    if (resolvedPath.length > 0) {
+      return "/" + resolvedPath;
+    } else {
+      return "/";
+    }
+  } else if (resolvedPath.length > 0) {
+    return resolvedPath;
+  } else {
+    return ".";
+  }
+};
+var CHAR_FORWARD_SLASH = 47;
+function toFileUrl(filepath) {
+  const outURL = new URL("file://");
+  let resolved = resolve(filepath);
+  const filePathLast = filepath.charCodeAt(filepath.length - 1);
+  if (filePathLast === CHAR_FORWARD_SLASH && resolved[resolved.length - 1] !== "/") {
+    resolved += "/";
+  }
+  outURL.pathname = encodePathChars(resolved);
+  return Effect2.succeed(outURL);
+}
+var percentRegEx = /%/g;
+var backslashRegEx = /\\/g;
+var newlineRegEx = /\n/g;
+var carriageReturnRegEx = /\r/g;
+var tabRegEx = /\t/g;
+function encodePathChars(filepath) {
+  if (filepath.includes("%")) {
+    filepath = filepath.replace(percentRegEx, "%25");
+  }
+  if (filepath.includes("\\")) {
+    filepath = filepath.replace(backslashRegEx, "%5C");
+  }
+  if (filepath.includes(`
+`)) {
+    filepath = filepath.replace(newlineRegEx, "%0A");
+  }
+  if (filepath.includes("\r")) {
+    filepath = filepath.replace(carriageReturnRegEx, "%0D");
+  }
+  if (filepath.includes("\t")) {
+    filepath = filepath.replace(tabRegEx, "%09");
+  }
+  return filepath;
+}
+var posixImpl = /* @__PURE__ */ Path.of({
+  [TypeId2]: TypeId2,
+  resolve,
+  normalize(path) {
+    if (path.length === 0)
+      return ".";
+    const isAbsolute = path.charCodeAt(0) === 47;
+    const trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+    path = normalizeStringPosix(path, !isAbsolute);
+    if (path.length === 0 && !isAbsolute)
+      path = ".";
+    if (path.length > 0 && trailingSeparator)
+      path += "/";
+    if (isAbsolute)
+      return "/" + path;
+    return path;
+  },
+  isAbsolute(path) {
+    return path.length > 0 && path.charCodeAt(0) === 47;
+  },
+  join() {
+    if (arguments.length === 0) {
+      return ".";
+    }
+    let joined;
+    for (let i = 0;i < arguments.length; ++i) {
+      const arg = arguments[i];
+      if (arg.length > 0) {
+        if (joined === undefined) {
+          joined = arg;
+        } else {
+          joined += "/" + arg;
+        }
+      }
+    }
+    if (joined === undefined) {
+      return ".";
+    }
+    return posixImpl.normalize(joined);
+  },
+  relative(from, to) {
+    if (from === to)
+      return "";
+    from = posixImpl.resolve(from);
+    to = posixImpl.resolve(to);
+    if (from === to)
+      return "";
+    let fromStart = 1;
+    for (;fromStart < from.length; ++fromStart) {
+      if (from.charCodeAt(fromStart) !== 47) {
+        break;
+      }
+    }
+    const fromEnd = from.length;
+    const fromLen = fromEnd - fromStart;
+    let toStart = 1;
+    for (;toStart < to.length; ++toStart) {
+      if (to.charCodeAt(toStart) !== 47) {
+        break;
+      }
+    }
+    const toEnd = to.length;
+    const toLen = toEnd - toStart;
+    const length = fromLen < toLen ? fromLen : toLen;
+    let lastCommonSep = -1;
+    let i = 0;
+    for (;i <= length; ++i) {
+      if (i === length) {
+        if (toLen > length) {
+          if (to.charCodeAt(toStart + i) === 47) {
+            return to.slice(toStart + i + 1);
+          } else if (i === 0) {
+            return to.slice(toStart + i);
+          }
+        } else if (fromLen > length) {
+          if (from.charCodeAt(fromStart + i) === 47) {
+            lastCommonSep = i;
+          } else if (i === 0) {
+            lastCommonSep = 0;
+          }
+        }
+        break;
+      }
+      const fromCode = from.charCodeAt(fromStart + i);
+      const toCode = to.charCodeAt(toStart + i);
+      if (fromCode !== toCode) {
+        break;
+      } else if (fromCode === 47) {
+        lastCommonSep = i;
+      }
+    }
+    let out = "";
+    for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i) {
+      if (i === fromEnd || from.charCodeAt(i) === 47) {
+        if (out.length === 0) {
+          out += "..";
+        } else {
+          out += "/..";
+        }
+      }
+    }
+    if (out.length > 0) {
+      return out + to.slice(toStart + lastCommonSep);
+    } else {
+      toStart += lastCommonSep;
+      if (to.charCodeAt(toStart) === 47) {
+        ++toStart;
+      }
+      return to.slice(toStart);
+    }
+  },
+  dirname(path) {
+    if (path.length === 0)
+      return ".";
+    let code = path.charCodeAt(0);
+    const hasRoot = code === 47;
+    let end = -1;
+    let matchedSlash = true;
+    for (let i = path.length - 1;i >= 1; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          end = i;
+          break;
+        }
+      } else {
+        matchedSlash = false;
+      }
+    }
+    if (end === -1)
+      return hasRoot ? "/" : ".";
+    if (hasRoot && end === 1)
+      return "//";
+    return path.slice(0, end);
+  },
+  basename(path, ext) {
+    let start = 0;
+    let end = -1;
+    let matchedSlash = true;
+    let i;
+    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+      if (ext.length === path.length && ext === path)
+        return "";
+      let extIdx = ext.length - 1;
+      let firstNonSlashEnd = -1;
+      for (i = path.length - 1;i >= 0; --i) {
+        const code = path.charCodeAt(i);
+        if (code === 47) {
+          if (!matchedSlash) {
+            start = i + 1;
+            break;
+          }
+        } else {
+          if (firstNonSlashEnd === -1) {
+            matchedSlash = false;
+            firstNonSlashEnd = i + 1;
+          }
+          if (extIdx >= 0) {
+            if (code === ext.charCodeAt(extIdx)) {
+              if (--extIdx === -1) {
+                end = i;
+              }
+            } else {
+              extIdx = -1;
+              end = firstNonSlashEnd;
+            }
+          }
+        }
+      }
+      if (start === end)
+        end = firstNonSlashEnd;
+      else if (end === -1)
+        end = path.length;
+      return path.slice(start, end);
+    } else {
+      for (i = path.length - 1;i >= 0; --i) {
+        if (path.charCodeAt(i) === 47) {
+          if (!matchedSlash) {
+            start = i + 1;
+            break;
+          }
+        } else if (end === -1) {
+          matchedSlash = false;
+          end = i + 1;
+        }
+      }
+      if (end === -1)
+        return "";
+      return path.slice(start, end);
+    }
+  },
+  extname(path) {
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    let preDotState = 0;
+    for (let i = path.length - 1;i >= 0; --i) {
+      const code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          startPart = i + 1;
+          break;
+        }
+        continue;
+      }
+      if (end === -1) {
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46) {
+        if (startDot === -1) {
+          startDot = i;
+        } else if (preDotState !== 1) {
+          preDotState = 1;
+        }
+      } else if (startDot !== -1) {
+        preDotState = -1;
+      }
+    }
+    if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      return "";
+    }
+    return path.slice(startDot, end);
+  },
+  format: function format(pathObject) {
+    if (pathObject === null || typeof pathObject !== "object") {
+      throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+    }
+    return _format("/", pathObject);
+  },
+  parse(path) {
+    const ret = {
+      root: "",
+      dir: "",
+      base: "",
+      ext: "",
+      name: ""
+    };
+    if (path.length === 0)
+      return ret;
+    let code = path.charCodeAt(0);
+    const isAbsolute = code === 47;
+    let start;
+    if (isAbsolute) {
+      ret.root = "/";
+      start = 1;
+    } else {
+      start = 0;
+    }
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    let i = path.length - 1;
+    let preDotState = 0;
+    for (;i >= start; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          startPart = i + 1;
+          break;
+        }
+        continue;
+      }
+      if (end === -1) {
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46) {
+        if (startDot === -1)
+          startDot = i;
+        else if (preDotState !== 1)
+          preDotState = 1;
+      } else if (startDot !== -1) {
+        preDotState = -1;
+      }
+    }
+    if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      if (end !== -1) {
+        if (startPart === 0 && isAbsolute)
+          ret.base = ret.name = path.slice(1, end);
+        else
+          ret.base = ret.name = path.slice(startPart, end);
+      }
+    } else {
+      if (startPart === 0 && isAbsolute) {
+        ret.name = path.slice(1, startDot);
+        ret.base = path.slice(1, end);
+      } else {
+        ret.name = path.slice(startPart, startDot);
+        ret.base = path.slice(startPart, end);
+      }
+      ret.ext = path.slice(startDot, end);
+    }
+    if (startPart > 0)
+      ret.dir = path.slice(0, startPart - 1);
+    else if (isAbsolute)
+      ret.dir = "/";
+    return ret;
+  },
+  sep: "/",
+  fromFileUrl,
+  toFileUrl,
+  toNamespacedPath: identity2
+});
+var layer = /* @__PURE__ */ Layer2.succeed(Path, posixImpl);
+
+// node_modules/@effect/platform/dist/esm/Path.js
+var TypeId3 = TypeId2;
+var Path2 = Path;
+var layer2 = layer;
 // src/fsGenerator.ts
-import { Effect as Effect2 } from "effect";
-import path from "node:path";
-import fs from "node:fs";
+import { Effect as Effect4 } from "effect";
 
 // src/fsNormalizator.ts
-import { resolve, relative, sep } from "node:path";
-import { Effect } from "effect";
+import { Effect as Effect3 } from "effect";
 
 // src/_commonErrors.ts
 class PathTraversalError {
@@ -31,42 +797,44 @@ class FsError {
 }
 
 // src/fsNormalizator.ts
-var resolveProjectPathToBase = (projectPath, basePath) => {
-  const filePath = projectPath.startsWith(sep) ? `.${projectPath}` : projectPath;
-  const absolute = resolve(basePath, filePath);
-  const rel = relative(basePath, absolute);
+var resolveProjectPathToBase = (projectPath, basePath) => Effect3.gen(function* () {
+  const path = yield* exports_Path.Path;
+  const filePath = projectPath.startsWith(path.sep) ? `.${projectPath}` : projectPath;
+  const absolute = path.resolve(basePath, filePath);
+  const rel = path.relative(basePath, absolute);
   if (rel.startsWith("..")) {
-    return Effect.fail(new PathTraversalError(["project:", projectPath, "base:", basePath].join(" ")));
+    return yield* Effect3.fail(new PathTraversalError(["project:", projectPath, "base:", basePath].join(" ")));
   }
-  return Effect.succeed(absolute);
-};
+  return absolute;
+});
 
 // src/fsGenerator.ts
-var fileStructureCreator = (items, basePath) => Effect2.gen(function* (_) {
-  yield* _(Effect2.logInfo(`Creating structure in: ${basePath}`));
+var fileStructureCreator = (items, basePath) => Effect4.gen(function* () {
+  const fs = yield* exports_FileSystem.FileSystem;
+  const path = yield* exports_Path.Path;
+  yield* Effect4.logInfo(`Creating structure in: ${basePath}`);
   for (const item of items) {
-    const fullPath = yield* _(resolveProjectPathToBase(item.path, basePath));
-    if (item.isFile) {
-      const dir = path.dirname(fullPath);
-      yield* _(Effect2.try({
-        try: () => fs.mkdirSync(dir, { recursive: true }),
-        catch: (error) => new FsError(`Failed to create directory ${dir}: ${String(error)}`)
-      }));
-      yield* _(Effect2.try({
-        try: () => fs.writeFileSync(fullPath, ""),
-        catch: (error) => new FsError(`Failed to create file ${fullPath}: ${String(error)}`)
-      }));
-      yield* _(Effect2.logInfo(`  Created file:      ${item.path}`));
-    } else {
-      yield* _(Effect2.try({
-        try: () => fs.mkdirSync(fullPath, { recursive: true }),
-        catch: (error) => new FsError(`Failed to create directory ${fullPath}: ${String(error)}`)
-      }));
-      yield* _(Effect2.logInfo(`  Created directory: ${item.path}`));
+    const fullPath = yield* resolveProjectPathToBase(item.path, basePath);
+    const dir = path.dirname(fullPath);
+    switch (item.type) {
+      case "file":
+        yield* fs.makeDirectory(dir, { recursive: true });
+        yield* fs.writeFile(fullPath, new Uint8Array);
+        yield* Effect4.logInfo(`  Created file:      ${item.path}`);
+        break;
+      case "symlink":
+        yield* fs.makeDirectory(dir, { recursive: true });
+        yield* fs.symlink(item.target, fullPath);
+        yield* Effect4.logInfo(`  Created symlink:   ${item.path} -> ${item.target}`);
+        break;
+      case "folder":
+        yield* fs.makeDirectory(fullPath, { recursive: true });
+        yield* Effect4.logInfo(`  Created directory: ${item.path}`);
+        break;
     }
   }
-  yield* _(Effect2.logInfo(`
-✓ Structure created successfully!`));
+  yield* Effect4.logInfo(`
+✓ Structure created successfully!`);
 });
 // src/parser.ts
 var parserFolderStructure = (treeString) => {
@@ -79,38 +847,50 @@ var parserFolderStructure = (treeString) => {
   for (const line of lines) {
     const [p01 = "", _comment01] = line.split("#");
     const [p02 = "", _comment02] = p01.split("//");
-    const p03 = p02.replace(/[│├└─\t]/g, " ");
-    const cleanLine = p03.trim().replace(/^\.\//, "");
+    const [p03a = "", _comment03] = p02.split("<-");
+    const [p03b = "", _comment04] = p03a.split("←");
+    const p04 = p03b.replace(/[│├└─\t]/g, " ");
+    const cleanLine = p04.trim().replace(/^\.\//, "");
     if (!cleanLine)
       continue;
     if (cleanLine === "/")
       continue;
     if (cleanLine.endsWith("../"))
       continue;
-    const indent = countLeadingSpaces(p03);
+    const indent = countLeadingSpaces(p04);
     indentSize = indentSize === 0 && indent > 0 ? indent : indentSize;
     const level = indentSize === 0 ? 0 : indent / indentSize;
     if (previousIndentLevel >= level) {
       pathStack.splice(level, pathStack.length - level);
     }
     previousIndentLevel = level;
-    const isFile = !cleanLine.endsWith("/");
+    const arrowIndex = cleanLine.indexOf("->");
+    if (arrowIndex !== -1) {
+      const linkName = cleanLine.slice(0, arrowIndex).trim();
+      const target = cleanLine.slice(arrowIndex + 2).trim();
+      if (!linkName || !target)
+        continue;
+      const nameParts = linkName.split("/").filter(Boolean);
+      pathStack.push(nameParts);
+      const path2 = pathStack.flat().join("/");
+      pathStack.pop();
+      result.push({ type: "symlink", path: path2, target });
+      continue;
+    }
+    const isFolder = cleanLine.endsWith("/");
     const name = cleanLine.split("/").filter(Boolean);
     pathStack.push(name);
-    const path2 = pathStack.flat().join("/");
-    result.push({
-      path: path2,
-      isFile
-    });
-    if (isFile) {
+    const path = pathStack.flat().join("/");
+    result.push(isFolder ? { type: "folder", path } : { type: "file", path });
+    if (!isFolder) {
       pathStack.pop();
     }
   }
   return result;
 };
 function countLeadingSpaces(str) {
-  const match = str.match(/^[\s]*/);
-  return match ? match[0].length : 0;
+  const match2 = str.match(/^[\s]*/);
+  return match2 ? match2[0].length : 0;
 }
 export {
   resolveProjectPathToBase,