@visulima/fs 2.3.5 → 2.3.7

package/dist/packem_shared/readJson-JrCHMN3m.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+const utils = require('@visulima/path/utils');
+const parseJson = require('./parseJson-DcUo4Rpt.cjs');
+const readFile = require('./readFile-iFUhZHnh.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function readJson(path, reviver, options) {
+  if (typeof reviver === "object") {
+    options = reviver;
+    reviver = undefined;
+  }
+  const content = await readFile(path, {
+    buffer: true,
+    encoding: undefined
+  });
+  let data = new TextDecoder().decode(content);
+  const { beforeParse, color } = options ?? {};
+  if (typeof beforeParse === "function") {
+    data = beforeParse(data);
+  }
+  return parseJson(data, reviver, utils.toPath(path), { color });
+}
+__name(readJson, "readJson");
+
+module.exports = readJson;

package/dist/packem_shared/readJsonSync-BPfxTuQL.mjs

@@ -0,0 +1,25 @@
+import { toPath } from '@visulima/path/utils';
+import parseJson from './parseJson-n9THWOFI.mjs';
+import readFileSync from './readFileSync-Cck96_o0.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function readJsonSync(path, reviver, options) {
+  if (typeof reviver === "object") {
+    options = reviver;
+    reviver = undefined;
+  }
+  const content = readFileSync(path, {
+    buffer: true,
+    encoding: undefined
+  });
+  let data = new TextDecoder().decode(content);
+  const { beforeParse, color } = options ?? {};
+  if (typeof beforeParse === "function") {
+    data = beforeParse(data);
+  }
+  return parseJson(data, reviver, toPath(path), { color });
+}
+__name(readJsonSync, "readJsonSync");
+
+export { readJsonSync as default };

package/dist/packem_shared/readJsonSync-o_MAOlUv.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+const utils = require('@visulima/path/utils');
+const parseJson = require('./parseJson-DcUo4Rpt.cjs');
+const readFileSync = require('./readFileSync-B3NTOR-W.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function readJsonSync(path, reviver, options) {
+  if (typeof reviver === "object") {
+    options = reviver;
+    reviver = undefined;
+  }
+  const content = readFileSync(path, {
+    buffer: true,
+    encoding: undefined
+  });
+  let data = new TextDecoder().decode(content);
+  const { beforeParse, color } = options ?? {};
+  if (typeof beforeParse === "function") {
+    data = beforeParse(data);
+  }
+  return parseJson(data, reviver, utils.toPath(path), { color });
+}
+__name(readJsonSync, "readJsonSync");
+
+module.exports = readJsonSync;

package/dist/packem_shared/readYaml-sR4bqUel.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+const yaml = require('yaml');
+const readFile = require('./readFile-iFUhZHnh.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function readYaml(path, reviver, options) {
+  const { buffer, compression, encoding = "utf8", flag, ...parseOptions } = options ?? {};
+  const content = await readFile(path, { buffer, compression, encoding, flag });
+  return typeof reviver === "function" ? yaml.parse(content, reviver, parseOptions) : yaml.parse(content, parseOptions);
+}
+__name(readYaml, "readYaml");
+
+module.exports = readYaml;

package/dist/packem_shared/readYaml-vVKK8ZzY.mjs

@@ -0,0 +1,13 @@
+import { parse } from 'yaml';
+import readFile from './readFile-DUM-xNoB.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function readYaml(path, reviver, options) {
+  const { buffer, compression, encoding = "utf8", flag, ...parseOptions } = options ?? {};
+  const content = await readFile(path, { buffer, compression, encoding, flag });
+  return typeof reviver === "function" ? parse(content, reviver, parseOptions) : parse(content, parseOptions);
+}
+__name(readYaml, "readYaml");
+
+export { readYaml as default };

package/dist/packem_shared/readYamlSync-C3oOzxiN.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+const yaml = require('yaml');
+const readFileSync = require('./readFileSync-B3NTOR-W.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function readYamlSync(path, reviver, options) {
+  const { buffer, compression, encoding = "utf8", flag, ...parseOptions } = options ?? {};
+  const content = readFileSync(path, { buffer, compression, encoding, flag });
+  return typeof reviver === "function" ? yaml.parse(content, reviver, parseOptions) : yaml.parse(content, parseOptions);
+}
+__name(readYamlSync, "readYamlSync");
+
+module.exports = readYamlSync;

