@slicemachine/init 1.1.19 → 2.0.1

package/dist/_node_modules/fast-glob/out/managers/tasks.js

@@ -0,0 +1,84 @@
+import { __exports as tasks } from "../../../../_virtual/tasks.js";
+import "../utils/index.js";
+import { __exports as utils$1 } from "../../../../_virtual/index6.js";
+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
+};
+//# sourceMappingURL=tasks.js.map

package/dist/_node_modules/fast-glob/out/managers/tasks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.js","sources":["../../../../../../../node_modules/fast-glob/out/managers/tasks.js"],"sourcesContent":["\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nexports.convertPatternGroupToTask = exports.convertPatternGroupsToTasks = exports.groupPatternsByBaseDirectory = exports.getNegativePatternsAsPositive = exports.getPositivePatterns = exports.convertPatternsToTasks = exports.generate = void 0;\r\nconst utils = require(\"../utils\");\r\nfunction generate(patterns, settings) {\r\n    const positivePatterns = getPositivePatterns(patterns);\r\n    const negativePatterns = getNegativePatternsAsPositive(patterns, settings.ignore);\r\n    const staticPatterns = positivePatterns.filter((pattern) => utils.pattern.isStaticPattern(pattern, settings));\r\n    const dynamicPatterns = positivePatterns.filter((pattern) => utils.pattern.isDynamicPattern(pattern, settings));\r\n    const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */ false);\r\n    const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */ true);\r\n    return staticTasks.concat(dynamicTasks);\r\n}\r\nexports.generate = generate;\r\n/**\r\n * Returns tasks grouped by basic pattern directories.\r\n *\r\n * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.\r\n * This is necessary because directory traversal starts at the base directory and goes deeper.\r\n */\r\nfunction convertPatternsToTasks(positive, negative, dynamic) {\r\n    const tasks = [];\r\n    const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);\r\n    const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);\r\n    const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);\r\n    const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);\r\n    tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));\r\n    /*\r\n     * For the sake of reducing future accesses to the file system, we merge all tasks within the current directory\r\n     * into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.\r\n     */\r\n    if ('.' in insideCurrentDirectoryGroup) {\r\n        tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));\r\n    }\r\n    else {\r\n        tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));\r\n    }\r\n    return tasks;\r\n}\r\nexports.convertPatternsToTasks = convertPatternsToTasks;\r\nfunction getPositivePatterns(patterns) {\r\n    return utils.pattern.getPositivePatterns(patterns);\r\n}\r\nexports.getPositivePatterns = getPositivePatterns;\r\nfunction getNegativePatternsAsPositive(patterns, ignore) {\r\n    const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);\r\n    const positive = negative.map(utils.pattern.convertToPositivePattern);\r\n    return positive;\r\n}\r\nexports.getNegativePatternsAsPositive = getNegativePatternsAsPositive;\r\nfunction groupPatternsByBaseDirectory(patterns) {\r\n    const group = {};\r\n    return patterns.reduce((collection, pattern) => {\r\n        const base = utils.pattern.getBaseDirectory(pattern);\r\n        if (base in collection) {\r\n            collection[base].push(pattern);\r\n        }\r\n        else {\r\n            collection[base] = [pattern];\r\n        }\r\n        return collection;\r\n    }, group);\r\n}\r\nexports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;\r\nfunction convertPatternGroupsToTasks(positive, negative, dynamic) {\r\n    return Object.keys(positive).map((base) => {\r\n        return convertPatternGroupToTask(base, positive[base], negative, dynamic);\r\n    });\r\n}\r\nexports.convertPatternGroupsToTasks = convertPatternGroupsToTasks;\r\nfunction convertPatternGroupToTask(base, positive, negative, dynamic) {\r\n    return {\r\n        dynamic,\r\n        positive,\r\n        negative,\r\n        base,\r\n        patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))\r\n    };\r\n}\r\nexports.convertPatternGroupToTask = convertPatternGroupToTask;\r\n"],"names":["require$$0","tasks"],"mappings":";;;AACA,OAAO,eAAe,OAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC5D,MAAA,4BAAoC,MAAA,8BAAsC,MAAA,+BAA4E,MAAA,gCAA8B,MAAA,qDAAoC,MAAA,WAAmB;AAC3O,MAAM,QAAQA;AACd,SAAS,SAAS,UAAU,UAAU;AAClC,QAAM,mBAAmB,oBAAoB,QAAQ;AACrD,QAAM,mBAAmB,8BAA8B,UAAU,SAAS,MAAM;AAChF,QAAM,iBAAiB,iBAAiB,OAAO,CAAC,YAAY,MAAM,QAAQ,gBAAgB,SAAS,QAAQ,CAAC;AAC5G,QAAM,kBAAkB,iBAAiB,OAAO,CAAC,YAAY,MAAM,QAAQ,iBAAiB,SAAS,QAAQ,CAAC;AAC9G,QAAM,cAAc;AAAA,IAAuB;AAAA,IAAgB;AAAA;AAAA,IAAgC;AAAA,EAAK;AAChG,QAAM,eAAe;AAAA,IAAuB;AAAA,IAAiB;AAAA;AAAA,IAAgC;AAAA,EAAI;AACjG,SAAO,YAAY,OAAO,YAAY;AAC1C;AACgB,MAAA,WAAG;AAOnB,SAAS,uBAAuB,UAAU,UAAU,SAAS;AACzD,QAAMC,SAAQ,CAAA;AACd,QAAM,kCAAkC,MAAM,QAAQ,mCAAmC,QAAQ;AACjG,QAAM,iCAAiC,MAAM,QAAQ,kCAAkC,QAAQ;AAC/F,QAAM,+BAA+B,6BAA6B,+BAA+B;AACjG,QAAM,8BAA8B,6BAA6B,8BAA8B;AAC/F,EAAAA,OAAM,KAAK,GAAG,4BAA4B,8BAA8B,UAAU,OAAO,CAAC;AAK1F,MAAI,OAAO,6BAA6B;AACpC,IAAAA,OAAM,KAAK,0BAA0B,KAAK,gCAAgC,UAAU,OAAO,CAAC;AAAA,EAC/F,OACI;AACD,IAAAA,OAAM,KAAK,GAAG,4BAA4B,6BAA6B,UAAU,OAAO,CAAC;AAAA,EAC5F;AACD,SAAOA;AACX;AAC8B,MAAA,yBAAG;AACjC,SAAS,oBAAoB,UAAU;AACnC,SAAO,MAAM,QAAQ,oBAAoB,QAAQ;AACrD;AAC2B,MAAA,sBAAG;AAC9B,SAAS,8BAA8B,UAAU,QAAQ;AACrD,QAAM,WAAW,MAAM,QAAQ,oBAAoB,QAAQ,EAAE,OAAO,MAAM;AAC1E,QAAM,WAAW,SAAS,IAAI,MAAM,QAAQ,wBAAwB;AACpE,SAAO;AACX;AACqC,MAAA,gCAAG;AACxC,SAAS,6BAA6B,UAAU;AAC5C,QAAM,QAAQ,CAAA;AACd,SAAO,SAAS,OAAO,CAAC,YAAY,YAAY;AAC5C,UAAM,OAAO,MAAM,QAAQ,iBAAiB,OAAO;AACnD,QAAI,QAAQ,YAAY;AACpB,iBAAW,IAAI,EAAE,KAAK,OAAO;AAAA,IAChC,OACI;AACD,iBAAW,IAAI,IAAI,CAAC,OAAO;AAAA,IAC9B;AACD,WAAO;AAAA,EACV,GAAE,KAAK;AACZ;AACoC,MAAA,+BAAG;AACvC,SAAS,4BAA4B,UAAU,UAAU,SAAS;AAC9D,SAAO,OAAO,KAAK,QAAQ,EAAE,IAAI,CAAC,SAAS;AACvC,WAAO,0BAA0B,MAAM,SAAS,IAAI,GAAG,UAAU,OAAO;AAAA,EAChF,CAAK;AACL;AACmC,MAAA,8BAAG;AACtC,SAAS,0BAA0B,MAAM,UAAU,UAAU,SAAS;AAClE,SAAO;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU,CAAA,EAAG,OAAO,UAAU,SAAS,IAAI,MAAM,QAAQ,wBAAwB,CAAC;AAAA,EAC1F;AACA;AACA,MAAA,4BAAoC;","x_google_ignoreList":[0]}

