effect 4.0.6 → 4.1.0

package/dist/internal/equal.js

@@ -23,4 +23,18 @@ export const getAllObjectKeys = obj => {
 export const byReferenceInstances = /*#__PURE__*/new WeakSet();
 /** @internal */
 export const viewBytes = view => new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+/** @internal */
+export const isArrayBufferLike = u => u instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && u instanceof SharedArrayBuffer;
+/**
+ * Returns `undefined` for detached buffers, which can no longer be read.
+ *
+ * @internal
+ */
+export const bufferBytes = buffer => {
+  try {
+    return new Uint8Array(buffer);
+  } catch {
+    return undefined;
+  }
+};
 //# sourceMappingURL=equal.js.map

package/dist/internal/equal.js.map

@@ -1 +1 @@
-{"version":3,"file":"equal.js","names":[],"sources":["../../src/internal/equal.ts"],"sourcesContent":[null],"mappings":"AAAA;AACA,OAAO,MAAM,gBAAgB,GAAI,GAAW,IAAsB;EAChE,MAAM,IAAI,GAAG,IAAI,GAAG,CAAc,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;EACvD,IAAI,GAAG,CAAC,WAAW,KAAK,MAAM,EAAE,OAAO,IAAI;EAE3C,IAAI,GAAG,YAAY,KAAK,EAAE;IACxB,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;EACtB;EAEA,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC;EACxC,IAAI,OAAO,GAAG,KAAK;EAEnB,OAAO,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,MAAM,CAAC,SAAS,EAAE;IACvD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC;IACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;MACvC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACtB;IACA,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC;EAC1C;EACA,IAAI,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,OAAO,GAAG,CAAC,WAAW,KAAK,UAAU,IAAI,KAAK,KAAK,GAAG,CAAC,WAAW,CAAC,SAAS,EAAE;IAC3G,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC;EAC5B;EAEA,OAAO,IAAI;AACb,CAAC;AAED;AACA,OAAO,MAAM,oBAAoB,gBAAG,IAAI,OAAO,EAAU;AAEzD;AACA,OAAO,MAAM,SAAS,GAAI,IAAc,IAAiB,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC","ignoreList":[]}
+{"version":3,"file":"equal.js","names":[],"sources":["../../src/internal/equal.ts"],"sourcesContent":[null],"mappings":"AAAA;AACA,OAAO,MAAM,gBAAgB,GAAI,GAAW,IAAsB;EAChE,MAAM,IAAI,GAAG,IAAI,GAAG,CAAc,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;EACvD,IAAI,GAAG,CAAC,WAAW,KAAK,MAAM,EAAE,OAAO,IAAI;EAE3C,IAAI,GAAG,YAAY,KAAK,EAAE;IACxB,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;EACtB;EAEA,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC;EACxC,IAAI,OAAO,GAAG,KAAK;EAEnB,OAAO,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,MAAM,CAAC,SAAS,EAAE;IACvD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC;IACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;MACvC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACtB;IACA,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC;EAC1C;EACA,IAAI,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,OAAO,GAAG,CAAC,WAAW,KAAK,UAAU,IAAI,KAAK,KAAK,GAAG,CAAC,WAAW,CAAC,SAAS,EAAE;IAC3G,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC;EAC5B;EAEA,OAAO,IAAI;AACb,CAAC;AAED;AACA,OAAO,MAAM,oBAAoB,gBAAG,IAAI,OAAO,EAAU;AAEzD;AACA,OAAO,MAAM,SAAS,GAAI,IAAc,IAAiB,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC;AAEtH;AACA,OAAO,MAAM,iBAAiB,GAAI,CAAU,IAC1C,CAAC,YAAY,WAAW,IAAK,OAAO,iBAAiB,KAAK,WAAW,IAAI,CAAC,YAAY,iBAAkB;AAE1G;;;;;AAKA,OAAO,MAAM,WAAW,GAAI,MAAuB,IAA4B;EAC7E,IAAI;IACF,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC;EAC/B,CAAC,CAAC,MAAM;IACN,OAAO,SAAS;EAClB;AACF,CAAC","ignoreList":[]}

package/dist/internal/glob.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=glob.d.ts.map

package/dist/internal/glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../src/internal/glob.ts"],"names":[],"mappings":""}

package/dist/internal/glob.js

@@ -0,0 +1,630 @@
+import * as Arr from "../Array.js";
+import * as Effect from "../Effect.js";
+import * as Order from "../Order.js";
+import * as Predicate from "../Predicate.js";
+// -----------------------------------------------------------------------------
+// compilation
+// -----------------------------------------------------------------------------
+const maxExpansions = 10_000;
+const maxExpandedLength = 2 ** 22;
+const maxBraceDepth = 64;
+/** @internal */
+export const compile = (patterns, dot) => {
+  const nodes = [];
+  const starts = new Set();
+  for (const pattern of patterns) {
+    for (const expanded of expandBraces(pattern)) {
+      const start = nodes.length;
+      if (compilePattern(expanded, nodes)) {
+        starts.add(start);
+      }
+    }
+  }
+  return {
+    nodes,
+    initial: closure(nodes, starts),
+    dot
+  };
+};
+// Reject UNC paths rather than collapsing them into local absolute paths.
+const isUnc = path => path.startsWith("//") && path[2] !== undefined && path[2] !== "/";
+// Appends the pattern's nodes, or appends nothing when it can match no path
+const compilePattern = (pattern, nodes) => {
+  if (pattern === "" || isUnc(pattern)) {
+    return false;
+  }
+  const raw = splitSegments(pattern);
+  const globstar = raw.indexOf("**");
+  if (globstar !== -1 && raw.some((segment, i) => i > globstar && (segment === "." || segment === ".."))) {
+    return false;
+  }
+  const {
+    directory,
+    segments
+  } = normalize(raw);
+  if (segments.length === 0) {
+    return false;
+  }
+  for (const segment of segments) {
+    if (segment !== "**") {
+      nodes.push(compileSegment(Array.from(segment)));
+    } else if (nodes[nodes.length - 1] !== globstarNode) {
+      nodes.push(globstarNode);
+    }
+  }
+  nodes.push({
+    _tag: "End",
+    directoryOnly: directory
+  });
+  return true;
+};
+const globstarNode = {
+  _tag: "Globstar"
+};
+const splitSegments = pattern => {
+  const segments = [];
+  let start = 0;
+  for (let i = 0; i < pattern.length; i++) {
+    if (pattern[i] === "\\") {
+      i++;
+    } else if (pattern[i] === "/") {
+      segments.push(pattern.slice(start, i));
+      start = i + 1;
+    }
+  }
+  segments.push(pattern.slice(start));
+  return segments;
+};
+const drive = /^[A-Za-z]:/;
+const isDrive = segment => segment.length === 2 && drive.test(segment);
+// the root of an absolute path: `""` or a drive such as `C:/`
+const isRoot = name => name === "" || name.length === 3 && name[2] === "/" && drive.test(name);
+const isAbsolute = path => path.startsWith("/") || path[2] === "/" && drive.test(path);
+// Preserve absolute roots and a lone `.`; trailing `/` or `/.` marks a directory.
+const normalize = raw => {
+  const segments = [];
+  let i = 0;
+  if (raw.length > 1 && (raw[0] === "" || isDrive(raw[0]))) {
+    segments.push(raw[0] === "" ? "" : `${raw[0]}/`);
+    i = 1;
+  }
+  let directory = false;
+  for (; i < raw.length; i++) {
+    const segment = raw[i];
+    if (segment === "" || segment === ".") {
+      directory = i === raw.length - 1 && segments.length > 0;
+    } else {
+      segments.push(segment);
+      directory = false;
+    }
+  }
+  if (segments.length === 0 && raw.includes(".")) {
+    segments.push(".");
+  }
+  return {
+    segments,
+    directory
+  };
+};
+const compileSegment = chars => {
+  const tokens = [];
+  let literal = "";
+  let magic = false;
+  // once a class fails to close, every later `[` in the segment is literal
+  let classes = true;
+  for (let i = 0; i < chars.length; i++) {
+    const char = chars[i];
+    if (char === "\\" && i + 1 < chars.length) {
+      literal += chars[++i];
+      tokens.push({
+        _tag: "Char",
+        value: chars[i]
+      });
+    } else if (char === "*") {
+      magic = true;
+      if (tokens[tokens.length - 1]?._tag !== "Star") {
+        tokens.push({
+          _tag: "Star"
+        });
+      }
+    } else if (char === "?") {
+      magic = true;
+      tokens.push({
+        _tag: "Any"
+      });
+    } else if (char === "[" && classes) {
+      const parsed = parseClass(chars, i);
+      if (parsed === undefined) {
+        classes = false;
+        literal += char;
+        tokens.push({
+          _tag: "Char",
+          value: char
+        });
+      } else {
+        magic = true;
+        tokens.push(parsed.token);
+        i = parsed.end;
+      }
+    } else {
+      literal += char;
+      tokens.push({
+        _tag: "Char",
+        value: char
+      });
+    }
+  }
+  if (!magic) {
+    return {
+      _tag: "Literal",
+      value: literal
+    };
+  }
+  const first = tokens[0];
+  return {
+    _tag: "Wildcard",
+    tokens,
+    leadingDot: first._tag === "Char" && first.value === "."
+  };
+};
+const range = (from, to) => [from.codePointAt(0), to.codePointAt(0)];
+const posixClasses = {
+  alnum: [... /*#__PURE__*/range("0", "9"), ... /*#__PURE__*/range("A", "Z"), ... /*#__PURE__*/range("a", "z")],
+  alpha: [... /*#__PURE__*/range("A", "Z"), ... /*#__PURE__*/range("a", "z")],
+  blank: [0x09, 0x09, 0x20, 0x20],
+  cntrl: [0x00, 0x1f, 0x7f, 0x7f],
+  digit: /*#__PURE__*/range("0", "9"),
+  graph: [0x21, 0x7e],
+  lower: /*#__PURE__*/range("a", "z"),
+  print: [0x20, 0x7e],
+  punct: [0x21, 0x2f, 0x3a, 0x40, 0x5b, 0x60, 0x7b, 0x7e],
+  space: [0x09, 0x0d, 0x20, 0x20],
+  upper: /*#__PURE__*/range("A", "Z"),
+  word: [... /*#__PURE__*/range("0", "9"), ... /*#__PURE__*/range("A", "Z"), 0x5f, 0x5f, ... /*#__PURE__*/range("a", "z")],
+  xdigit: [... /*#__PURE__*/range("0", "9"), ... /*#__PURE__*/range("A", "F"), ... /*#__PURE__*/range("a", "f")]
+};
+// POSIX class names are at most six characters.
+const parsePosixClass = (chars, open) => {
+  for (let i = open + 2; i < chars.length && i <= open + 8; i++) {
+    if (chars[i] === ":" && chars[i + 1] === "]") {
+      const ranges = posixClasses[chars.slice(open + 2, i).join("")];
+      return ranges === undefined ? undefined : {
+        ranges,
+        end: i + 1
+      };
+    }
+  }
+  return undefined;
+};
+// Share class boundaries between brace expansion and segment compilation.
+const parseClass = (chars, open) => {
+  let i = open + 1;
+  const negated = chars[i] === "!" || chars[i] === "^";
+  if (negated) {
+    i++;
+  }
+  const ranges = [];
+  for (let first = true; i < chars.length; i++, first = false) {
+    let char = chars[i];
+    if (char === "/") {
+      return undefined;
+    }
+    if (char === "]" && !first) {
+      return {
+        token: {
+          _tag: "Class",
+          ranges,
+          negated
+        },
+        end: i
+      };
+    }
+    if (char === "[" && chars[i + 1] === ":") {
+      const posix = parsePosixClass(chars, i);
+      if (posix !== undefined) {
+        ranges.push(...posix.ranges);
+        i = posix.end;
+        continue;
+      }
+    }
+    if (char === "\\" && i + 1 < chars.length) {
+      char = chars[++i];
+    }
+    if (chars[i + 1] === "-" && i + 2 < chars.length && chars[i + 2] !== "]") {
+      let next = i + 2;
+      if (chars[next] === "/") {
+        return undefined;
+      }
+      if (chars[next] === "\\" && next + 1 < chars.length) {
+        next++;
+      }
+      ranges.push(...range(char, chars[next]));
+      i = next;
+      continue;
+    }
+    ranges.push(...range(char, char));
+  }
+  return undefined;
+};
+const expandBraces = pattern => {
+  const chars = Array.from(pattern);
+  const groups = matchBraceGroups(chars);
+  if (groups.size === 0) {
+    return [pattern];
+  }
+  const sequence = parseBraceSequence(chars, 0, chars.length, groups, 0);
+  if (sequence === undefined) {
+    return [pattern];
+  }
+  const count = countExpansions(sequence);
+  return count > maxExpansions || count * pattern.length > maxExpandedLength ? [pattern] : expandSequence(sequence);
+};
+// Index expandable brace groups by opening position, ignoring bracket classes.
+const matchBraceGroups = chars => {
+  const groups = new Map();
+  const stack = [];
+  let classes = true;
+  for (let i = 0; i < chars.length; i++) {
+    const char = chars[i];
+    if (char === "\\") {
+      i++;
+    } else if (char === "/") {
+      classes = true;
+    } else if (char === "[" && classes) {
+      const parsed = parseClass(chars, i);
+      if (parsed === undefined) {
+        classes = false;
+      } else {
+        i = parsed.end;
+      }
+    } else if (char === "{") {
+      stack.push({
+        open: i,
+        commas: []
+      });
+    } else if (char === ",") {
+      stack[stack.length - 1]?.commas.push(i);
+    } else if (char === "}") {
+      const group = stack.pop();
+      if (group !== undefined && group.commas.length > 0) {
+        groups.set(group.open, {
+          commas: group.commas,
+          close: i
+        });
+      }
+    }
+  }
+  return groups;
+};
+const parseBraceSequence = (chars, start, end, groups, depth) => {
+  if (depth > maxBraceDepth) {
+    return undefined;
+  }
+  const parts = [];
+  let text = "";
+  for (let i = start; i < end; i++) {
+    const group = groups.get(i);
+    if (group === undefined) {
+      if (chars[i] === "\\" && i + 1 < end) {
+        text += chars[i++];
+      }
+      text += chars[i];
+      continue;
+    }
+    const alternatives = [];
+    let from = i + 1;
+    for (const to of [...group.commas, group.close]) {
+      const alternative = parseBraceSequence(chars, from, to, groups, depth + 1);
+      if (alternative === undefined) {
+        return undefined;
+      }
+      alternatives.push(alternative);
+      from = to + 1;
+    }
+    if (text !== "") {
+      parts.push(text);
+      text = "";
+    }
+    parts.push(alternatives);
+    i = group.close;
+  }
+  if (text !== "") {
+    parts.push(text);
+  }
+  return parts;
+};
+const countExpansions = sequence => {
+  let count = 1;
+  for (const part of sequence) {
+    if (typeof part !== "string") {
+      let sum = 0;
+      for (const alternative of part) {
+        sum += countExpansions(alternative);
+      }
+      count *= sum;
+      if (count > maxExpansions) {
+        return Infinity;
+      }
+    }
+  }
+  return count;
+};
+const expandSequence = sequence => {
+  let out = [""];
+  for (const part of sequence) {
+    if (typeof part === "string") {
+      out = out.map(prefix => prefix + part);
+    } else {
+      const alternatives = part.flatMap(expandSequence);
+      out = out.flatMap(prefix => alternatives.map(alternative => prefix + alternative));
+    }
+  }
+  return out;
+};
+// -----------------------------------------------------------------------------
+// matching
+// -----------------------------------------------------------------------------
+const matchToken = (token, char) => {
+  switch (token._tag) {
+    case "Char":
+      return token.value === char;
+    case "Any":
+      return true;
+    case "Star":
+      return false;
+    case "Class":
+      {
+        const code = char.codePointAt(0);
+        let found = false;
+        for (let i = 0; i < token.ranges.length && !found; i += 2) {
+          found = code >= token.ranges[i] && code <= token.ranges[i + 1];
+        }
+        return found !== token.negated;
+      }
+  }
+};
+// Backtrack only to the last `*`, bounding retries by tokens × characters.
+const matchWildcard = (node, name, chars, dot) => {
+  if (name === "." || name === ".." || name.startsWith(".") && !dot && !node.leadingDot) {
+    return false;
+  }
+  const {
+    tokens
+  } = node;
+  let t = 0;
+  let c = 0;
+  let star = -1;
+  let resume = 0;
+  while (c < chars.length) {
+    if (tokens[t]?._tag === "Star") {
+      star = t++;
+      resume = c;
+    } else if (t < tokens.length && matchToken(tokens[t], chars[c])) {
+      t++;
+      c++;
+    } else if (star !== -1) {
+      t = star + 1;
+      c = ++resume;
+    } else {
+      return false;
+    }
+  }
+  while (tokens[t]?._tag === "Star") {
+    t++;
+  }
+  return t === tokens.length;
+};
+// `**` also matches zero segments, so its successor is reachable too
+const closure = (nodes, states) => {
+  for (const state of states) {
+    if (nodes[state]._tag === "Globstar") {
+      states.add(state + 1);
+    }
+  }
+  return states;
+};
+const step = (compiled, states, name) => {
+  const explicit = new Set();
+  const viaGlobstar = new Set();
+  // only a literal segment can name the root of an absolute path
+  const root = isRoot(name);
+  let chars;
+  for (const state of states) {
+    const node = compiled.nodes[state];
+    switch (node._tag) {
+      case "Globstar":
+        {
+          if (!root && name !== "." && name !== ".." && (compiled.dot || !name.startsWith("."))) {
+            viaGlobstar.add(state);
+          }
+          break;
+        }
+      case "Literal":
+        {
+          if (node.value === name) {
+            explicit.add(state + 1);
+          }
+          break;
+        }
+      case "Wildcard":
+        {
+          if (!root && matchWildcard(node, name, chars ??= Array.from(name), compiled.dot)) {
+            explicit.add(state + 1);
+          }
+          break;
+        }
+    }
+  }
+  return {
+    explicit: closure(compiled.nodes, explicit),
+    globstar: closure(compiled.nodes, viaGlobstar)
+  };
+};
+const union = step => {
+  if (step.globstar.size === 0) {
+    return step.explicit;
+  }
+  const states = new Set(step.explicit);
+  for (const state of step.globstar) {
+    states.add(state);
+  }
+  return states;
+};
+const accepts = (compiled, states, isDirectory) => {
+  for (const state of states) {
+    const node = compiled.nodes[state];
+    if (node._tag === "End" && (isDirectory || !node.directoryOnly)) {
+      return true;
+    }
+  }
+  return false;
+};
+const canDescend = (compiled, states) => {
+  for (const state of states) {
+    if (compiled.nodes[state]._tag !== "End") {
+      return true;
+    }
+  }
+  return false;
+};
+const needsDirectory = (compiled, states) => {
+  for (const state of states) {
+    const node = compiled.nodes[state];
+    if (node._tag === "End" && node.directoryOnly) {
+      return true;
+    }
+  }
+  return false;
+};
+/** @internal */
+export const match = (compiled, path) => {
+  if (path === "" || isUnc(path)) {
+    return false;
+  }
+  const {
+    directory,
+    segments
+  } = normalize(path.split("/"));
+  let states = compiled.initial;
+  for (const name of segments) {
+    states = union(step(compiled, states, name));
+    if (states.size === 0) {
+      return false;
+    }
+  }
+  return accepts(compiled, states, directory);
+};
+// -----------------------------------------------------------------------------
+// file system walk
+// -----------------------------------------------------------------------------
+const join = (parent, name) => {
+  if (parent === "") {
+    return name === "" ? "/" : name;
+  }
+  return parent.endsWith("/") ? parent + name : `${parent}/${name}`;
+};
+const isMissing = error => error.reason._tag === "NotFound" || error.reason._tag === "BadResource";
+const isIgnorable = error => isMissing(error) || error.reason._tag === "PermissionDenied";
+// Node and Deno report `readLink` on a path that is not a link as "Unknown"
+const isNotLink = error => isIgnorable(error) || error.reason._tag === "Unknown";
+const byName = /*#__PURE__*/Order.mapInput(Order.String, entry => entry.name);
+/** @internal */
+export const make = fs => (pattern, options) => walk(fs, compile([pattern], options?.dot ?? false), options);
+// Named directories (the root and those reached only through leading literal
+// segments) must be readable; unreadable wildcard-reached ones are skipped.
+const walk = /*#__PURE__*/Effect.fnUntraced(function* (fs, compiled, options) {
+  if (compiled.initial.size === 0) {
+    return [];
+  }
+  const root = options?.root ?? "";
+  const excludes = compile(options?.exclude ?? [], true);
+  const excludeNeedsDirectory = excludes.nodes.some(node => node._tag === "End" && node.directoryOnly);
+  const toFsPath = relative => isAbsolute(relative) ? relative : relative === "" ? root === "" ? "." : root : join(root, relative);
+  // Listings never contain `.`, `..`, or the root of an absolute pattern
+  const isUnlisted = value => value === "." || value === ".." || isRoot(value);
+  // Keep broken links so literal probes agree with directory listings.
+  const probe = (parent, name, named) => {
+    const path = toFsPath(join(parent, name));
+    return fs.stat(path).pipe(Effect.map(info => info.type), Effect.catchReason("PlatformError", "NotFound", () => fs.readLink(path).pipe(Effect.as("SymbolicLink"), Effect.catchIf(isNotLink, () => Effect.succeed(undefined)))), Effect.catchIf(named ? isMissing : isIgnorable, () => Effect.succeed(undefined)), Effect.map(type => type === undefined ? undefined : {
+      name,
+      type
+    }));
+  };
+  // Probe leading literals without requiring permission to list their parent.
+  const entries = (relative, states, named) => {
+    const literals = new Set();
+    let listed = !named;
+    for (const state of states) {
+      const node = compiled.nodes[state];
+      if (node._tag === "Literal") {
+        literals.add(node.value);
+      } else if (node._tag !== "End") {
+        listed = true;
+      }
+    }
+    const probed = listed ? [...literals].filter(isUnlisted) : [...literals];
+    return Effect.zipWith(listed ? Effect.catchIf(fs.readDirectoryEntries(toFsPath(relative)), named ? isMissing : isIgnorable, () => Effect.succeed([])) : Effect.succeed([]), Effect.forEach(probed, name => probe(relative, name, named), {
+      concurrency: 16
+    }), (listing, found) => ({
+      entries: Arr.sort([...listing, ...found.filter(Predicate.isNotUndefined)], byName),
+      named: named && !listed
+    }));
+  };
+  const visit = Effect.fnUntraced(function* ({
+    name,
+    type
+  }, parent, states, excluded) {
+    const result = step(compiled, states, name);
+    const next = union(result);
+    if (next.size === 0) {
+      return undefined;
+    }
+    const relative = join(parent, name);
+    const nextExcluded = union(step(excludes, excluded, name));
+    const descend = canDescend(compiled, next);
+    const isDirectory = !descend && !needsDirectory(compiled, next) && !excludeNeedsDirectory ? false : type !== "Unknown" && type !== "SymbolicLink" ? type === "Directory" : yield* fs.stat(toFsPath(relative)).pipe(Effect.map(info => info.type === "Directory"), Effect.catchIf(isIgnorable, () => Effect.succeed(false)));
+    const accepted = accepts(compiled, next, isDirectory);
+    if (!accepted && (!isDirectory || !descend) || accepts(excludes, nextExcluded, isDirectory)) {
+      return undefined;
+    }
+    const child = next => ({
+      relative,
+      accepted,
+      excluded: nextExcluded,
+      next
+    });
+    if (!isDirectory || !descend) {
+      return child(undefined);
+    }
+    if (result.globstar.size === 0) {
+      return child(next);
+    }
+    // Follow symlinks only through explicit segments, not `**`.
+    const followed = canDescend(compiled, result.explicit) ? result.explicit : undefined;
+    if (type !== "Unknown") {
+      return child(type === "SymbolicLink" ? followed : next);
+    }
+    return yield* fs.readLink(toFsPath(relative)).pipe(Effect.as(child(followed)), Effect.catchIf(isNotLink, () => Effect.succeed(child(next))));
+  });
+  const directory = Effect.fnUntraced(function* (relative, states, excluded, named, out) {
+    const listing = yield* entries(relative, states, named);
+    const children = yield* Effect.forEach(listing.entries, entry => visit(entry, relative, states, excluded), {
+      concurrency: 16
+    });
+    for (const child of children) {
+      if (child === undefined) {
+        continue;
+      }
+      if (child.accepted) {
+        out.push(child.relative);
+      }
+      if (child.next !== undefined) {
+        yield* directory(child.relative, child.next, child.excluded, listing.named, out);
+      }
+    }
+  });
+  const out = [];
+  yield* directory("", compiled.initial, excludes.initial, true, out);
+  return out;
+});
+//# sourceMappingURL=glob.js.map