yyx990803

soda

sxzz

amour1688

@vue/babel-plugin-jsx

var __defProps = Object.defineProperties;

var __getOwnPropDesc = Object.getOwnPropertyDescriptor;

var __getOwnPropDescs = Object.getOwnPropertyDescriptors;

var __getOwnPropNames = Object.getOwnPropertyNames;

var __getOwnPropSymbols = Object.getOwnPropertySymbols;

var __getProtoOf = Object.getPrototypeOf;

var __hasOwnProp = Object.prototype.hasOwnProperty;

var __propIsEnum = Object.prototype.propertyIsEnumerable;

var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;

    for (var prop of __getOwnPropSymbols(b)) {

        __defNormalProp(a, prop, b[prop]);

var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));

    __defProp(target, name, { get: all[name], enumerable: true });

var __copyProps = (to, from, except, desc) => {

  if (from && typeof from === "object" || typeof from === "function") {

    for (let key of __getOwnPropNames(from))

      if (!__hasOwnProp.call(to, key) && key !== except)

        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });

var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(

  // If the importer is in node compatibility mode or this is not an ESM

  // file that has been converted to a CommonJS file using a Babel-

  // compatible transform (i.e. "__esModule" has not been set), then set

  // "default" to the CommonJS "module.exports" for node compatibility.

  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,

var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

module.exports = __toCommonJS(src_exports);

var t5 = __toESM(require("@babel/types"));

var import_template = __toESM(require("@babel/template"));

var import_plugin_syntax_jsx = __toESM(require("@babel/plugin-syntax-jsx"));

var import_helper_module_imports2 = require("@babel/helper-module-imports");

var t3 = __toESM(require("@babel/types"));

var import_helper_module_imports = require("@babel/helper-module-imports");

var t = __toESM(require("@babel/types"));

var import_html_tags = __toESM(require("html-tags"));

var import_svg_tags = __toESM(require("svg-tags"));

var SlotFlags = /* @__PURE__ */ ((SlotFlags2) => {

  SlotFlags2[SlotFlags2["STABLE"] = 1] = "STABLE";

  SlotFlags2[SlotFlags2["DYNAMIC"] = 2] = "DYNAMIC";

  SlotFlags2[SlotFlags2["FORWARDED"] = 3] = "FORWARDED";

var createIdentifier = (state, name) => state.get(name)();

var isDirective = (src) => src.startsWith("v-") || src.startsWith("v") && src.length >= 2 && src[1] >= "A" && src[1] <= "Z";

var shouldTransformedToSlots = (tag) => !(tag.match(RegExp(`^_?${FRAGMENT}\\d*$`)) || tag === KEEP_ALIVE);

var checkIsComponent = (path, state) => {

  if (namePath.isJSXMemberExpression()) {

    return shouldTransformedToSlots(namePath.node.property.name);

  return !((_b = (_a = state.opts).isCustomElement) == null ? void 0 : _b.call(_a, tag)) && shouldTransformedToSlots(tag) && !import_html_tags.default.includes(tag) && !import_svg_tags.default.includes(tag);

var transformJSXMemberExpression = (path) => {

  const propertyPath = path.node.property;

  const transformedObject = t.isJSXMemberExpression(objectPath) ? transformJSXMemberExpression(

  ) : t.isJSXIdentifier(objectPath) ? t.identifier(objectPath.name) : t.nullLiteral();

  const transformedProperty = t.identifier(propertyPath.name);

  return t.memberExpression(transformedObject, transformedProperty);

  const lines = node.value.split(/\r\n|\n|\r/);

  const str = transformText(path.node.value);

  return str !== "" ? t.stringLiteral(str) : null;

  const lines = text.split(/\r\n|\n|\r/);

  for (let i = 0; i < lines.length; i++) {

    const isLastLine = i === lines.length - 1;

    const isLastNonEmptyLine = i === lastNonEmptyLine;

    let trimmedLine = line.replace(/\t/g, " ");

      trimmedLine = trimmedLine.replace(/^[ ]+/, "");

      trimmedLine = trimmedLine.replace(/[ ]+$/, "");

var transformJSXExpressionContainer = (path) => path.get("expression").node;

var transformJSXSpreadChild = (path) => t.spreadElement(path.get("expression").node);

var walksScope = (path, name, slotFlag) => {

  if (path.scope.hasBinding(name) && path.parentPath) {

    if (t.isJSXElement(path.parentPath.node)) {

      path.parentPath.setData("slotFlag", slotFlag);

    walksScope(path.parentPath, name, slotFlag);

  if (parentPath.isAssignmentExpression()) {

        if (t.isIdentifier(child) && child.name === left.name) {

          const insertName = path.scope.generateUidIdentifier(child.name);

            t.variableDeclaration("const", [

                    t.blockStatement([t.returnStatement(child)])

var mergeAsArray = (existing, incoming) => {

  if (t.isArrayExpression(existing.value)) {

    existing.value.elements.push(incoming.value);

var dedupeProperties = (properties = [], mergeProps) => {

  const knownProps = /* @__PURE__ */ new Map();

      const existing = knownProps.get(name);

        if (name === "style" || name === "class" || name.startsWith("on")) {

    return elements.every((element) => element && isConstant(element));

      (property) => isConstant(property.value)

var transformJSXSpreadAttribute = (nodePath, path, mergeProps, args) => {

  const properties = t.isObjectExpression(argument.node) ? argument.node.properties : void 0;

    return t3.stringLiteral(transformText(valuePath.node.value));

  if (valuePath.isJSXExpressionContainer()) {

    return transformJSXExpressionContainer(valuePath);

  const isComponent = checkIsComponent(path.get("openingElement"), state);

  const props = path.get("openingElement").get("attributes");

  const dynamicPropNames = /* @__PURE__ */ new Set();

  const { mergeProps = true } = state.opts;

      let name = getJSXAttributeName(prop);

      const attributeValue = getJSXAttributeValue(prop, state);

      if (!isConstant(attributeValue) || name === "ref") {

        if (!isComponent && isOn(name) && // omit the flag for click handlers becaues hydration gives click

        name.toLowerCase() !== "onclick" && // omit v-model handlers

        name !== "onUpdate:modelValue") {

          hasHydrationEventBinding = true;

        } else if (name === "class" && !isComponent) {

        } else if (name === "style" && !isComponent) {

        } else if (name !== "key" && !isDirective(name) && name !== "on") {

      if (state.opts.transformOn && (name === "on" || name === "nativeOn")) {

            (0, import_helper_module_imports.addDefault)(path, "@vue/babel-helper-vue-transform-on", {

          t3.callExpression(state.get("transformOn"), [

            attributeValue || t3.booleanLiteral(true)

        const { directive, modifiers, values, args, directiveName } = parseDirectives_default({

          directives.push(t3.arrayExpression(directive));

        } else if (directiveName === "html") {

            t3.objectProperty(t3.stringLiteral("innerHTML"), values[0])

          dynamicPropNames.add("innerHTML");

        } else if (directiveName === "text") {

            t3.objectProperty(t3.stringLiteral("textContent"), values[0])

          dynamicPropNames.add("textContent");

        if (["models", "model"].includes(directiveName)) {

          values.forEach((value, index) => {

            const propName = args[index];

            const isDynamic = propName && !t3.isStringLiteral(propName) && !t3.isNullLiteral(propName);

  "description": "Babel plugin for Vue 3 JSX",

  "author": "Amour1688 <lcz_1996@foxmail.com>",

  "homepage": "https://github.com/vuejs/babel-plugin-jsx/tree/dev/packages/babel-plugin-jsx#readme",

    "url": "git+https://github.com/vuejs/babel-plugin-jsx"

    "url": "https://github.com/vuejs/babel-plugin-jsx/issues"

    "@babel/helper-module-imports": "^7.22.5",

    "@babel/plugin-syntax-jsx": "^7.22.5",

    "@vue/babel-helper-vue-transform-on": "^1.1.4"

    "@vue/babel-helper-vue-transform-on": "^1.1.5"

		@@ -125,4 +125,7 @@ "use strict";
		var transformJSXText = (path) => {
		const { node } = path;
		const lines = node.value.split(/\r\n\|\n\|\r/);
		const str = transformText(path.node.value);
		return str !== "" ? t.stringLiteral(str) : null;
		};
		var transformText = (text) => {
		const lines = text.split(/\r\n\|\n\|\r/);
		let lastNonEmptyLine = 0;
		@@ -154,3 +157,3 @@ for (let i = 0; i < lines.length; i++) {
		}
		return str !== "" ? t.stringLiteral(str) : null;
		return str;
		};
		@@ -407,3 +410,3 @@ var transformJSXExpressionContainer = (path) => path.get("expression").node;
		if (valuePath.isStringLiteral()) {
		return transformJSXText(valuePath);
		return t3.stringLiteral(transformText(valuePath.node.value));
		}
		@@ -410,0 +413,0 @@ if (valuePath.isJSXExpressionContainer()) {

		{
		"name": "@vue/babel-plugin-jsx",
		"version": "1.1.4",
		"version": "1.1.5",
		"description": "Babel plugin for Vue 3 JSX",
		@@ -30,3 +30,3 @@ "author": "Amour1688 <lcz_1996@foxmail.com>",
		"svg-tags": "^1.0.0",
		"@vue/babel-helper-vue-transform-on": "^1.1.4"
		"@vue/babel-helper-vue-transform-on": "^1.1.5"
		},
		@@ -33,0 +33,0 @@ "devDependencies": {

Improved metrics

Dependency changes