package/dist/_node_modules/fast-glob/out/providers/async.cjs

@@ -0,0 +1,29 @@
+"use strict";
+const async = require("../../../../_virtual/async.cjs");
+require("../readers/async.cjs");
+require("./provider.cjs");
+const async$1 = require("../../../../_virtual/async2.cjs");
+const provider = require("../../../../_virtual/provider.cjs");
+Object.defineProperty(async.__exports, "__esModule", { value: true });
+const async_1 = async$1.__exports;
+const provider_1 = provider.__exports;
+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.__exports.default = ProviderAsync;
+//# sourceMappingURL=async.cjs.map

package/dist/_node_modules/fast-glob/out/providers/async.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.cjs","sources":["../../../../../../../node_modules/fast-glob/out/providers/async.js"],"sourcesContent":["\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nconst async_1 = require(\"../readers/async\");\r\nconst provider_1 = require(\"./provider\");\r\nclass ProviderAsync extends provider_1.default {\r\n    constructor() {\r\n        super(...arguments);\r\n        this._reader = new async_1.default(this._settings);\r\n    }\r\n    async read(task) {\r\n        const root = this._getRootDirectory(task);\r\n        const options = this._getReaderOptions(task);\r\n        const entries = await this.api(root, task, options);\r\n        return entries.map((entry) => options.transform(entry));\r\n    }\r\n    api(root, task, options) {\r\n        if (task.dynamic) {\r\n            return this._reader.dynamic(root, options);\r\n        }\r\n        return this._reader.static(task.patterns, options);\r\n    }\r\n}\r\nexports.default = ProviderAsync;\r\n"],"names":["async","require$$0","require$$1"],"mappings":";;;;;;AACA,OAAO,eAAeA,MAAAA,WAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC5D,MAAM,UAAUC,QAAAA;AAChB,MAAM,aAAaC,SAAAA;AACnB,MAAM,sBAAsB,WAAW,QAAQ;AAAA,EAC3C,cAAc;AACV,UAAM,GAAG,SAAS;AAClB,SAAK,UAAU,IAAI,QAAQ,QAAQ,KAAK,SAAS;AAAA,EACpD;AAAA,EACD,MAAM,KAAK,MAAM;AACb,UAAM,OAAO,KAAK,kBAAkB,IAAI;AACxC,UAAM,UAAU,KAAK,kBAAkB,IAAI;AAC3C,UAAM,UAAU,MAAM,KAAK,IAAI,MAAM,MAAM,OAAO;AAClD,WAAO,QAAQ,IAAI,CAAC,UAAU,QAAQ,UAAU,KAAK,CAAC;AAAA,EACzD;AAAA,EACD,IAAI,MAAM,MAAM,SAAS;AACrB,QAAI,KAAK,SAAS;AACd,aAAO,KAAK,QAAQ,QAAQ,MAAM,OAAO;AAAA,IAC5C;AACD,WAAO,KAAK,QAAQ,OAAO,KAAK,UAAU,OAAO;AAAA,EACpD;AACL;AACAF,MAAA,UAAA,UAAkB;","x_google_ignoreList":[0]}

package/dist/_node_modules/fast-glob/out/providers/async.js

@@ -0,0 +1,28 @@
+import { __exports as async } from "../../../../_virtual/async.js";
+import "../readers/async.js";
+import "./provider.js";
+import { __exports as async$1 } from "../../../../_virtual/async2.js";
+import { __exports as provider } from "../../../../_virtual/provider.js";
+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;
+//# sourceMappingURL=async.js.map

package/dist/_node_modules/fast-glob/out/providers/async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.js","sources":["../../../../../../../node_modules/fast-glob/out/providers/async.js"],"sourcesContent":["\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nconst async_1 = require(\"../readers/async\");\r\nconst provider_1 = require(\"./provider\");\r\nclass ProviderAsync extends provider_1.default {\r\n    constructor() {\r\n        super(...arguments);\r\n        this._reader = new async_1.default(this._settings);\r\n    }\r\n    async read(task) {\r\n        const root = this._getRootDirectory(task);\r\n        const options = this._getReaderOptions(task);\r\n        const entries = await this.api(root, task, options);\r\n        return entries.map((entry) => options.transform(entry));\r\n    }\r\n    api(root, task, options) {\r\n        if (task.dynamic) {\r\n            return this._reader.dynamic(root, options);\r\n        }\r\n        return this._reader.static(task.patterns, options);\r\n    }\r\n}\r\nexports.default = ProviderAsync;\r\n"],"names":["require$$0","require$$1"],"mappings":";;;;;AACA,OAAO,eAAe,OAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC5D,MAAM,UAAUA;AAChB,MAAM,aAAaC;AACnB,MAAM,sBAAsB,WAAW,QAAQ;AAAA,EAC3C,cAAc;AACV,UAAM,GAAG,SAAS;AAClB,SAAK,UAAU,IAAI,QAAQ,QAAQ,KAAK,SAAS;AAAA,EACpD;AAAA,EACD,MAAM,KAAK,MAAM;AACb,UAAM,OAAO,KAAK,kBAAkB,IAAI;AACxC,UAAM,UAAU,KAAK,kBAAkB,IAAI;AAC3C,UAAM,UAAU,MAAM,KAAK,IAAI,MAAM,MAAM,OAAO;AAClD,WAAO,QAAQ,IAAI,CAAC,UAAU,QAAQ,UAAU,KAAK,CAAC;AAAA,EACzD;AAAA,EACD,IAAI,MAAM,MAAM,SAAS;AACrB,QAAI,KAAK,SAAS;AACd,aAAO,KAAK,QAAQ,QAAQ,MAAM,OAAO;AAAA,IAC5C;AACD,WAAO,KAAK,QAAQ,OAAO,KAAK,UAAU,OAAO;AAAA,EACpD;AACL;AACA,MAAA,UAAkB;","x_google_ignoreList":[0]}