package/dist/packem_shared/readYamlSync-MOLH4gXB.mjs

@@ -0,0 +1,13 @@
+import { parse } from 'yaml';
+import readFileSync from './readFileSync-Cck96_o0.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function readYamlSync(path, reviver, options) {
+  const { buffer, compression, encoding = "utf8", flag, ...parseOptions } = options ?? {};
+  const content = readFileSync(path, { buffer, compression, encoding, flag });
+  return typeof reviver === "function" ? parse(content, reviver, parseOptions) : parse(content, parseOptions);
+}
+__name(readYamlSync, "readYamlSync");
+
+export { readYamlSync as default };

package/dist/packem_shared/remove-B2nxUObP.mjs

@@ -0,0 +1,18 @@
+import { unlink, rm } from 'node:fs/promises';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const remove = /* @__PURE__ */ __name(async (path, options = {}) => {
+  assertValidFileOrDirectoryPath(path);
+  try {
+    await unlink(path);
+  } catch {
+  }
+  try {
+    await rm(path, { force: true, maxRetries: options?.maxRetries, recursive: true, retryDelay: options?.retryDelay });
+  } catch {
+  }
+}, "remove");
+
+export { remove as default };

package/dist/packem_shared/remove-BpDiVPns.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+const promises = require('node:fs/promises');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const remove = /* @__PURE__ */ __name(async (path, options = {}) => {
+  assertValidFileOrDirectoryPath(path);
+  try {
+    await promises.unlink(path);
+  } catch {
+  }
+  try {
+    await promises.rm(path, { force: true, maxRetries: options?.maxRetries, recursive: true, retryDelay: options?.retryDelay });
+  } catch {
+  }
+}, "remove");
+
+module.exports = remove;

package/dist/packem_shared/removeSync-BosXW624.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const removeSync = /* @__PURE__ */ __name((path, options = {}) => {
+  assertValidFileOrDirectoryPath(path);
+  try {
+    node_fs.unlinkSync(path);
+  } catch {
+  }
+  try {
+    node_fs.rmSync(path, { force: true, maxRetries: options?.maxRetries, recursive: true, retryDelay: options?.retryDelay });
+  } catch {
+  }
+}, "removeSync");
+
+module.exports = removeSync;

package/dist/packem_shared/removeSync-C87yepDI.mjs

@@ -0,0 +1,18 @@
+import { unlinkSync, rmSync } from 'node:fs';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const removeSync = /* @__PURE__ */ __name((path, options = {}) => {
+  assertValidFileOrDirectoryPath(path);
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+  try {
+    rmSync(path, { force: true, maxRetries: options?.maxRetries, recursive: true, retryDelay: options?.retryDelay });
+  } catch {
+  }
+}, "removeSync");
+
+export { removeSync as default };

package/dist/packem_shared/resolve-symlink-target-BbpEHdU2.mjs

@@ -0,0 +1,18 @@
+import { resolve, dirname } from '@visulima/path';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const resolveSymlinkTarget = /* @__PURE__ */ __name((target, linkName) => {
+  if (typeof target !== "string") {
+    return target;
+  }
+  if (target.startsWith("./")) {
+    return resolve(target);
+  }
+  if (typeof linkName === "string") {
+    return resolve(dirname(linkName), target);
+  }
+  return new URL(target, linkName);
+}, "resolveSymlinkTarget");
+
+export { resolveSymlinkTarget as r };

package/dist/packem_shared/resolve-symlink-target-DImIddt6.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+const path = require('@visulima/path');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const resolveSymlinkTarget = /* @__PURE__ */ __name((target, linkName) => {
+  if (typeof target !== "string") {
+    return target;
+  }
+  if (target.startsWith("./")) {
+    return path.resolve(target);
+  }
+  if (typeof linkName === "string") {
+    return path.resolve(path.dirname(linkName), target);
+  }
+  return new URL(target, linkName);
+}, "resolveSymlinkTarget");
+
+exports.resolveSymlinkTarget = resolveSymlinkTarget;

