up n_m

node_modules/@babel/plugin-transform-react-constant-elements/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/plugin-transform-react-constant-elements/README.md

@@ -0,0 +1,19 @@
+# @babel/plugin-transform-react-constant-elements
+
+> Treat React JSX elements as value types and hoist them to the highest scope
+
+See our website [@babel/plugin-transform-react-constant-elements](https://babeljs.io/docs/babel-plugin-transform-react-constant-elements) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/plugin-transform-react-constant-elements
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/plugin-transform-react-constant-elements --dev
+```

node_modules/@babel/plugin-transform-react-constant-elements/lib/index.js

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _helperPluginUtils = require("@babel/helper-plugin-utils");
+var _core = require("@babel/core");
+var _default = exports.default = (0, _helperPluginUtils.declare)((api, options) => {
+  api.assertVersion(7);
+  const {
+    allowMutablePropsOnTags
+  } = options;
+  if (allowMutablePropsOnTags != null && !Array.isArray(allowMutablePropsOnTags)) {
+    throw new Error(".allowMutablePropsOnTags must be an array, null, or undefined.");
+  }
+  const HOISTED = new WeakMap();
+  function declares(node, scope) {
+    if (_core.types.isJSXIdentifier(node, {
+      name: "this"
+    }) || _core.types.isJSXIdentifier(node, {
+      name: "arguments"
+    }) || _core.types.isJSXIdentifier(node, {
+      name: "super"
+    }) || _core.types.isJSXIdentifier(node, {
+      name: "new"
+    })) {
+      const {
+        path
+      } = scope;
+      return path.isFunctionParent() && !path.isArrowFunctionExpression();
+    }
+    return scope.hasOwnBinding(node.name);
+  }
+  function isHoistingScope({
+    path
+  }) {
+    return path.isFunctionParent() || path.isLoop() || path.isProgram();
+  }
+  function getHoistingScope(scope) {
+    while (!isHoistingScope(scope)) scope = scope.parent;
+    return scope;
+  }
+  const targetScopeVisitor = {
+    ReferencedIdentifier(path, state) {
+      const {
+        node
+      } = path;
+      let {
+        scope
+      } = path;
+      while (scope !== state.jsxScope) {
+        if (declares(node, scope)) return;
+        scope = scope.parent;
+      }
+      while (scope) {
+        if (scope === state.targetScope) return;
+        if (declares(node, scope)) break;
+        scope = scope.parent;
+      }
+      state.targetScope = getHoistingScope(scope);
+    }
+  };
+  const immutabilityVisitor = {
+    enter(path, state) {
+      var _expressionResult$deo;
+      const stop = () => {
+        state.isImmutable = false;
+        path.stop();
+      };
+      const skip = () => {
+        path.skip();
+      };
+      if (path.isJSXClosingElement()) {
+        skip();
+        return;
+      }
+      if (path.isJSXIdentifier({
+        name: "ref"
+      }) && path.parentPath.isJSXAttribute({
+        name: path.node
+      })) {
+        stop();
+        return;
+      }
+      if (path.isJSXIdentifier() || path.isJSXMemberExpression() || path.isJSXNamespacedName() || path.isImmutable()) {
+        return;
+      }
+      if (path.isIdentifier()) {
+        const binding = path.scope.getBinding(path.node.name);
+        if (binding && binding.constant) return;
+      }
+      const {
+        mutablePropsAllowed
+      } = state;
+      if (mutablePropsAllowed && path.isFunction()) {
+        path.traverse(targetScopeVisitor, state);
+        skip();
+        return;
+      }
+      if (!path.isPure()) {
+        stop();
+        return;
+      }
+      const expressionResult = path.evaluate();
+      if (expressionResult.confident) {
+        const {
+          value
+        } = expressionResult;
+        if (mutablePropsAllowed || value === null || typeof value !== "object" && typeof value !== "function") {
+          skip();
+          return;
+        }
+      } else if ((_expressionResult$deo = expressionResult.deopt) != null && _expressionResult$deo.isIdentifier()) {
+        return;
+      }
+      stop();
+    }
+  };
+  const hoistingVisitor = Object.assign({}, immutabilityVisitor, targetScopeVisitor);
+  return {
+    name: "transform-react-constant-elements",
+    visitor: {
+      JSXElement(path) {
+        var _jsxScope;
+        if (HOISTED.has(path.node)) return;
+        const name = path.node.openingElement.name;
+        let mutablePropsAllowed = false;
+        if (allowMutablePropsOnTags != null) {
+          let lastSegment = name;
+          while (_core.types.isJSXMemberExpression(lastSegment)) {
+            lastSegment = lastSegment.property;
+          }
+          const elementName = lastSegment.name;
+          mutablePropsAllowed = allowMutablePropsOnTags.includes(elementName);
+        }
+        let jsxScope;
+        let current = path;
+        while (!jsxScope && current.parentPath.isJSX()) {
+          current = current.parentPath;
+          jsxScope = HOISTED.get(current.node);
+        }
+        (_jsxScope = jsxScope) != null ? _jsxScope : jsxScope = path.scope;
+        HOISTED.set(path.node, jsxScope);
+        const visitorState = {
+          isImmutable: true,
+          mutablePropsAllowed,
+          jsxScope,
+          targetScope: path.scope.getProgramParent()
+        };
+        path.traverse(hoistingVisitor, visitorState);
+        if (!visitorState.isImmutable) return;
+        const {
+          targetScope
+        } = visitorState;
+        for (let currentScope = jsxScope;;) {
+          if (targetScope === currentScope) return;
+          if (isHoistingScope(currentScope)) break;
+          currentScope = currentScope.parent;
+          if (!currentScope) {
+            throw new Error("Internal @babel/plugin-transform-react-constant-elements error: " + "targetScope must be an ancestor of jsxScope. " + "This is a Babel bug, please report it.");
+          }
+        }
+        const id = path.scope.generateUidBasedOnNode(name);
+        targetScope.push({
+          id: _core.types.identifier(id)
+        });
+        HOISTED.set(path.node, targetScope);
+        let replacement = _core.template.expression.ast`
+          ${_core.types.identifier(id)} || (${_core.types.identifier(id)} = ${path.node})
+        `;
+        if (path.parentPath.isJSXElement() || path.parentPath.isJSXAttribute()) {
+          replacement = _core.types.jsxExpressionContainer(replacement);
+        }
+        path.replaceWith(replacement);
+      }
+    }
+  };
+});
+
+//# sourceMappingURL=index.js.map

node_modules/@babel/plugin-transform-react-constant-elements/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@babel/plugin-transform-react-constant-elements",
+  "version": "7.24.1",
+  "description": "Treat React JSX elements as value types and hoist them to the highest scope",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-transform-react-constant-elements"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-react-constant-elements",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-utils": "^7.24.0"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.24.1",
+    "@babel/helper-plugin-test-runner": "^7.24.1"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}