package/dist/_node_modules/fast-glob/out/providers/filters/deep.cjs

@@ -0,0 +1,65 @@
+"use strict";
+const deep = require("../../../../../_virtual/deep.cjs");
+require("../../utils/index.cjs");
+require("../matchers/partial.cjs");
+const index = require("../../../../../_virtual/index6.cjs");
+const partial = require("../../../../../_virtual/partial.cjs");
+Object.defineProperty(deep.__exports, "__esModule", { value: true });
+const utils = index.__exports;
+const partial_1 = partial.__exports;
+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.__exports.default = DeepFilter;
+//# sourceMappingURL=deep.cjs.map

package/dist/_node_modules/fast-glob/out/providers/filters/deep.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep.cjs","sources":["../../../../../../../../node_modules/fast-glob/out/providers/filters/deep.js"],"sourcesContent":["\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nconst utils = require(\"../../utils\");\r\nconst partial_1 = require(\"../matchers/partial\");\r\nclass DeepFilter {\r\n    constructor(_settings, _micromatchOptions) {\r\n        this._settings = _settings;\r\n        this._micromatchOptions = _micromatchOptions;\r\n    }\r\n    getFilter(basePath, positive, negative) {\r\n        const matcher = this._getMatcher(positive);\r\n        const negativeRe = this._getNegativePatternsRe(negative);\r\n        return (entry) => this._filter(basePath, entry, matcher, negativeRe);\r\n    }\r\n    _getMatcher(patterns) {\r\n        return new partial_1.default(patterns, this._settings, this._micromatchOptions);\r\n    }\r\n    _getNegativePatternsRe(patterns) {\r\n        const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);\r\n        return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);\r\n    }\r\n    _filter(basePath, entry, matcher, negativeRe) {\r\n        if (this._isSkippedByDeep(basePath, entry.path)) {\r\n            return false;\r\n        }\r\n        if (this._isSkippedSymbolicLink(entry)) {\r\n            return false;\r\n        }\r\n        const filepath = utils.path.removeLeadingDotSegment(entry.path);\r\n        if (this._isSkippedByPositivePatterns(filepath, matcher)) {\r\n            return false;\r\n        }\r\n        return this._isSkippedByNegativePatterns(filepath, negativeRe);\r\n    }\r\n    _isSkippedByDeep(basePath, entryPath) {\r\n        /**\r\n         * Avoid unnecessary depth calculations when it doesn't matter.\r\n         */\r\n        if (this._settings.deep === Infinity) {\r\n            return false;\r\n        }\r\n        return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;\r\n    }\r\n    _getEntryLevel(basePath, entryPath) {\r\n        const entryPathDepth = entryPath.split('/').length;\r\n        if (basePath === '') {\r\n            return entryPathDepth;\r\n        }\r\n        const basePathDepth = basePath.split('/').length;\r\n        return entryPathDepth - basePathDepth;\r\n    }\r\n    _isSkippedSymbolicLink(entry) {\r\n        return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();\r\n    }\r\n    _isSkippedByPositivePatterns(entryPath, matcher) {\r\n        return !this._settings.baseNameMatch && !matcher.match(entryPath);\r\n    }\r\n    _isSkippedByNegativePatterns(entryPath, patternsRe) {\r\n        return !utils.pattern.matchAny(entryPath, patternsRe);\r\n    }\r\n}\r\nexports.default = DeepFilter;\r\n"],"names":["deep","require$$0","require$$1"],"mappings":";;;;;;AACA,OAAO,eAAeA,KAAAA,WAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC5D,MAAM,QAAQC,MAAAA;AACd,MAAM,YAAYC,QAAAA;AAClB,MAAM,WAAW;AAAA,EACb,YAAY,WAAW,oBAAoB;AACvC,SAAK,YAAY;AACjB,SAAK,qBAAqB;AAAA,EAC7B;AAAA,EACD,UAAU,UAAU,UAAU,UAAU;AACpC,UAAM,UAAU,KAAK,YAAY,QAAQ;AACzC,UAAM,aAAa,KAAK,uBAAuB,QAAQ;AACvD,WAAO,CAAC,UAAU,KAAK,QAAQ,UAAU,OAAO,SAAS,UAAU;AAAA,EACtE;AAAA,EACD,YAAY,UAAU;AAClB,WAAO,IAAI,UAAU,QAAQ,UAAU,KAAK,WAAW,KAAK,kBAAkB;AAAA,EACjF;AAAA,EACD,uBAAuB,UAAU;AAC7B,UAAM,+BAA+B,SAAS,OAAO,MAAM,QAAQ,6BAA6B;AAChG,WAAO,MAAM,QAAQ,oBAAoB,8BAA8B,KAAK,kBAAkB;AAAA,EACjG;AAAA,EACD,QAAQ,UAAU,OAAO,SAAS,YAAY;AAC1C,QAAI,KAAK,iBAAiB,UAAU,MAAM,IAAI,GAAG;AAC7C,aAAO;AAAA,IACV;AACD,QAAI,KAAK,uBAAuB,KAAK,GAAG;AACpC,aAAO;AAAA,IACV;AACD,UAAM,WAAW,MAAM,KAAK,wBAAwB,MAAM,IAAI;AAC9D,QAAI,KAAK,6BAA6B,UAAU,OAAO,GAAG;AACtD,aAAO;AAAA,IACV;AACD,WAAO,KAAK,6BAA6B,UAAU,UAAU;AAAA,EAChE;AAAA,EACD,iBAAiB,UAAU,WAAW;AAIlC,QAAI,KAAK,UAAU,SAAS,UAAU;AAClC,aAAO;AAAA,IACV;AACD,WAAO,KAAK,eAAe,UAAU,SAAS,KAAK,KAAK,UAAU;AAAA,EACrE;AAAA,EACD,eAAe,UAAU,WAAW;AAChC,UAAM,iBAAiB,UAAU,MAAM,GAAG,EAAE;AAC5C,QAAI,aAAa,IAAI;AACjB,aAAO;AAAA,IACV;AACD,UAAM,gBAAgB,SAAS,MAAM,GAAG,EAAE;AAC1C,WAAO,iBAAiB;AAAA,EAC3B;AAAA,EACD,uBAAuB,OAAO;AAC1B,WAAO,CAAC,KAAK,UAAU,uBAAuB,MAAM,OAAO;EAC9D;AAAA,EACD,6BAA6B,WAAW,SAAS;AAC7C,WAAO,CAAC,KAAK,UAAU,iBAAiB,CAAC,QAAQ,MAAM,SAAS;AAAA,EACnE;AAAA,EACD,6BAA6B,WAAW,YAAY;AAChD,WAAO,CAAC,MAAM,QAAQ,SAAS,WAAW,UAAU;AAAA,EACvD;AACL;AACAF,KAAA,UAAA,UAAkB;","x_google_ignoreList":[0]}

