@quilted/create 0.2.43 → 0.2.45

package/build/esnext/node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/parse.esnext

@@ -1,236 +0,0 @@
-import { s as stringify$1 } from './stringify.esnext';
-import { c as constants } from './constants.esnext';
-
-const stringify = stringify$1;
-const {
-  MAX_LENGTH,
-  CHAR_BACKSLASH,
-  /* \ */
-  CHAR_BACKTICK,
-  /* ` */
-  CHAR_COMMA,
-  /* , */
-  CHAR_DOT,
-  /* . */
-  CHAR_LEFT_PARENTHESES,
-  /* ( */
-  CHAR_RIGHT_PARENTHESES,
-  /* ) */
-  CHAR_LEFT_CURLY_BRACE,
-  /* { */
-  CHAR_RIGHT_CURLY_BRACE,
-  /* } */
-  CHAR_LEFT_SQUARE_BRACKET,
-  /* [ */
-  CHAR_RIGHT_SQUARE_BRACKET,
-  /* ] */
-  CHAR_DOUBLE_QUOTE,
-  /* " */
-  CHAR_SINGLE_QUOTE,
-  /* ' */
-  CHAR_NO_BREAK_SPACE,
-  CHAR_ZERO_WIDTH_NOBREAK_SPACE
-} = constants;
-const parse = (input, options = {}) => {
-  if (typeof input !== "string") {
-    throw new TypeError("Expected a string");
-  }
-  let opts = options || {};
-  let max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-  if (input.length > max) {
-    throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
-  }
-  let ast = { type: "root", input, nodes: [] };
-  let stack = [ast];
-  let block = ast;
-  let prev = ast;
-  let brackets = 0;
-  let length = input.length;
-  let index = 0;
-  let depth = 0;
-  let value;
-  const advance = () => input[index++];
-  const push = (node) => {
-    if (node.type === "text" && prev.type === "dot") {
-      prev.type = "text";
-    }
-    if (prev && prev.type === "text" && node.type === "text") {
-      prev.value += node.value;
-      return;
-    }
-    block.nodes.push(node);
-    node.parent = block;
-    node.prev = prev;
-    prev = node;
-    return node;
-  };
-  push({ type: "bos" });
-  while (index < length) {
-    block = stack[stack.length - 1];
-    value = advance();
-    if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
-      continue;
-    }
-    if (value === CHAR_BACKSLASH) {
-      push({ type: "text", value: (options.keepEscaping ? value : "") + advance() });
-      continue;
-    }
-    if (value === CHAR_RIGHT_SQUARE_BRACKET) {
-      push({ type: "text", value: "\\" + value });
-      continue;
-    }
-    if (value === CHAR_LEFT_SQUARE_BRACKET) {
-      brackets++;
-      let next;
-      while (index < length && (next = advance())) {
-        value += next;
-        if (next === CHAR_LEFT_SQUARE_BRACKET) {
-          brackets++;
-          continue;
-        }
-        if (next === CHAR_BACKSLASH) {
-          value += advance();
-          continue;
-        }
-        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
-          brackets--;
-          if (brackets === 0) {
-            break;
-          }
-        }
-      }
-      push({ type: "text", value });
-      continue;
-    }
-    if (value === CHAR_LEFT_PARENTHESES) {
-      block = push({ type: "paren", nodes: [] });
-      stack.push(block);
-      push({ type: "text", value });
-      continue;
-    }
-    if (value === CHAR_RIGHT_PARENTHESES) {
-      if (block.type !== "paren") {
-        push({ type: "text", value });
-        continue;
-      }
-      block = stack.pop();
-      push({ type: "text", value });
-      block = stack[stack.length - 1];
-      continue;
-    }
-    if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
-      let open = value;
-      let next;
-      if (options.keepQuotes !== true) {
-        value = "";
-      }
-      while (index < length && (next = advance())) {
-        if (next === CHAR_BACKSLASH) {
-          value += next + advance();
-          continue;
-        }
-        if (next === open) {
-          if (options.keepQuotes === true) value += next;
-          break;
-        }
-        value += next;
-      }
-      push({ type: "text", value });
-      continue;
-    }
-    if (value === CHAR_LEFT_CURLY_BRACE) {
-      depth++;
-      let dollar = prev.value && prev.value.slice(-1) === "$" || block.dollar === true;
-      let brace = {
-        type: "brace",
-        open: true,
-        close: false,
-        dollar,
-        depth,
-        commas: 0,
-        ranges: 0,
-        nodes: []
-      };
-      block = push(brace);
-      stack.push(block);
-      push({ type: "open", value });
-      continue;
-    }
-    if (value === CHAR_RIGHT_CURLY_BRACE) {
-      if (block.type !== "brace") {
-        push({ type: "text", value });
-        continue;
-      }
-      let type = "close";
-      block = stack.pop();
-      block.close = true;
-      push({ type, value });
-      depth--;
-      block = stack[stack.length - 1];
-      continue;
-    }
-    if (value === CHAR_COMMA && depth > 0) {
-      if (block.ranges > 0) {
-        block.ranges = 0;
-        let open = block.nodes.shift();
-        block.nodes = [open, { type: "text", value: stringify(block) }];
-      }
-      push({ type: "comma", value });
-      block.commas++;
-      continue;
-    }
-    if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
-      let siblings = block.nodes;
-      if (depth === 0 || siblings.length === 0) {
-        push({ type: "text", value });
-        continue;
-      }
-      if (prev.type === "dot") {
-        block.range = [];
-        prev.value += value;
-        prev.type = "range";
-        if (block.nodes.length !== 3 && block.nodes.length !== 5) {
-          block.invalid = true;
-          block.ranges = 0;
-          prev.type = "text";
-          continue;
-        }
-        block.ranges++;
-        block.args = [];
-        continue;
-      }
-      if (prev.type === "range") {
-        siblings.pop();
-        let before = siblings[siblings.length - 1];
-        before.value += prev.value + value;
-        prev = before;
-        block.ranges--;
-        continue;
-      }
-      push({ type: "dot", value });
-      continue;
-    }
-    push({ type: "text", value });
-  }
-  do {
-    block = stack.pop();
-    if (block.type !== "root") {
-      block.nodes.forEach((node) => {
-        if (!node.nodes) {
-          if (node.type === "open") node.isOpen = true;
-          if (node.type === "close") node.isClose = true;
-          if (!node.nodes) node.type = "text";
-          node.invalid = true;
-        }
-      });
-      let parent = stack[stack.length - 1];
-      let index2 = parent.nodes.indexOf(block);
-      parent.nodes.splice(index2, 1, ...block.nodes);
-    }
-  } while (stack.length > 0);
-  push({ type: "eos" });
-  return ast;
-};
-var parse_1 = parse;
-
-export { parse_1 as p };

