Ajout de promotion et de commande

node_modules/@babel/helper-compilation-targets/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@babel/helper-compilation-targets/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-compilation-targets
+
+> Helper functions on Babel compilation targets
+
+See our website [@babel/helper-compilation-targets](https://babeljs.io/docs/babel-helper-compilation-targets) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-compilation-targets
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-compilation-targets
+```

node_modules/@babel/helper-compilation-targets/lib/debug.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getInclusionReasons = getInclusionReasons;
+var _semver = require("semver");
+var _pretty = require("./pretty.js");
+var _utils = require("./utils.js");
+function getInclusionReasons(item, targetVersions, list) {
+  const minVersions = list[item] || {};
+  return Object.keys(targetVersions).reduce((result, env) => {
+    const minVersion = (0, _utils.getLowestImplementedVersion)(minVersions, env);
+    const targetVersion = targetVersions[env];
+    if (!minVersion) {
+      result[env] = (0, _pretty.prettifyVersion)(targetVersion);
+    } else {
+      const minIsUnreleased = (0, _utils.isUnreleasedVersion)(minVersion, env);
+      const targetIsUnreleased = (0, _utils.isUnreleasedVersion)(targetVersion, env);
+      if (!targetIsUnreleased && (minIsUnreleased || _semver.lt(targetVersion.toString(), (0, _utils.semverify)(minVersion)))) {
+        result[env] = (0, _pretty.prettifyVersion)(targetVersion);
+      }
+    }
+    return result;
+  }, {});
+}
+
+//# sourceMappingURL=debug.js.map

node_modules/@babel/helper-compilation-targets/lib/filter-items.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = filterItems;
+exports.isRequired = isRequired;
+exports.targetsSupported = targetsSupported;
+var _semver = require("semver");
+var _utils = require("./utils.js");
+const pluginsCompatData = require("@babel/compat-data/plugins");
+function targetsSupported(target, support) {
+  const targetEnvironments = Object.keys(target);
+  if (targetEnvironments.length === 0) {
+    return false;
+  }
+  const unsupportedEnvironments = targetEnvironments.filter(environment => {
+    const lowestImplementedVersion = (0, _utils.getLowestImplementedVersion)(support, environment);
+    if (!lowestImplementedVersion) {
+      return true;
+    }
+    const lowestTargetedVersion = target[environment];
+    if ((0, _utils.isUnreleasedVersion)(lowestTargetedVersion, environment)) {
+      return false;
+    }
+    if ((0, _utils.isUnreleasedVersion)(lowestImplementedVersion, environment)) {
+      return true;
+    }
+    if (!_semver.valid(lowestTargetedVersion.toString())) {
+      throw new Error(`Invalid version passed for target "${environment}": "${lowestTargetedVersion}". ` + "Versions must be in semver format (major.minor.patch)");
+    }
+    return _semver.gt((0, _utils.semverify)(lowestImplementedVersion), lowestTargetedVersion.toString());
+  });
+  return unsupportedEnvironments.length === 0;
+}
+function isRequired(name, targets, {
+  compatData = pluginsCompatData,
+  includes,
+  excludes
+} = {}) {
+  if (excludes != null && excludes.has(name)) return false;
+  if (includes != null && includes.has(name)) return true;
+  return !targetsSupported(targets, compatData[name]);
+}
+function filterItems(list, includes, excludes, targets, defaultIncludes, defaultExcludes, pluginSyntaxMap) {
+  const result = new Set();
+  const options = {
+    compatData: list,
+    includes,
+    excludes
+  };
+  for (const item in list) {
+    if (isRequired(item, targets, options)) {
+      result.add(item);
+    } else if (pluginSyntaxMap) {
+      const shippedProposalsSyntax = pluginSyntaxMap.get(item);
+      if (shippedProposalsSyntax) {
+        result.add(shippedProposalsSyntax);
+      }
+    }
+  }
+  defaultIncludes == null || defaultIncludes.forEach(item => !excludes.has(item) && result.add(item));
+  defaultExcludes == null || defaultExcludes.forEach(item => !includes.has(item) && result.delete(item));
+  return result;
+}
+
+//# sourceMappingURL=filter-items.js.map

node_modules/@babel/helper-compilation-targets/lib/index.js

@@ -0,0 +1,229 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "TargetNames", {
+  enumerable: true,
+  get: function () {
+    return _options.TargetNames;
+  }
+});
+exports.default = getTargets;
+Object.defineProperty(exports, "filterItems", {
+  enumerable: true,
+  get: function () {
+    return _filterItems.default;
+  }
+});
+Object.defineProperty(exports, "getInclusionReasons", {
+  enumerable: true,
+  get: function () {
+    return _debug.getInclusionReasons;
+  }
+});
+exports.isBrowsersQueryValid = isBrowsersQueryValid;
+Object.defineProperty(exports, "isRequired", {
+  enumerable: true,
+  get: function () {
+    return _filterItems.isRequired;
+  }
+});
+Object.defineProperty(exports, "prettifyTargets", {
+  enumerable: true,
+  get: function () {
+    return _pretty.prettifyTargets;
+  }
+});
+Object.defineProperty(exports, "unreleasedLabels", {
+  enumerable: true,
+  get: function () {
+    return _targets.unreleasedLabels;
+  }
+});
+var _browserslist = require("browserslist");
+var _helperValidatorOption = require("@babel/helper-validator-option");
+var _lruCache = require("lru-cache");
+var _utils = require("./utils.js");
+var _targets = require("./targets.js");
+var _options = require("./options.js");
+var _pretty = require("./pretty.js");
+var _debug = require("./debug.js");
+var _filterItems = require("./filter-items.js");
+const browserModulesData = require("@babel/compat-data/native-modules");
+const ESM_SUPPORT = browserModulesData["es6.module"];
+const v = new _helperValidatorOption.OptionValidator("@babel/helper-compilation-targets");
+function validateTargetNames(targets) {
+  const validTargets = Object.keys(_options.TargetNames);
+  for (const target of Object.keys(targets)) {
+    if (!(target in _options.TargetNames)) {
+      throw new Error(v.formatMessage(`'${target}' is not a valid target
+- Did you mean '${(0, _helperValidatorOption.findSuggestion)(target, validTargets)}'?`));
+    }
+  }
+  return targets;
+}
+function isBrowsersQueryValid(browsers) {
+  return typeof browsers === "string" || Array.isArray(browsers) && browsers.every(b => typeof b === "string");
+}
+function validateBrowsers(browsers) {
+  v.invariant(browsers === undefined || isBrowsersQueryValid(browsers), `'${String(browsers)}' is not a valid browserslist query`);
+  return browsers;
+}
+function getLowestVersions(browsers) {
+  return browsers.reduce((all, browser) => {
+    const [browserName, browserVersion] = browser.split(" ");
+    const target = _targets.browserNameMap[browserName];
+    if (!target) {
+      return all;
+    }
+    try {
+      const splitVersion = browserVersion.split("-")[0].toLowerCase();
+      const isSplitUnreleased = (0, _utils.isUnreleasedVersion)(splitVersion, target);
+      if (!all[target]) {
+        all[target] = isSplitUnreleased ? splitVersion : (0, _utils.semverify)(splitVersion);
+        return all;
+      }
+      const version = all[target];
+      const isUnreleased = (0, _utils.isUnreleasedVersion)(version, target);
+      if (isUnreleased && isSplitUnreleased) {
+        all[target] = (0, _utils.getLowestUnreleased)(version, splitVersion, target);
+      } else if (isUnreleased) {
+        all[target] = (0, _utils.semverify)(splitVersion);
+      } else if (!isUnreleased && !isSplitUnreleased) {
+        const parsedBrowserVersion = (0, _utils.semverify)(splitVersion);
+        all[target] = (0, _utils.semverMin)(version, parsedBrowserVersion);
+      }
+    } catch (_) {}
+    return all;
+  }, {});
+}
+function outputDecimalWarning(decimalTargets) {
+  if (!decimalTargets.length) {
+    return;
+  }
+  console.warn("Warning, the following targets are using a decimal version:\n");
+  decimalTargets.forEach(({
+    target,
+    value
+  }) => console.warn(`  ${target}: ${value}`));
+  console.warn(`
+We recommend using a string for minor/patch versions to avoid numbers like 6.10
+getting parsed as 6.1, which can lead to unexpected behavior.
+`);
+}
+function semverifyTarget(target, value) {
+  try {
+    return (0, _utils.semverify)(value);
+  } catch (_) {
+    throw new Error(v.formatMessage(`'${value}' is not a valid value for 'targets.${target}'.`));
+  }
+}
+function nodeTargetParser(value) {
+  const parsed = value === true || value === "current" ? process.versions.node.split("-")[0] : semverifyTarget("node", value);
+  return ["node", parsed];
+}
+function defaultTargetParser(target, value) {
+  const version = (0, _utils.isUnreleasedVersion)(value, target) ? value.toLowerCase() : semverifyTarget(target, value);
+  return [target, version];
+}
+function generateTargets(inputTargets) {
+  const input = Object.assign({}, inputTargets);
+  delete input.esmodules;
+  delete input.browsers;
+  return input;
+}
+function resolveTargets(queries, env) {
+  const resolved = _browserslist(queries, {
+    mobileToDesktop: true,
+    env
+  });
+  return getLowestVersions(resolved);
+}
+const targetsCache = new _lruCache({
+  max: 64
+});
+function resolveTargetsCached(queries, env) {
+  const cacheKey = typeof queries === "string" ? queries : queries.join() + env;
+  let cached = targetsCache.get(cacheKey);
+  if (!cached) {
+    cached = resolveTargets(queries, env);
+    targetsCache.set(cacheKey, cached);
+  }
+  return Object.assign({}, cached);
+}
+function getTargets(inputTargets = {}, options = {}) {
+  var _browsers, _browsers2;
+  let {
+    browsers,
+    esmodules
+  } = inputTargets;
+  const {
+    configPath = ".",
+    onBrowserslistConfigFound
+  } = options;
+  validateBrowsers(browsers);
+  const input = generateTargets(inputTargets);
+  let targets = validateTargetNames(input);
+  const shouldParseBrowsers = !!browsers;
+  const hasTargets = shouldParseBrowsers || Object.keys(targets).length > 0;
+  const shouldSearchForConfig = !options.ignoreBrowserslistConfig && !hasTargets;
+  if (!browsers && shouldSearchForConfig) {
+    browsers = process.env.BROWSERSLIST;
+    if (!browsers) {
+      const configFile = options.configFile || process.env.BROWSERSLIST_CONFIG || _browserslist.findConfigFile(configPath);
+      if (configFile != null) {
+        onBrowserslistConfigFound == null || onBrowserslistConfigFound(configFile);
+        browsers = _browserslist.loadConfig({
+          config: configFile,
+          env: options.browserslistEnv
+        });
+      }
+    }
+    if (browsers == null) {
+      browsers = [];
+    }
+  }
+  if (esmodules && (esmodules !== "intersect" || !((_browsers = browsers) != null && _browsers.length))) {
+    browsers = Object.keys(ESM_SUPPORT).map(browser => `${browser} >= ${ESM_SUPPORT[browser]}`).join(", ");
+    esmodules = false;
+  }
+  if ((_browsers2 = browsers) != null && _browsers2.length) {
+    const queryBrowsers = resolveTargetsCached(browsers, options.browserslistEnv);
+    if (esmodules === "intersect") {
+      for (const browser of Object.keys(queryBrowsers)) {
+        if (browser !== "deno" && browser !== "ie") {
+          const esmSupportVersion = ESM_SUPPORT[browser === "opera_mobile" ? "op_mob" : browser];
+          if (esmSupportVersion) {
+            const version = queryBrowsers[browser];
+            queryBrowsers[browser] = (0, _utils.getHighestUnreleased)(version, (0, _utils.semverify)(esmSupportVersion), browser);
+          } else {
+            delete queryBrowsers[browser];
+          }
+        } else {
+          delete queryBrowsers[browser];
+        }
+      }
+    }
+    targets = Object.assign(queryBrowsers, targets);
+  }
+  const result = {};
+  const decimalWarnings = [];
+  for (const target of Object.keys(targets).sort()) {
+    const value = targets[target];
+    if (typeof value === "number" && value % 1 !== 0) {
+      decimalWarnings.push({
+        target,
+        value
+      });
+    }
+    const [parsedTarget, parsedValue] = target === "node" ? nodeTargetParser(value) : defaultTargetParser(target, value);
+    if (parsedValue) {
+      result[parsedTarget] = parsedValue;
+    }
+  }
+  outputDecimalWarning(decimalWarnings);
+  return result;
+}
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/helper-compilation-targets/lib/options.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TargetNames = void 0;
+const TargetNames = exports.TargetNames = {
+  node: "node",
+  deno: "deno",
+  chrome: "chrome",
+  opera: "opera",
+  edge: "edge",
+  firefox: "firefox",
+  safari: "safari",
+  ie: "ie",
+  ios: "ios",
+  android: "android",
+  electron: "electron",
+  samsung: "samsung",
+  rhino: "rhino",
+  opera_mobile: "opera_mobile"
+};
+
+//# sourceMappingURL=options.js.map

node_modules/@babel/helper-compilation-targets/lib/options.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TargetNames","exports","node","deno","chrome","opera","edge","firefox","safari","ie","ios","android","electron","samsung","rhino","opera_mobile"],"sources":["../src/options.ts"],"sourcesContent":["export const TargetNames = {\n  node: \"node\",\n  deno: \"deno\",\n  chrome: \"chrome\",\n  opera: \"opera\",\n  edge: \"edge\",\n  firefox: \"firefox\",\n  safari: \"safari\",\n  ie: \"ie\",\n  ios: \"ios\",\n  android: \"android\",\n  electron: \"electron\",\n  samsung: \"samsung\",\n  rhino: \"rhino\",\n  opera_mobile: \"opera_mobile\",\n};\n"],"mappings":";;;;;;AAAO,MAAMA,WAAW,GAAAC,OAAA,CAAAD,WAAA,GAAG;EACzBE,IAAI,EAAE,MAAM;EACZC,IAAI,EAAE,MAAM;EACZC,MAAM,EAAE,QAAQ;EAChBC,KAAK,EAAE,OAAO;EACdC,IAAI,EAAE,MAAM;EACZC,OAAO,EAAE,SAAS;EAClBC,MAAM,EAAE,QAAQ;EAChBC,EAAE,EAAE,IAAI;EACRC,GAAG,EAAE,KAAK;EACVC,OAAO,EAAE,SAAS;EAClBC,QAAQ,EAAE,UAAU;EACpBC,OAAO,EAAE,SAAS;EAClBC,KAAK,EAAE,OAAO;EACdC,YAAY,EAAE;AAChB,CAAC","ignoreList":[]}

node_modules/@babel/helper-compilation-targets/lib/pretty.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.prettifyTargets = prettifyTargets;
+exports.prettifyVersion = prettifyVersion;
+var _semver = require("semver");
+var _targets = require("./targets.js");
+function prettifyVersion(version) {
+  if (typeof version !== "string") {
+    return version;
+  }
+  const {
+    major,
+    minor,
+    patch
+  } = _semver.parse(version);
+  const parts = [major];
+  if (minor || patch) {
+    parts.push(minor);
+  }
+  if (patch) {
+    parts.push(patch);
+  }
+  return parts.join(".");
+}
+function prettifyTargets(targets) {
+  return Object.keys(targets).reduce((results, target) => {
+    let value = targets[target];
+    const unreleasedLabel = _targets.unreleasedLabels[target];
+    if (typeof value === "string" && unreleasedLabel !== value) {
+      value = prettifyVersion(value);
+    }
+    results[target] = value;
+    return results;
+  }, {});
+}
+
+//# sourceMappingURL=pretty.js.map

node_modules/@babel/helper-compilation-targets/lib/targets.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unreleasedLabels = exports.browserNameMap = void 0;
+const unreleasedLabels = exports.unreleasedLabels = {
+  safari: "tp"
+};
+const browserNameMap = exports.browserNameMap = {
+  and_chr: "chrome",
+  and_ff: "firefox",
+  android: "android",
+  chrome: "chrome",
+  edge: "edge",
+  firefox: "firefox",
+  ie: "ie",
+  ie_mob: "ie",
+  ios_saf: "ios",
+  node: "node",
+  deno: "deno",
+  op_mob: "opera_mobile",
+  opera: "opera",
+  safari: "safari",
+  samsung: "samsung"
+};
+
+//# sourceMappingURL=targets.js.map

node_modules/@babel/helper-compilation-targets/lib/utils.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getHighestUnreleased = getHighestUnreleased;
+exports.getLowestImplementedVersion = getLowestImplementedVersion;
+exports.getLowestUnreleased = getLowestUnreleased;
+exports.isUnreleasedVersion = isUnreleasedVersion;
+exports.semverMin = semverMin;
+exports.semverify = semverify;
+var _semver = require("semver");
+var _helperValidatorOption = require("@babel/helper-validator-option");
+var _targets = require("./targets.js");
+const versionRegExp = /^(?:\d+|\d(?:\d?[^\d\n\r\u2028\u2029]\d+|\d{2,}(?:[^\d\n\r\u2028\u2029]\d+)?))$/;
+const v = new _helperValidatorOption.OptionValidator("@babel/helper-compilation-targets");
+function semverMin(first, second) {
+  return first && _semver.lt(first, second) ? first : second;
+}
+function semverify(version) {
+  if (typeof version === "string" && _semver.valid(version)) {
+    return version;
+  }
+  v.invariant(typeof version === "number" || typeof version === "string" && versionRegExp.test(version), `'${version}' is not a valid version`);
+  version = version.toString();
+  let pos = 0;
+  let num = 0;
+  while ((pos = version.indexOf(".", pos + 1)) > 0) {
+    num++;
+  }
+  return version + ".0".repeat(2 - num);
+}
+function isUnreleasedVersion(version, env) {
+  const unreleasedLabel = _targets.unreleasedLabels[env];
+  return !!unreleasedLabel && unreleasedLabel === version.toString().toLowerCase();
+}
+function getLowestUnreleased(a, b, env) {
+  const unreleasedLabel = _targets.unreleasedLabels[env];
+  if (a === unreleasedLabel) {
+    return b;
+  }
+  if (b === unreleasedLabel) {
+    return a;
+  }
+  return semverMin(a, b);
+}
+function getHighestUnreleased(a, b, env) {
+  return getLowestUnreleased(a, b, env) === a ? b : a;
+}
+function getLowestImplementedVersion(plugin, environment) {
+  const result = plugin[environment];
+  if (!result && environment === "android") {
+    return plugin.chrome;
+  }
+  return result;
+}
+
+//# sourceMappingURL=utils.js.map

node_modules/@babel/helper-compilation-targets/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@babel/helper-compilation-targets",
+  "version": "7.28.6",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "license": "MIT",
+  "description": "Helper functions on Babel compilation targets",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-compilation-targets"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "babel",
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/compat-data": "^7.28.6",
+    "@babel/helper-validator-option": "^7.27.1",
+    "browserslist": "^4.24.0",
+    "lru-cache": "^5.1.1",
+    "semver": "^6.3.1"
+  },
+  "devDependencies": {
+    "@babel/helper-plugin-test-runner": "^7.27.1",
+    "@types/lru-cache": "^5.1.1",
+    "@types/semver": "^5.5.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}