package/dist/_node_modules/fast-glob/out/providers/filters/deep.js

@@ -0,0 +1,64 @@
+import { __exports as deep } from "../../../../../_virtual/deep.js";
+import "../../utils/index.js";
+import "../matchers/partial.js";
+import { __exports as utils$1 } from "../../../../../_virtual/index6.js";
+import { __exports as partial } from "../../../../../_virtual/partial.js";
+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;
+//# sourceMappingURL=deep.js.map

package/dist/_node_modules/fast-glob/out/providers/filters/deep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep.js","sources":["../../../../../../../../node_modules/fast-glob/out/providers/filters/deep.js"],"sourcesContent":["\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nconst utils = require(\"../../utils\");\r\nconst partial_1 = require(\"../matchers/partial\");\r\nclass DeepFilter {\r\n    constructor(_settings, _micromatchOptions) {\r\n        this._settings = _settings;\r\n        this._micromatchOptions = _micromatchOptions;\r\n    }\r\n    getFilter(basePath, positive, negative) {\r\n        const matcher = this._getMatcher(positive);\r\n        const negativeRe = this._getNegativePatternsRe(negative);\r\n        return (entry) => this._filter(basePath, entry, matcher, negativeRe);\r\n    }\r\n    _getMatcher(patterns) {\r\n        return new partial_1.default(patterns, this._settings, this._micromatchOptions);\r\n    }\r\n    _getNegativePatternsRe(patterns) {\r\n        const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);\r\n        return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);\r\n    }\r\n    _filter(basePath, entry, matcher, negativeRe) {\r\n        if (this._isSkippedByDeep(basePath, entry.path)) {\r\n            return false;\r\n        }\r\n        if (this._isSkippedSymbolicLink(entry)) {\r\n            return false;\r\n        }\r\n        const filepath = utils.path.removeLeadingDotSegment(entry.path);\r\n        if (this._isSkippedByPositivePatterns(filepath, matcher)) {\r\n            return false;\r\n        }\r\n        return this._isSkippedByNegativePatterns(filepath, negativeRe);\r\n    }\r\n    _isSkippedByDeep(basePath, entryPath) {\r\n        /**\r\n         * Avoid unnecessary depth calculations when it doesn't matter.\r\n         */\r\n        if (this._settings.deep === Infinity) {\r\n            return false;\r\n        }\r\n        return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;\r\n    }\r\n    _getEntryLevel(basePath, entryPath) {\r\n        const entryPathDepth = entryPath.split('/').length;\r\n        if (basePath === '') {\r\n            return entryPathDepth;\r\n        }\r\n        const basePathDepth = basePath.split('/').length;\r\n        return entryPathDepth - basePathDepth;\r\n    }\r\n    _isSkippedSymbolicLink(entry) {\r\n        return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();\r\n    }\r\n    _isSkippedByPositivePatterns(entryPath, matcher) {\r\n        return !this._settings.baseNameMatch && !matcher.match(entryPath);\r\n    }\r\n    _isSkippedByNegativePatterns(entryPath, patternsRe) {\r\n        return !utils.pattern.matchAny(entryPath, patternsRe);\r\n    }\r\n}\r\nexports.default = DeepFilter;\r\n"],"names":["require$$0","require$$1"],"mappings":";;;;;AACA,OAAO,eAAe,MAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC5D,MAAM,QAAQA;AACd,MAAM,YAAYC;AAClB,MAAM,WAAW;AAAA,EACb,YAAY,WAAW,oBAAoB;AACvC,SAAK,YAAY;AACjB,SAAK,qBAAqB;AAAA,EAC7B;AAAA,EACD,UAAU,UAAU,UAAU,UAAU;AACpC,UAAM,UAAU,KAAK,YAAY,QAAQ;AACzC,UAAM,aAAa,KAAK,uBAAuB,QAAQ;AACvD,WAAO,CAAC,UAAU,KAAK,QAAQ,UAAU,OAAO,SAAS,UAAU;AAAA,EACtE;AAAA,EACD,YAAY,UAAU;AAClB,WAAO,IAAI,UAAU,QAAQ,UAAU,KAAK,WAAW,KAAK,kBAAkB;AAAA,EACjF;AAAA,EACD,uBAAuB,UAAU;AAC7B,UAAM,+BAA+B,SAAS,OAAO,MAAM,QAAQ,6BAA6B;AAChG,WAAO,MAAM,QAAQ,oBAAoB,8BAA8B,KAAK,kBAAkB;AAAA,EACjG;AAAA,EACD,QAAQ,UAAU,OAAO,SAAS,YAAY;AAC1C,QAAI,KAAK,iBAAiB,UAAU,MAAM,IAAI,GAAG;AAC7C,aAAO;AAAA,IACV;AACD,QAAI,KAAK,uBAAuB,KAAK,GAAG;AACpC,aAAO;AAAA,IACV;AACD,UAAM,WAAW,MAAM,KAAK,wBAAwB,MAAM,IAAI;AAC9D,QAAI,KAAK,6BAA6B,UAAU,OAAO,GAAG;AACtD,aAAO;AAAA,IACV;AACD,WAAO,KAAK,6BAA6B,UAAU,UAAU;AAAA,EAChE;AAAA,EACD,iBAAiB,UAAU,WAAW;AAIlC,QAAI,KAAK,UAAU,SAAS,UAAU;AAClC,aAAO;AAAA,IACV;AACD,WAAO,KAAK,eAAe,UAAU,SAAS,KAAK,KAAK,UAAU;AAAA,EACrE;AAAA,EACD,eAAe,UAAU,WAAW;AAChC,UAAM,iBAAiB,UAAU,MAAM,GAAG,EAAE;AAC5C,QAAI,aAAa,IAAI;AACjB,aAAO;AAAA,IACV;AACD,UAAM,gBAAgB,SAAS,MAAM,GAAG,EAAE;AAC1C,WAAO,iBAAiB;AAAA,EAC3B;AAAA,EACD,uBAAuB,OAAO;AAC1B,WAAO,CAAC,KAAK,UAAU,uBAAuB,MAAM,OAAO;EAC9D;AAAA,EACD,6BAA6B,WAAW,SAAS;AAC7C,WAAO,CAAC,KAAK,UAAU,iBAAiB,CAAC,QAAQ,MAAM,SAAS;AAAA,EACnE;AAAA,EACD,6BAA6B,WAAW,YAAY;AAChD,WAAO,CAAC,MAAM,QAAQ,SAAS,WAAW,UAAU;AAAA,EACvD;AACL;AACA,KAAA,UAAkB;","x_google_ignoreList":[0]}