package/dist/packem_shared/stripJsonComments-B66nRaTZ.mjs

@@ -0,0 +1,21 @@
+import { INTERNAL_STRIP_JSON_REGEX } from './F_OK-JER1LjUr.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const stripJsonComments = /* @__PURE__ */ __name((jsonString, { whitespace = true } = {}) => (
+  // This regular expression translates to:
+  //
+  //   /quoted-string|line-comment|block-comment/g
+  //
+  // This means that comment characters inside of strings will match
+  // as strings, not comments, so we can just skip the whole string
+  // in the replacer function.
+  jsonString.replace(INTERNAL_STRIP_JSON_REGEX, (match) => {
+    if (match.startsWith('"') || match[1] === "*" && !match.endsWith("*/")) {
+      return match;
+    }
+    return whitespace ? match.replaceAll(/\S/g, " ") : "";
+  })
+), "stripJsonComments");
+
+export { stripJsonComments as default };

package/dist/packem_shared/stripJsonComments-eDrcJvBT.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+const F_OK = require('./F_OK-CWSqQIdF.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const stripJsonComments = /* @__PURE__ */ __name((jsonString, { whitespace = true } = {}) => (
+  // This regular expression translates to:
+  //
+  //   /quoted-string|line-comment|block-comment/g
+  //
+  // This means that comment characters inside of strings will match
+  // as strings, not comments, so we can just skip the whole string
+  // in the replacer function.
+  jsonString.replace(F_OK.INTERNAL_STRIP_JSON_REGEX, (match) => {
+    if (match.startsWith('"') || match[1] === "*" && !match.endsWith("*/")) {
+      return match;
+    }
+    return whitespace ? match.replaceAll(/\S/g, " ") : "";
+  })
+), "stripJsonComments");
+
+module.exports = stripJsonComments;

package/dist/packem_shared/to-uint-8-array-B4CjMOD3.mjs

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const encoder = new TextEncoder();
+const toUint8Array = /* @__PURE__ */ __name((contents) => {
+  if (contents instanceof Uint8Array) {
+    return contents;
+  }
+  if (typeof contents === "string") {
+    return encoder.encode(contents);
+  }
+  if (contents instanceof ArrayBuffer) {
+    return new Uint8Array(contents);
+  }
+  if (ArrayBuffer.isView(contents)) {
+    const bytes = contents.buffer.slice(contents.byteOffset, contents.byteOffset + contents.byteLength);
+    return new Uint8Array(bytes);
+  }
+  throw new TypeError("Invalid contents type. Expected string or ArrayBuffer.");
+}, "toUint8Array");
+
+export { toUint8Array as t };

package/dist/packem_shared/to-uint-8-array-BaTEyX3D.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const encoder = new TextEncoder();
+const toUint8Array = /* @__PURE__ */ __name((contents) => {
+  if (contents instanceof Uint8Array) {
+    return contents;
+  }
+  if (typeof contents === "string") {
+    return encoder.encode(contents);
+  }
+  if (contents instanceof ArrayBuffer) {
+    return new Uint8Array(contents);
+  }
+  if (ArrayBuffer.isView(contents)) {
+    const bytes = contents.buffer.slice(contents.byteOffset, contents.byteOffset + contents.byteLength);
+    return new Uint8Array(bytes);
+  }
+  throw new TypeError("Invalid contents type. Expected string or ArrayBuffer.");
+}, "toUint8Array");
+
+exports.toUint8Array = toUint8Array;

package/dist/packem_shared/walk-BW7b4GXI.cjs