package/build/esnext/node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/stringify.esnext

@@ -1,29 +0,0 @@
-import './utils.esnext';
-import { __exports as utils$1 } from '../../../../../../_virtual/utils2.esnext';
-
-const utils = utils$1;
-var stringify = (ast, options = {}) => {
-  let stringify2 = (node, parent = {}) => {
-    let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
-    let invalidNode = node.invalid === true && options.escapeInvalid === true;
-    let output = "";
-    if (node.value) {
-      if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {
-        return "\\" + node.value;
-      }
-      return node.value;
-    }
-    if (node.value) {
-      return node.value;
-    }
-    if (node.nodes) {
-      for (let child of node.nodes) {
-        output += stringify2(child);
-      }
-    }
-    return output;
-  };
-  return stringify2(ast);
-};
-
-export { stringify as s };

package/build/esnext/node_modules/.pnpm/braces@3.0.2/node_modules/braces/lib/utils.esnext

@@ -1,73 +0,0 @@
-import { __exports as utils } from '../../../../../../_virtual/utils2.esnext';
-
-(function(exports) {
-  exports.isInteger = (num) => {
-    if (typeof num === "number") {
-      return Number.isInteger(num);
-    }
-    if (typeof num === "string" && num.trim() !== "") {
-      return Number.isInteger(Number(num));
-    }
-    return false;
-  };
-  exports.find = (node, type) => node.nodes.find((node2) => node2.type === type);
-  exports.exceedsLimit = (min, max, step = 1, limit) => {
-    if (limit === false) return false;
-    if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
-    return (Number(max) - Number(min)) / Number(step) >= limit;
-  };
-  exports.escapeNode = (block, n = 0, type) => {
-    let node = block.nodes[n];
-    if (!node) return;
-    if (type && node.type === type || node.type === "open" || node.type === "close") {
-      if (node.escaped !== true) {
-        node.value = "\\" + node.value;
-        node.escaped = true;
-      }
-    }
-  };
-  exports.encloseBrace = (node) => {
-    if (node.type !== "brace") return false;
-    if (node.commas >> 0 + node.ranges >> 0 === 0) {
-      node.invalid = true;
-      return true;
-    }
-    return false;
-  };
-  exports.isInvalidBrace = (block) => {
-    if (block.type !== "brace") return false;
-    if (block.invalid === true || block.dollar) return true;
-    if (block.commas >> 0 + block.ranges >> 0 === 0) {
-      block.invalid = true;
-      return true;
-    }
-    if (block.open !== true || block.close !== true) {
-      block.invalid = true;
-      return true;
-    }
-    return false;
-  };
-  exports.isOpenOrClose = (node) => {
-    if (node.type === "open" || node.type === "close") {
-      return true;
-    }
-    return node.open === true || node.close === true;
-  };
-  exports.reduce = (nodes) => nodes.reduce((acc, node) => {
-    if (node.type === "text") acc.push(node.value);
-    if (node.type === "range") node.type = "text";
-    return acc;
-  }, []);
-  exports.flatten = (...args) => {
-    const result = [];
-    const flat = (arr) => {
-      for (let i = 0; i < arr.length; i++) {
-        let ele = arr[i];
-        Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele);
-      }
-      return result;
-    };
-    flat(args);
-    return result;
-  };
-})(utils);

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/index.esnext