package/dist/_node_modules/fast-glob/out/providers/filters/entry.cjs

@@ -0,0 +1,65 @@
+"use strict";
+const entry = require("../../../../../_virtual/entry.cjs");
+require("../../utils/index.cjs");
+const index = require("../../../../../_virtual/index6.cjs");
+Object.defineProperty(entry.__exports, "__esModule", { value: true });
+const utils = index.__exports;
+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.__exports.default = EntryFilter;
+//# sourceMappingURL=entry.cjs.map

package/dist/_node_modules/fast-glob/out/providers/filters/entry.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.cjs","sources":["../../../../../../../../node_modules/fast-glob/out/providers/filters/entry.js"],"sourcesContent":["\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nconst utils = require(\"../../utils\");\r\nclass EntryFilter {\r\n    constructor(_settings, _micromatchOptions) {\r\n        this._settings = _settings;\r\n        this._micromatchOptions = _micromatchOptions;\r\n        this.index = new Map();\r\n    }\r\n    getFilter(positive, negative) {\r\n        const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);\r\n        const negativeRe = utils.pattern.convertPatternsToRe(negative, this._micromatchOptions);\r\n        return (entry) => this._filter(entry, positiveRe, negativeRe);\r\n    }\r\n    _filter(entry, positiveRe, negativeRe) {\r\n        if (this._settings.unique && this._isDuplicateEntry(entry)) {\r\n            return false;\r\n        }\r\n        if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {\r\n            return false;\r\n        }\r\n        if (this._isSkippedByAbsoluteNegativePatterns(entry.path, negativeRe)) {\r\n            return false;\r\n        }\r\n        const filepath = this._settings.baseNameMatch ? entry.name : entry.path;\r\n        const isDirectory = entry.dirent.isDirectory();\r\n        const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(entry.path, negativeRe, isDirectory);\r\n        if (this._settings.unique && isMatched) {\r\n            this._createIndexRecord(entry);\r\n        }\r\n        return isMatched;\r\n    }\r\n    _isDuplicateEntry(entry) {\r\n        return this.index.has(entry.path);\r\n    }\r\n    _createIndexRecord(entry) {\r\n        this.index.set(entry.path, undefined);\r\n    }\r\n    _onlyFileFilter(entry) {\r\n        return this._settings.onlyFiles && !entry.dirent.isFile();\r\n    }\r\n    _onlyDirectoryFilter(entry) {\r\n        return this._settings.onlyDirectories && !entry.dirent.isDirectory();\r\n    }\r\n    _isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {\r\n        if (!this._settings.absolute) {\r\n            return false;\r\n        }\r\n        const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath);\r\n        return utils.pattern.matchAny(fullpath, patternsRe);\r\n    }\r\n    _isMatchToPatterns(entryPath, patternsRe, isDirectory) {\r\n        const filepath = utils.path.removeLeadingDotSegment(entryPath);\r\n        // Trying to match files and directories by patterns.\r\n        const isMatched = utils.pattern.matchAny(filepath, patternsRe);\r\n        // A pattern with a trailling slash can be used for directory matching.\r\n        // To apply such pattern, we need to add a tralling slash to the path.\r\n        if (!isMatched && isDirectory) {\r\n            return utils.pattern.matchAny(filepath + '/', patternsRe);\r\n        }\r\n        return isMatched;\r\n    }\r\n}\r\nexports.default = EntryFilter;\r\n"],"names":["entry","require$$0"],"mappings":";;;;AACA,OAAO,eAAeA,MAAAA,WAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC5D,MAAM,QAAQC,MAAAA;AACd,MAAM,YAAY;AAAA,EACd,YAAY,WAAW,oBAAoB;AACvC,SAAK,YAAY;AACjB,SAAK,qBAAqB;AAC1B,SAAK,QAAQ,oBAAI;EACpB;AAAA,EACD,UAAU,UAAU,UAAU;AAC1B,UAAM,aAAa,MAAM,QAAQ,oBAAoB,UAAU,KAAK,kBAAkB;AACtF,UAAM,aAAa,MAAM,QAAQ,oBAAoB,UAAU,KAAK,kBAAkB;AACtF,WAAO,CAACD,WAAU,KAAK,QAAQA,QAAO,YAAY,UAAU;AAAA,EAC/D;AAAA,EACD,QAAQA,QAAO,YAAY,YAAY;AACnC,QAAI,KAAK,UAAU,UAAU,KAAK,kBAAkBA,MAAK,GAAG;AACxD,aAAO;AAAA,IACV;AACD,QAAI,KAAK,gBAAgBA,MAAK,KAAK,KAAK,qBAAqBA,MAAK,GAAG;AACjE,aAAO;AAAA,IACV;AACD,QAAI,KAAK,qCAAqCA,OAAM,MAAM,UAAU,GAAG;AACnE,aAAO;AAAA,IACV;AACD,UAAM,WAAW,KAAK,UAAU,gBAAgBA,OAAM,OAAOA,OAAM;AACnE,UAAM,cAAcA,OAAM,OAAO,YAAW;AAC5C,UAAM,YAAY,KAAK,mBAAmB,UAAU,YAAY,WAAW,KAAK,CAAC,KAAK,mBAAmBA,OAAM,MAAM,YAAY,WAAW;AAC5I,QAAI,KAAK,UAAU,UAAU,WAAW;AACpC,WAAK,mBAAmBA,MAAK;AAAA,IAChC;AACD,WAAO;AAAA,EACV;AAAA,EACD,kBAAkBA,QAAO;AACrB,WAAO,KAAK,MAAM,IAAIA,OAAM,IAAI;AAAA,EACnC;AAAA,EACD,mBAAmBA,QAAO;AACtB,SAAK,MAAM,IAAIA,OAAM,MAAM,MAAS;AAAA,EACvC;AAAA,EACD,gBAAgBA,QAAO;AACnB,WAAO,KAAK,UAAU,aAAa,CAACA,OAAM,OAAO;EACpD;AAAA,EACD,qBAAqBA,QAAO;AACxB,WAAO,KAAK,UAAU,mBAAmB,CAACA,OAAM,OAAO;EAC1D;AAAA,EACD,qCAAqC,WAAW,YAAY;AACxD,QAAI,CAAC,KAAK,UAAU,UAAU;AAC1B,aAAO;AAAA,IACV;AACD,UAAM,WAAW,MAAM,KAAK,aAAa,KAAK,UAAU,KAAK,SAAS;AACtE,WAAO,MAAM,QAAQ,SAAS,UAAU,UAAU;AAAA,EACrD;AAAA,EACD,mBAAmB,WAAW,YAAY,aAAa;AACnD,UAAM,WAAW,MAAM,KAAK,wBAAwB,SAAS;AAE7D,UAAM,YAAY,MAAM,QAAQ,SAAS,UAAU,UAAU;AAG7D,QAAI,CAAC,aAAa,aAAa;AAC3B,aAAO,MAAM,QAAQ,SAAS,WAAW,KAAK,UAAU;AAAA,IAC3D;AACD,WAAO;AAAA,EACV;AACL;AACAA,MAAA,UAAA,UAAkB;","x_google_ignoreList":[0]}