@@ -0,0 +1,106 @@
+'use strict';
+
+const promises = require('node:fs/promises');
+const path = require('@visulima/path');
+const utils = require('@visulima/path/utils');
+const WalkError = require('./WalkError-B7_AVs7d.cjs');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+const walkInclude = require('./walk-include-yUdRrF16.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const _createWalkEntry = /* @__PURE__ */ __name(async (path$1) => {
+  const normalizePath = path.normalize(path$1);
+  const name = path.basename(normalizePath);
+  const info = await promises.stat(normalizePath);
+  return {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    isDirectory: info.isDirectory,
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    isFile: info.isFile,
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    isSymbolicLink: info.isSymbolicLink,
+    name,
+    path: normalizePath
+  };
+}, "_createWalkEntry");
+async function* walk(directory, {
+  extensions,
+  followSymlinks = false,
+  includeDirs: includeDirectories = true,
+  includeFiles = true,
+  includeSymlinks = true,
+  match,
+  maxDepth = Number.POSITIVE_INFINITY,
+  skip
+} = {}) {
+  assertValidFileOrDirectoryPath(directory);
+  if (maxDepth < 0) {
+    return;
+  }
+  const mappedMatch = match ? match.map((pattern) => typeof pattern === "string" ? walkInclude.globToRegExp(pattern) : pattern) : undefined;
+  const mappedSkip = skip ? skip.map((pattern) => typeof pattern === "string" ? walkInclude.globToRegExp(pattern) : pattern) : undefined;
+  directory = path.resolve(utils.toPath(directory));
+  if (includeDirectories && walkInclude.walkInclude(directory, extensions, mappedMatch, mappedSkip)) {
+    yield await _createWalkEntry(directory);
+  }
+  if (maxDepth < 1 || !walkInclude.walkInclude(directory, undefined, undefined, mappedSkip)) {
+    return;
+  }
+  try {
+    for await (const entry of await promises.readdir(directory, {
+      withFileTypes: true
+    })) {
+      let path$1 = path.join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        if (followSymlinks) {
+          path$1 = await promises.realpath(path$1);
+        } else if (includeSymlinks && walkInclude.walkInclude(path$1, extensions, mappedMatch, mappedSkip)) {
+          yield {
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            isDirectory: entry.isDirectory,
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            isFile: entry.isFile,
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            isSymbolicLink: entry.isSymbolicLink,
+            name: entry.name,
+            path: path$1
+          };
+        } else {
+          continue;
+        }
+      }
+      if (entry.isSymbolicLink() || entry.isDirectory()) {
+        yield* walk(path$1, {
+          extensions,
+          followSymlinks,
+          includeDirs: includeDirectories,
+          includeFiles,
+          includeSymlinks,
+          match: mappedMatch,
+          maxDepth: maxDepth - 1,
+          skip: mappedSkip
+        });
+      } else if (entry.isFile() && includeFiles && walkInclude.walkInclude(path$1, extensions, mappedMatch, mappedSkip)) {
+        yield {
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          isDirectory: entry.isDirectory,
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          isFile: entry.isFile,
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          isSymbolicLink: entry.isSymbolicLink,
+          name: entry.name,
+          path: path$1
+        };
+      }
+    }
+  } catch (error) {
+    if (error instanceof WalkError) {
+      throw error;
+    }
+    throw new WalkError(error, directory);
+  }
+}
+__name(walk, "walk");
+
+module.exports = walk;

package/dist/packem_shared/walk-CNcSYQVq.mjs