@@ -1,79 +0,0 @@
-import { getDefaultExportFromCjs } from '../../../../../../_virtual/_commonjsHelpers.esnext';
-import './managers/tasks.esnext';
-import './managers/patterns.esnext';
-import './providers/async.esnext';
-import './providers/stream.esnext';
-import './providers/sync.esnext';
-import './settings.esnext';
-import './utils/index.esnext';
-import { __exports as tasks } from '../../../../../../_virtual/tasks.esnext';
-import { __exports as patterns } from '../../../../../../_virtual/patterns.esnext';
-import { __exports as async } from '../../../../../../_virtual/async.esnext';
-import { __exports as stream } from '../../../../../../_virtual/stream.esnext';
-import { __exports as sync } from '../../../../../../_virtual/sync.esnext';
-import { __exports as settings } from '../../../../../../_virtual/settings.esnext';
-import { __exports as utils$1 } from '../../../../../../_virtual/index.esnext';
-
-const taskManager = tasks;
-const patternManager = patterns;
-const async_1 = async;
-const stream_1 = stream;
-const sync_1 = sync;
-const settings_1 = settings;
-const utils = utils$1;
-async function FastGlob(source, options) {
-  assertPatternsInput(source);
-  const works = getWorks(source, async_1.default, options);
-  const result = await Promise.all(works);
-  return utils.array.flatten(result);
-}
-(function(FastGlob2) {
-  function sync(source, options) {
-    assertPatternsInput(source);
-    const works = getWorks(source, sync_1.default, options);
-    return utils.array.flatten(works);
-  }
-  FastGlob2.sync = sync;
-  function stream(source, options) {
-    assertPatternsInput(source);
-    const works = getWorks(source, stream_1.default, options);
-    return utils.stream.merge(works);
-  }
-  FastGlob2.stream = stream;
-  function generateTasks(source, options) {
-    assertPatternsInput(source);
-    const patterns = patternManager.transform([].concat(source));
-    const settings = new settings_1.default(options);
-    return taskManager.generate(patterns, settings);
-  }
-  FastGlob2.generateTasks = generateTasks;
-  function isDynamicPattern(source, options) {
-    assertPatternsInput(source);
-    const settings = new settings_1.default(options);
-    return utils.pattern.isDynamicPattern(source, settings);
-  }
-  FastGlob2.isDynamicPattern = isDynamicPattern;
-  function escapePath(source) {
-    assertPatternsInput(source);
-    return utils.path.escape(source);
-  }
-  FastGlob2.escapePath = escapePath;
-})(FastGlob || (FastGlob = {}));
-function getWorks(source, _Provider, options) {
-  const patterns = patternManager.transform([].concat(source));
-  const settings = new settings_1.default(options);
-  const tasks = taskManager.generate(patterns, settings);
-  const provider = new _Provider(settings);
-  return tasks.map(provider.read, provider);
-}
-function assertPatternsInput(input) {
-  const source = [].concat(input);
-  const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
-  if (!isValidSource) {
-    throw new TypeError("Patterns must be a string (non empty) or an array of strings");
-  }
-}
-var out = FastGlob;
-const fastGlob = /* @__PURE__ */ getDefaultExportFromCjs(out);
-
-export { fastGlob as default };

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/managers/patterns.esnext