package/dist/_node_modules/fast-glob/out/providers/filters/entry.js

@@ -0,0 +1,64 @@
+import { __exports as entry } from "../../../../../_virtual/entry.js";
+import "../../utils/index.js";
+import { __exports as utils$1 } from "../../../../../_virtual/index6.js";
+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;
+//# sourceMappingURL=entry.js.map

package/dist/_node_modules/fast-glob/out/providers/filters/entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.js","sources":["../../../../../../../../node_modules/fast-glob/out/providers/filters/entry.js"],"sourcesContent":["\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nconst utils = require(\"../../utils\");\r\nclass EntryFilter {\r\n    constructor(_settings, _micromatchOptions) {\r\n        this._settings = _settings;\r\n        this._micromatchOptions = _micromatchOptions;\r\n        this.index = new Map();\r\n    }\r\n    getFilter(positive, negative) {\r\n        const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);\r\n        const negativeRe = utils.pattern.convertPatternsToRe(negative, this._micromatchOptions);\r\n        return (entry) => this._filter(entry, positiveRe, negativeRe);\r\n    }\r\n    _filter(entry, positiveRe, negativeRe) {\r\n        if (this._settings.unique && this._isDuplicateEntry(entry)) {\r\n            return false;\r\n        }\r\n        if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {\r\n            return false;\r\n        }\r\n        if (this._isSkippedByAbsoluteNegativePatterns(entry.path, negativeRe)) {\r\n            return false;\r\n        }\r\n        const filepath = this._settings.baseNameMatch ? entry.name : entry.path;\r\n        const isDirectory = entry.dirent.isDirectory();\r\n        const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(entry.path, negativeRe, isDirectory);\r\n        if (this._settings.unique && isMatched) {\r\n            this._createIndexRecord(entry);\r\n        }\r\n        return isMatched;\r\n    }\r\n    _isDuplicateEntry(entry) {\r\n        return this.index.has(entry.path);\r\n    }\r\n    _createIndexRecord(entry) {\r\n        this.index.set(entry.path, undefined);\r\n    }\r\n    _onlyFileFilter(entry) {\r\n        return this._settings.onlyFiles && !entry.dirent.isFile();\r\n    }\r\n    _onlyDirectoryFilter(entry) {\r\n        return this._settings.onlyDirectories && !entry.dirent.isDirectory();\r\n    }\r\n    _isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {\r\n        if (!this._settings.absolute) {\r\n            return false;\r\n        }\r\n        const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath);\r\n        return utils.pattern.matchAny(fullpath, patternsRe);\r\n    }\r\n    _isMatchToPatterns(entryPath, patternsRe, isDirectory) {\r\n        const filepath = utils.path.removeLeadingDotSegment(entryPath);\r\n        // Trying to match files and directories by patterns.\r\n        const isMatched = utils.pattern.matchAny(filepath, patternsRe);\r\n        // A pattern with a trailling slash can be used for directory matching.\r\n        // To apply such pattern, we need to add a tralling slash to the path.\r\n        if (!isMatched && isDirectory) {\r\n            return utils.pattern.matchAny(filepath + '/', patternsRe);\r\n        }\r\n        return isMatched;\r\n    }\r\n}\r\nexports.default = EntryFilter;\r\n"],"names":["require$$0","entry"],"mappings":";;;AACA,OAAO,eAAe,OAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC5D,MAAM,QAAQA;AACd,MAAM,YAAY;AAAA,EACd,YAAY,WAAW,oBAAoB;AACvC,SAAK,YAAY;AACjB,SAAK,qBAAqB;AAC1B,SAAK,QAAQ,oBAAI;EACpB;AAAA,EACD,UAAU,UAAU,UAAU;AAC1B,UAAM,aAAa,MAAM,QAAQ,oBAAoB,UAAU,KAAK,kBAAkB;AACtF,UAAM,aAAa,MAAM,QAAQ,oBAAoB,UAAU,KAAK,kBAAkB;AACtF,WAAO,CAACC,WAAU,KAAK,QAAQA,QAAO,YAAY,UAAU;AAAA,EAC/D;AAAA,EACD,QAAQA,QAAO,YAAY,YAAY;AACnC,QAAI,KAAK,UAAU,UAAU,KAAK,kBAAkBA,MAAK,GAAG;AACxD,aAAO;AAAA,IACV;AACD,QAAI,KAAK,gBAAgBA,MAAK,KAAK,KAAK,qBAAqBA,MAAK,GAAG;AACjE,aAAO;AAAA,IACV;AACD,QAAI,KAAK,qCAAqCA,OAAM,MAAM,UAAU,GAAG;AACnE,aAAO;AAAA,IACV;AACD,UAAM,WAAW,KAAK,UAAU,gBAAgBA,OAAM,OAAOA,OAAM;AACnE,UAAM,cAAcA,OAAM,OAAO,YAAW;AAC5C,UAAM,YAAY,KAAK,mBAAmB,UAAU,YAAY,WAAW,KAAK,CAAC,KAAK,mBAAmBA,OAAM,MAAM,YAAY,WAAW;AAC5I,QAAI,KAAK,UAAU,UAAU,WAAW;AACpC,WAAK,mBAAmBA,MAAK;AAAA,IAChC;AACD,WAAO;AAAA,EACV;AAAA,EACD,kBAAkBA,QAAO;AACrB,WAAO,KAAK,MAAM,IAAIA,OAAM,IAAI;AAAA,EACnC;AAAA,EACD,mBAAmBA,QAAO;AACtB,SAAK,MAAM,IAAIA,OAAM,MAAM,MAAS;AAAA,EACvC;AAAA,EACD,gBAAgBA,QAAO;AACnB,WAAO,KAAK,UAAU,aAAa,CAACA,OAAM,OAAO;EACpD;AAAA,EACD,qBAAqBA,QAAO;AACxB,WAAO,KAAK,UAAU,mBAAmB,CAACA,OAAM,OAAO;EAC1D;AAAA,EACD,qCAAqC,WAAW,YAAY;AACxD,QAAI,CAAC,KAAK,UAAU,UAAU;AAC1B,aAAO;AAAA,IACV;AACD,UAAM,WAAW,MAAM,KAAK,aAAa,KAAK,UAAU,KAAK,SAAS;AACtE,WAAO,MAAM,QAAQ,SAAS,UAAU,UAAU;AAAA,EACrD;AAAA,EACD,mBAAmB,WAAW,YAAY,aAAa;AACnD,UAAM,WAAW,MAAM,KAAK,wBAAwB,SAAS;AAE7D,UAAM,YAAY,MAAM,QAAQ,SAAS,UAAU,UAAU;AAG7D,QAAI,CAAC,aAAa,aAAa;AAC3B,aAAO,MAAM,QAAQ,SAAS,WAAW,KAAK,UAAU;AAAA,IAC3D;AACD,WAAO;AAAA,EACV;AACL;AACA,MAAA,UAAkB;","x_google_ignoreList":[0]}