@@ -0,0 +1,104 @@
+import { readdir, realpath, stat } from 'node:fs/promises';
+import { resolve, join, normalize, basename } from '@visulima/path';
+import { toPath } from '@visulima/path/utils';
+import WalkError from './WalkError-H9EuRv7O.mjs';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+import { g as globToRegExp, w as walkInclude } from './walk-include-CMUSRa86.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const _createWalkEntry = /* @__PURE__ */ __name(async (path) => {
+  const normalizePath = normalize(path);
+  const name = basename(normalizePath);
+  const info = await stat(normalizePath);
+  return {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    isDirectory: info.isDirectory,
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    isFile: info.isFile,
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    isSymbolicLink: info.isSymbolicLink,
+    name,
+    path: normalizePath
+  };
+}, "_createWalkEntry");
+async function* walk(directory, {
+  extensions,
+  followSymlinks = false,
+  includeDirs: includeDirectories = true,
+  includeFiles = true,
+  includeSymlinks = true,
+  match,
+  maxDepth = Number.POSITIVE_INFINITY,
+  skip
+} = {}) {
+  assertValidFileOrDirectoryPath(directory);
+  if (maxDepth < 0) {
+    return;
+  }
+  const mappedMatch = match ? match.map((pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern) : undefined;
+  const mappedSkip = skip ? skip.map((pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern) : undefined;
+  directory = resolve(toPath(directory));
+  if (includeDirectories && walkInclude(directory, extensions, mappedMatch, mappedSkip)) {
+    yield await _createWalkEntry(directory);
+  }
+  if (maxDepth < 1 || !walkInclude(directory, undefined, undefined, mappedSkip)) {
+    return;
+  }
+  try {
+    for await (const entry of await readdir(directory, {
+      withFileTypes: true
+    })) {
+      let path = join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        if (followSymlinks) {
+          path = await realpath(path);
+        } else if (includeSymlinks && walkInclude(path, extensions, mappedMatch, mappedSkip)) {
+          yield {
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            isDirectory: entry.isDirectory,
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            isFile: entry.isFile,
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            isSymbolicLink: entry.isSymbolicLink,
+            name: entry.name,
+            path
+          };
+        } else {
+          continue;
+        }
+      }
+      if (entry.isSymbolicLink() || entry.isDirectory()) {
+        yield* walk(path, {
+          extensions,
+          followSymlinks,
+          includeDirs: includeDirectories,
+          includeFiles,
+          includeSymlinks,
+          match: mappedMatch,
+          maxDepth: maxDepth - 1,
+          skip: mappedSkip
+        });
+      } else if (entry.isFile() && includeFiles && walkInclude(path, extensions, mappedMatch, mappedSkip)) {
+        yield {
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          isDirectory: entry.isDirectory,
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          isFile: entry.isFile,
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          isSymbolicLink: entry.isSymbolicLink,
+          name: entry.name,
+          path
+        };
+      }
+    }
+  } catch (error) {
+    if (error instanceof WalkError) {
+      throw error;
+    }
+    throw new WalkError(error, directory);
+  }
+}
+__name(walk, "walk");
+
+export { walk as default };

package/dist/packem_shared/walk-include-CMUSRa86.mjs

@@ -0,0 +1,20 @@
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+const globToRegExp = /* @__PURE__ */ __name$1((glob) => {
+  const reString = glob.replace(/\.\*/g, ".([^/]*)").replace(/\*\*/g, "(.*)").replace(/(?<!\.)\*(?!\*)/g, "([^/]*)").replace(/\?/g, "[^/]").replace(/\.(?!\*)/g, "\\.").replace(/\{/g, "(").replace(/\}/g, ")").replace(/,/g, "|").replace(/\[!(.*?)\]/g, "[^$1]");
+  return new RegExp(`^${reString}$`);
+}, "globToRegExp");
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const walkInclude = /* @__PURE__ */ __name((path, extensions, match, skip) => {
+  if (Array.isArray(extensions) && extensions.length > 0 && !extensions.some((extension) => path.endsWith(extension))) {
+    return false;
+  }
+  if (match && !match.some((pattern) => pattern.test(path))) {
+    return false;
+  }
+  return !skip?.some((pattern) => pattern.test(path));
+}, "walkInclude");
+
+export { globToRegExp as g, walkInclude as w };

package/dist/packem_shared/walk-include-yUdRrF16.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+const globToRegExp = /* @__PURE__ */ __name$1((glob) => {
+  const reString = glob.replace(/\.\*/g, ".([^/]*)").replace(/\*\*/g, "(.*)").replace(/(?<!\.)\*(?!\*)/g, "([^/]*)").replace(/\?/g, "[^/]").replace(/\.(?!\*)/g, "\\.").replace(/\{/g, "(").replace(/\}/g, ")").replace(/,/g, "|").replace(/\[!(.*?)\]/g, "[^$1]");
+  return new RegExp(`^${reString}$`);
+}, "globToRegExp");
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const walkInclude = /* @__PURE__ */ __name((path, extensions, match, skip) => {
+  if (Array.isArray(extensions) && extensions.length > 0 && !extensions.some((extension) => path.endsWith(extension))) {
+    return false;
+  }
+  if (match && !match.some((pattern) => pattern.test(path))) {
+    return false;
+  }
+  return !skip?.some((pattern) => pattern.test(path));
+}, "walkInclude");
+
+exports.globToRegExp = globToRegExp;
+exports.walkInclude = walkInclude;