@@ -1,15 +0,0 @@
-import { __exports as patterns } from '../../../../../../../_virtual/patterns.esnext';
-
-Object.defineProperty(patterns, "__esModule", { value: true });
-patterns.removeDuplicateSlashes = patterns.transform = void 0;
-const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
-function transform(patterns2) {
-  return patterns2.map((pattern) => removeDuplicateSlashes(pattern));
-}
-patterns.transform = transform;
-function removeDuplicateSlashes(pattern) {
-  return pattern.replace(DOUBLE_SLASH_RE, "/");
-}
-patterns.removeDuplicateSlashes = removeDuplicateSlashes;
-
-export { patterns as default };

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/managers/tasks.esnext

@@ -1,83 +0,0 @@
-import { __exports as tasks } from '../../../../../../../_virtual/tasks.esnext';
-import '../utils/index.esnext';
-import { __exports as utils$1 } from '../../../../../../../_virtual/index.esnext';
-
-Object.defineProperty(tasks, "__esModule", { value: true });
-tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
-const utils = utils$1;
-function generate(patterns, settings) {
-  const positivePatterns = getPositivePatterns(patterns);
-  const negativePatterns = getNegativePatternsAsPositive(patterns, settings.ignore);
-  const staticPatterns = positivePatterns.filter((pattern) => utils.pattern.isStaticPattern(pattern, settings));
-  const dynamicPatterns = positivePatterns.filter((pattern) => utils.pattern.isDynamicPattern(pattern, settings));
-  const staticTasks = convertPatternsToTasks(
-    staticPatterns,
-    negativePatterns,
-    /* dynamic */
-    false
-  );
-  const dynamicTasks = convertPatternsToTasks(
-    dynamicPatterns,
-    negativePatterns,
-    /* dynamic */
-    true
-  );
-  return staticTasks.concat(dynamicTasks);
-}
-tasks.generate = generate;
-function convertPatternsToTasks(positive, negative, dynamic) {
-  const tasks2 = [];
-  const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
-  const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
-  const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
-  const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
-  tasks2.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
-  if ("." in insideCurrentDirectoryGroup) {
-    tasks2.push(convertPatternGroupToTask(".", patternsInsideCurrentDirectory, negative, dynamic));
-  } else {
-    tasks2.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
-  }
-  return tasks2;
-}
-tasks.convertPatternsToTasks = convertPatternsToTasks;
-function getPositivePatterns(patterns) {
-  return utils.pattern.getPositivePatterns(patterns);
-}
-tasks.getPositivePatterns = getPositivePatterns;
-function getNegativePatternsAsPositive(patterns, ignore) {
-  const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);
-  const positive = negative.map(utils.pattern.convertToPositivePattern);
-  return positive;
-}
-tasks.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
-function groupPatternsByBaseDirectory(patterns) {
-  const group = {};
-  return patterns.reduce((collection, pattern) => {
-    const base = utils.pattern.getBaseDirectory(pattern);
-    if (base in collection) {
-      collection[base].push(pattern);
-    } else {
-      collection[base] = [pattern];
-    }
-    return collection;
-  }, group);
-}
-tasks.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
-function convertPatternGroupsToTasks(positive, negative, dynamic) {
-  return Object.keys(positive).map((base) => {
-    return convertPatternGroupToTask(base, positive[base], negative, dynamic);
-  });
-}
-tasks.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
-function convertPatternGroupToTask(base, positive, negative, dynamic) {
-  return {
-    dynamic,
-    positive,
-    negative,
-    base,
-    patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
-  };
-}
-tasks.convertPatternGroupToTask = convertPatternGroupToTask;
-
-export { tasks as default };

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/providers/async.esnext