package/dist/_node_modules/fast-glob/out/providers/filters/error.cjs

@@ -0,0 +1,19 @@
+"use strict";
+const error = require("../../../../../_virtual/error.cjs");
+require("../../utils/index.cjs");
+const index = require("../../../../../_virtual/index6.cjs");
+Object.defineProperty(error.__exports, "__esModule", { value: true });
+const utils = index.__exports;
+class ErrorFilter {
+  constructor(_settings) {
+    this._settings = _settings;
+  }
+  getFilter() {
+    return (error2) => this._isNonFatalError(error2);
+  }
+  _isNonFatalError(error2) {
+    return utils.errno.isEnoentCodeError(error2) || this._settings.suppressErrors;
+  }
+}
+error.__exports.default = ErrorFilter;
+//# sourceMappingURL=error.cjs.map

package/dist/_node_modules/fast-glob/out/providers/filters/error.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.cjs","sources":["../../../../../../../../node_modules/fast-glob/out/providers/filters/error.js"],"sourcesContent":["\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nconst utils = require(\"../../utils\");\r\nclass ErrorFilter {\r\n    constructor(_settings) {\r\n        this._settings = _settings;\r\n    }\r\n    getFilter() {\r\n        return (error) => this._isNonFatalError(error);\r\n    }\r\n    _isNonFatalError(error) {\r\n        return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;\r\n    }\r\n}\r\nexports.default = ErrorFilter;\r\n"],"names":["error","require$$0"],"mappings":";;;;AACA,OAAO,eAAeA,MAAAA,WAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC5D,MAAM,QAAQC,MAAAA;AACd,MAAM,YAAY;AAAA,EACd,YAAY,WAAW;AACnB,SAAK,YAAY;AAAA,EACpB;AAAA,EACD,YAAY;AACR,WAAO,CAACD,WAAU,KAAK,iBAAiBA,MAAK;AAAA,EAChD;AAAA,EACD,iBAAiBA,QAAO;AACpB,WAAO,MAAM,MAAM,kBAAkBA,MAAK,KAAK,KAAK,UAAU;AAAA,EACjE;AACL;AACAA,MAAA,UAAA,UAAkB;","x_google_ignoreList":[0]}

package/dist/_node_modules/fast-glob/out/providers/filters/error.js

@@ -0,0 +1,18 @@
+import { __exports as error } from "../../../../../_virtual/error.js";
+import "../../utils/index.js";
+import { __exports as utils$1 } from "../../../../../_virtual/index6.js";
+Object.defineProperty(error, "__esModule", { value: true });
+const utils = utils$1;
+class ErrorFilter {
+  constructor(_settings) {
+    this._settings = _settings;
+  }
+  getFilter() {
+    return (error2) => this._isNonFatalError(error2);
+  }
+  _isNonFatalError(error2) {
+    return utils.errno.isEnoentCodeError(error2) || this._settings.suppressErrors;
+  }
+}
+error.default = ErrorFilter;
+//# sourceMappingURL=error.js.map

package/dist/_node_modules/fast-glob/out/providers/filters/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sources":["../../../../../../../../node_modules/fast-glob/out/providers/filters/error.js"],"sourcesContent":["\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nconst utils = require(\"../../utils\");\r\nclass ErrorFilter {\r\n    constructor(_settings) {\r\n        this._settings = _settings;\r\n    }\r\n    getFilter() {\r\n        return (error) => this._isNonFatalError(error);\r\n    }\r\n    _isNonFatalError(error) {\r\n        return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;\r\n    }\r\n}\r\nexports.default = ErrorFilter;\r\n"],"names":["require$$0","error"],"mappings":";;;AACA,OAAO,eAAe,OAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC5D,MAAM,QAAQA;AACd,MAAM,YAAY;AAAA,EACd,YAAY,WAAW;AACnB,SAAK,YAAY;AAAA,EACpB;AAAA,EACD,YAAY;AACR,WAAO,CAACC,WAAU,KAAK,iBAAiBA,MAAK;AAAA,EAChD;AAAA,EACD,iBAAiBA,QAAO;AACpB,WAAO,MAAM,MAAM,kBAAkBA,MAAK,KAAK,KAAK,UAAU;AAAA,EACjE;AACL;AACA,MAAA,UAAkB;","x_google_ignoreList":[0]}

package/dist/_node_modules/fast-glob/out/providers/matchers/matcher.cjs

@@ -0,0 +1,50 @@
+"use strict";
+const matcher = require("../../../../../_virtual/matcher.cjs");
+require("../../utils/index.cjs");
+const index = require("../../../../../_virtual/index6.cjs");
+Object.defineProperty(matcher.__exports, "__esModule", { value: true });
+const utils = index.__exports;
+class Matcher {
+  constructor(_patterns, _settings, _micromatchOptions) {
+    this._patterns = _patterns;
+    this._settings = _settings;
+    this._micromatchOptions = _micromatchOptions;
+    this._storage = [];
+    this._fillStorage();
+  }
+  _fillStorage() {
+    const patterns = utils.pattern.expandPatternsWithBraceExpansion(this._patterns);
+    for (const pattern of patterns) {
+      const segments = this._getPatternSegments(pattern);
+      const sections = this._splitSegmentsIntoSections(segments);
+      this._storage.push({
+        complete: sections.length <= 1,
+        pattern,
+        segments,
+        sections
+      });
+    }
+  }
+  _getPatternSegments(pattern) {
+    const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
+    return parts.map((part) => {
+      const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
+      if (!dynamic) {
+        return {
+          dynamic: false,
+          pattern: part
+        };
+      }
+      return {
+        dynamic: true,
+        pattern: part,
+        patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
+      };
+    });
+  }
+  _splitSegmentsIntoSections(segments) {
+    return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
+  }
+}
+matcher.__exports.default = Matcher;
+//# sourceMappingURL=matcher.cjs.map