@@ -1,28 +0,0 @@
-import { __exports as async } from '../../../../../../../_virtual/async.esnext';
-import '../readers/async.esnext';
-import './provider.esnext';
-import { __exports as async$1 } from '../../../../../../../_virtual/async2.esnext';
-import { __exports as provider } from '../../../../../../../_virtual/provider.esnext';
-
-Object.defineProperty(async, "__esModule", { value: true });
-const async_1 = async$1;
-const provider_1 = provider;
-class ProviderAsync extends provider_1.default {
-  constructor() {
-    super(...arguments);
-    this._reader = new async_1.default(this._settings);
-  }
-  async read(task) {
-    const root = this._getRootDirectory(task);
-    const options = this._getReaderOptions(task);
-    const entries = await this.api(root, task, options);
-    return entries.map((entry) => options.transform(entry));
-  }
-  api(root, task, options) {
-    if (task.dynamic) {
-      return this._reader.dynamic(root, options);
-    }
-    return this._reader.static(task.patterns, options);
-  }
-}
-async.default = ProviderAsync;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/providers/filters/deep.esnext

@@ -1,64 +0,0 @@
-import { __exports as deep } from '../../../../../../../../_virtual/deep.esnext';
-import '../../utils/index.esnext';
-import '../matchers/partial.esnext';
-import { __exports as utils$1 } from '../../../../../../../../_virtual/index.esnext';
-import { __exports as partial } from '../../../../../../../../_virtual/partial.esnext';
-
-Object.defineProperty(deep, "__esModule", { value: true });
-const utils = utils$1;
-const partial_1 = partial;
-class DeepFilter {
-  constructor(_settings, _micromatchOptions) {
-    this._settings = _settings;
-    this._micromatchOptions = _micromatchOptions;
-  }
-  getFilter(basePath, positive, negative) {
-    const matcher = this._getMatcher(positive);
-    const negativeRe = this._getNegativePatternsRe(negative);
-    return (entry) => this._filter(basePath, entry, matcher, negativeRe);
-  }
-  _getMatcher(patterns) {
-    return new partial_1.default(patterns, this._settings, this._micromatchOptions);
-  }
-  _getNegativePatternsRe(patterns) {
-    const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
-    return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
-  }
-  _filter(basePath, entry, matcher, negativeRe) {
-    if (this._isSkippedByDeep(basePath, entry.path)) {
-      return false;
-    }
-    if (this._isSkippedSymbolicLink(entry)) {
-      return false;
-    }
-    const filepath = utils.path.removeLeadingDotSegment(entry.path);
-    if (this._isSkippedByPositivePatterns(filepath, matcher)) {
-      return false;
-    }
-    return this._isSkippedByNegativePatterns(filepath, negativeRe);
-  }
-  _isSkippedByDeep(basePath, entryPath) {
-    if (this._settings.deep === Infinity) {
-      return false;
-    }
-    return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
-  }
-  _getEntryLevel(basePath, entryPath) {
-    const entryPathDepth = entryPath.split("/").length;
-    if (basePath === "") {
-      return entryPathDepth;
-    }
-    const basePathDepth = basePath.split("/").length;
-    return entryPathDepth - basePathDepth;
-  }
-  _isSkippedSymbolicLink(entry) {
-    return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
-  }
-  _isSkippedByPositivePatterns(entryPath, matcher) {
-    return !this._settings.baseNameMatch && !matcher.match(entryPath);
-  }
-  _isSkippedByNegativePatterns(entryPath, patternsRe) {
-    return !utils.pattern.matchAny(entryPath, patternsRe);
-  }
-}
-deep.default = DeepFilter;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.12/node_modules/fast-glob/out/providers/filters/entry.esnext

@@ -1,64 +0,0 @@
-import { __exports as entry } from '../../../../../../../../_virtual/entry.esnext';
-import '../../utils/index.esnext';
-import { __exports as utils$1 } from '../../../../../../../../_virtual/index.esnext';
-
-Object.defineProperty(entry, "__esModule", { value: true });
-const utils = utils$1;
-class EntryFilter {
-  constructor(_settings, _micromatchOptions) {
-    this._settings = _settings;
-    this._micromatchOptions = _micromatchOptions;
-    this.index = /* @__PURE__ */ new Map();
-  }
-  getFilter(positive, negative) {
-    const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);
-    const negativeRe = utils.pattern.convertPatternsToRe(negative, this._micromatchOptions);
-    return (entry2) => this._filter(entry2, positiveRe, negativeRe);
-  }
-  _filter(entry2, positiveRe, negativeRe) {
-    if (this._settings.unique && this._isDuplicateEntry(entry2)) {
-      return false;
-    }
-    if (this._onlyFileFilter(entry2) || this._onlyDirectoryFilter(entry2)) {
-      return false;
-    }
-    if (this._isSkippedByAbsoluteNegativePatterns(entry2.path, negativeRe)) {
-      return false;
-    }
-    const filepath = this._settings.baseNameMatch ? entry2.name : entry2.path;
-    const isDirectory = entry2.dirent.isDirectory();
-    const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(entry2.path, negativeRe, isDirectory);
-    if (this._settings.unique && isMatched) {
-      this._createIndexRecord(entry2);
-    }
-    return isMatched;
-  }
-  _isDuplicateEntry(entry2) {
-    return this.index.has(entry2.path);
-  }
-  _createIndexRecord(entry2) {
-    this.index.set(entry2.path, void 0);
-  }
-  _onlyFileFilter(entry2) {
-    return this._settings.onlyFiles && !entry2.dirent.isFile();
-  }
-  _onlyDirectoryFilter(entry2) {
-    return this._settings.onlyDirectories && !entry2.dirent.isDirectory();
-  }
-  _isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {
-    if (!this._settings.absolute) {
-      return false;
-    }
-    const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath);
-    return utils.pattern.matchAny(fullpath, patternsRe);
-  }
-  _isMatchToPatterns(entryPath, patternsRe, isDirectory) {
-    const filepath = utils.path.removeLeadingDotSegment(entryPath);
-    const isMatched = utils.pattern.matchAny(filepath, patternsRe);
-    if (!isMatched && isDirectory) {
-      return utils.pattern.matchAny(filepath + "/", patternsRe);
-    }
-    return isMatched;
-  }
-}
-entry.default = EntryFilter;