package/dist/_node_modules/fast-glob/out/providers/matchers/matcher.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"matcher.cjs","sources":["../../../../../../../../node_modules/fast-glob/out/providers/matchers/matcher.js"],"sourcesContent":["\"use strict\";\r\nObject.defineProperty(exports, \"__esModule\", { value: true });\r\nconst utils = require(\"../../utils\");\r\nclass Matcher {\r\n    constructor(_patterns, _settings, _micromatchOptions) {\r\n        this._patterns = _patterns;\r\n        this._settings = _settings;\r\n        this._micromatchOptions = _micromatchOptions;\r\n        this._storage = [];\r\n        this._fillStorage();\r\n    }\r\n    _fillStorage() {\r\n        /**\r\n         * The original pattern may include `{,*,**,a/*}`, which will lead to problems with matching (unresolved level).\r\n         * So, before expand patterns with brace expansion into separated patterns.\r\n         */\r\n        const patterns = utils.pattern.expandPatternsWithBraceExpansion(this._patterns);\r\n        for (const pattern of patterns) {\r\n            const segments = this._getPatternSegments(pattern);\r\n            const sections = this._splitSegmentsIntoSections(segments);\r\n            this._storage.push({\r\n                complete: sections.length <= 1,\r\n                pattern,\r\n                segments,\r\n                sections\r\n            });\r\n        }\r\n    }\r\n    _getPatternSegments(pattern) {\r\n        const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);\r\n        return parts.map((part) => {\r\n            const dynamic = utils.pattern.isDynamicPattern(part, this._settings);\r\n            if (!dynamic) {\r\n                return {\r\n                    dynamic: false,\r\n                    pattern: part\r\n                };\r\n            }\r\n            return {\r\n                dynamic: true,\r\n                pattern: part,\r\n                patternRe: utils.pattern.makeRe(part, this._micromatchOptions)\r\n            };\r\n        });\r\n    }\r\n    _splitSegmentsIntoSections(segments) {\r\n        return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));\r\n    }\r\n}\r\nexports.default = Matcher;\r\n"],"names":["matcher","require$$0"],"mappings":";;;;AACA,OAAO,eAAeA,QAAAA,WAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC5D,MAAM,QAAQC,MAAAA;AACd,MAAM,QAAQ;AAAA,EACV,YAAY,WAAW,WAAW,oBAAoB;AAClD,SAAK,YAAY;AACjB,SAAK,YAAY;AACjB,SAAK,qBAAqB;AAC1B,SAAK,WAAW;AAChB,SAAK,aAAY;AAAA,EACpB;AAAA,EACD,eAAe;AAKX,UAAM,WAAW,MAAM,QAAQ,iCAAiC,KAAK,SAAS;AAC9E,eAAW,WAAW,UAAU;AAC5B,YAAM,WAAW,KAAK,oBAAoB,OAAO;AACjD,YAAM,WAAW,KAAK,2BAA2B,QAAQ;AACzD,WAAK,SAAS,KAAK;AAAA,QACf,UAAU,SAAS,UAAU;AAAA,QAC7B;AAAA,QACA;AAAA,QACA;AAAA,MAChB,CAAa;AAAA,IACJ;AAAA,EACJ;AAAA,EACD,oBAAoB,SAAS;AACzB,UAAM,QAAQ,MAAM,QAAQ,gBAAgB,SAAS,KAAK,kBAAkB;AAC5E,WAAO,MAAM,IAAI,CAAC,SAAS;AACvB,YAAM,UAAU,MAAM,QAAQ,iBAAiB,MAAM,KAAK,SAAS;AACnE,UAAI,CAAC,SAAS;AACV,eAAO;AAAA,UACH,SAAS;AAAA,UACT,SAAS;AAAA,QAC7B;AAAA,MACa;AACD,aAAO;AAAA,QACH,SAAS;AAAA,QACT,SAAS;AAAA,QACT,WAAW,MAAM,QAAQ,OAAO,MAAM,KAAK,kBAAkB;AAAA,MAC7E;AAAA,IACA,CAAS;AAAA,EACJ;AAAA,EACD,2BAA2B,UAAU;AACjC,WAAO,MAAM,MAAM,UAAU,UAAU,CAAC,YAAY,QAAQ,WAAW,MAAM,QAAQ,YAAY,QAAQ,OAAO,CAAC;AAAA,EACpH;AACL;AACAD,QAAA,UAAA,UAAkB;","x_google_ignoreList":[0]}

package/dist/_node_modules/fast-glob/out/providers/matchers/matcher.js

@@ -0,0 +1,49 @@
+import { __exports as matcher } from "../../../../../_virtual/matcher.js";
+import "../../utils/index.js";
+import { __exports as utils$1 } from "../../../../../_virtual/index6.js";
+Object.defineProperty(matcher, "__esModule", { value: true });
+const utils = utils$1;
+class Matcher {
+  constructor(_patterns, _settings, _micromatchOptions) {
+    this._patterns = _patterns;
+    this._settings = _settings;
+    this._micromatchOptions = _micromatchOptions;
+    this._storage = [];
+    this._fillStorage();
+  }
+  _fillStorage() {
+    const patterns = utils.pattern.expandPatternsWithBraceExpansion(this._patterns);
+    for (const pattern of patterns) {
+      const segments = this._getPatternSegments(pattern);
+      const sections = this._splitSegmentsIntoSections(segments);
+      this._storage.push({
+        complete: sections.length <= 1,
+        pattern,
+        segments,
+        sections
+      });
+    }
+  }
+  _getPatternSegments(pattern) {
+    const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
+    return parts.map((part) => {
+      const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
+      if (!dynamic) {
+        return {
+          dynamic: false,
+          pattern: part
+        };
+      }
+      return {
+        dynamic: true,
+        pattern: part,
+        patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
+      };
+    });
+  }
+  _splitSegmentsIntoSections(segments) {
+    return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
+  }
+}
+matcher.default = Matcher;
+//# sourceMappingURL=matcher.js.map