jsx-loc-plugin 0.1.22

package/dist/index.cjs

@@ -0,0 +1,131 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __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 });
+  }
+  return to;
+};
+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,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  withJsxLoc: () => withJsxLoc
+});
+module.exports = __toCommonJS(index_exports);
+var import_path = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_meta = {};
+var computedDirname;
+try {
+  computedDirname = import_path.default.dirname((0, import_url.fileURLToPath)(import_meta.url));
+} catch {
+  computedDirname = typeof __dirname !== "undefined" ? __dirname : "";
+}
+function withJsxLoc(nextConfig = {}, pluginOptions = {}) {
+  const loaderPath = import_path.default.join(computedDirname, "loader.cjs");
+  console.log(`[jsx-loc-plugin] Plugin loaded, loader path: ${loaderPath}`);
+  const loaderObj = {
+    loader: loaderPath,
+    options: { ...pluginOptions }
+  };
+  const jsxRule = {
+    test: /\.(jsx|tsx)$/,
+    enforce: "pre",
+    use: [loaderObj],
+    exclude: pluginOptions.exclude || /node_modules/
+  };
+  if (pluginOptions.include) {
+    jsxRule.include = pluginOptions.include;
+  }
+  const tsxLoaderConfig = {
+    condition: {
+      all: [
+        { not: "foreign" },
+        // Only match paths that end with .tsx (not directories)
+        { path: /\/[^/]+\.tsx$/ }
+      ]
+    },
+    loaders: [
+      {
+        loader: loaderPath,
+        options: { ...pluginOptions }
+      }
+    ]
+    // as: "*.tsx",
+  };
+  const jsxLoaderConfig = {
+    condition: {
+      all: [
+        { not: "foreign" },
+        // Only match paths that end with .jsx (not directories)
+        { path: /\/[^/]+\.jsx$/ }
+      ]
+    },
+    loaders: [
+      {
+        loader: loaderPath,
+        options: { ...pluginOptions }
+      }
+    ]
+    // as: "*.jsx",
+  };
+  const turbopackRules = {
+    "*.tsx": tsxLoaderConfig,
+    "*.jsx": jsxLoaderConfig
+  };
+  const existingTurbopack = nextConfig.turbopack || {};
+  const existingRules = existingTurbopack.rules || {};
+  const enhancedConfig = {
+    ...nextConfig,
+    // Configure webpack
+    webpack(config, options) {
+      if (!config.module) {
+        config.module = { rules: [] };
+      }
+      if (!config.module.rules) {
+        config.module.rules = [];
+      }
+      config.module.rules.unshift(jsxRule);
+      if (typeof nextConfig.webpack === "function") {
+        return nextConfig.webpack(config, options);
+      }
+      return config;
+    },
+    // Configure Turbopack (Next.js 16+ top-level turbopack key)
+    turbopack: {
+      ...existingTurbopack,
+      rules: {
+        ...existingRules,
+        ...turbopackRules
+      }
+    }
+  };
+  return enhancedConfig;
+}
+var index_default = withJsxLoc;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withJsxLoc
+});

package/dist/index.d.cts

@@ -0,0 +1,22 @@
+import { NextConfig } from 'next';
+
+/**
+ * Next.js plugin that adds data-loc attributes to JSX elements.
+ * Compatible with Next.js 16+ (supports both webpack and Turbopack)
+ */
+
+interface JsxLocPluginOptions {
+    /** RegExp patterns to include (default: all .jsx/.tsx files) */
+    include?: RegExp | RegExp[];
+    /** RegExp patterns to exclude (default: /node_modules/) */
+    exclude?: RegExp | RegExp[];
+}
+/**
+ * Next.js plugin that adds data-loc attributes to JSX elements
+ * to help with component tracking and debugging.
+ *
+ * Supports both webpack and Turbopack configurations.
+ */
+declare function withJsxLoc(nextConfig?: NextConfig, pluginOptions?: JsxLocPluginOptions): NextConfig;
+
+export { type JsxLocPluginOptions, withJsxLoc as default, withJsxLoc };

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+import { NextConfig } from 'next';
+
+/**
+ * Next.js plugin that adds data-loc attributes to JSX elements.
+ * Compatible with Next.js 16+ (supports both webpack and Turbopack)
+ */
+
+interface JsxLocPluginOptions {
+    /** RegExp patterns to include (default: all .jsx/.tsx files) */
+    include?: RegExp | RegExp[];
+    /** RegExp patterns to exclude (default: /node_modules/) */
+    exclude?: RegExp | RegExp[];
+}
+/**
+ * Next.js plugin that adds data-loc attributes to JSX elements
+ * to help with component tracking and debugging.
+ *
+ * Supports both webpack and Turbopack configurations.
+ */
+declare function withJsxLoc(nextConfig?: NextConfig, pluginOptions?: JsxLocPluginOptions): NextConfig;
+
+export { type JsxLocPluginOptions, withJsxLoc as default, withJsxLoc };

package/dist/index.js

@@ -0,0 +1,95 @@
+// src/index.ts
+import path from "path";
+import { fileURLToPath } from "url";
+var computedDirname;
+try {
+  computedDirname = path.dirname(fileURLToPath(import.meta.url));
+} catch {
+  computedDirname = typeof __dirname !== "undefined" ? __dirname : "";
+}
+function withJsxLoc(nextConfig = {}, pluginOptions = {}) {
+  const loaderPath = path.join(computedDirname, "loader.cjs");
+  console.log(`[jsx-loc-plugin] Plugin loaded, loader path: ${loaderPath}`);
+  const loaderObj = {
+    loader: loaderPath,
+    options: { ...pluginOptions }
+  };
+  const jsxRule = {
+    test: /\.(jsx|tsx)$/,
+    enforce: "pre",
+    use: [loaderObj],
+    exclude: pluginOptions.exclude || /node_modules/
+  };
+  if (pluginOptions.include) {
+    jsxRule.include = pluginOptions.include;
+  }
+  const tsxLoaderConfig = {
+    condition: {
+      all: [
+        { not: "foreign" },
+        // Only match paths that end with .tsx (not directories)
+        { path: /\/[^/]+\.tsx$/ }
+      ]
+    },
+    loaders: [
+      {
+        loader: loaderPath,
+        options: { ...pluginOptions }
+      }
+    ]
+    // as: "*.tsx",
+  };
+  const jsxLoaderConfig = {
+    condition: {
+      all: [
+        { not: "foreign" },
+        // Only match paths that end with .jsx (not directories)
+        { path: /\/[^/]+\.jsx$/ }
+      ]
+    },
+    loaders: [
+      {
+        loader: loaderPath,
+        options: { ...pluginOptions }
+      }
+    ]
+    // as: "*.jsx",
+  };
+  const turbopackRules = {
+    "*.tsx": tsxLoaderConfig,
+    "*.jsx": jsxLoaderConfig
+  };
+  const existingTurbopack = nextConfig.turbopack || {};
+  const existingRules = existingTurbopack.rules || {};
+  const enhancedConfig = {
+    ...nextConfig,
+    // Configure webpack
+    webpack(config, options) {
+      if (!config.module) {
+        config.module = { rules: [] };
+      }
+      if (!config.module.rules) {
+        config.module.rules = [];
+      }
+      config.module.rules.unshift(jsxRule);
+      if (typeof nextConfig.webpack === "function") {
+        return nextConfig.webpack(config, options);
+      }
+      return config;
+    },
+    // Configure Turbopack (Next.js 16+ top-level turbopack key)
+    turbopack: {
+      ...existingTurbopack,
+      rules: {
+        ...existingRules,
+        ...turbopackRules
+      }
+    }
+  };
+  return enhancedConfig;
+}
+var index_default = withJsxLoc;
+export {
+  index_default as default,
+  withJsxLoc
+};

package/dist/loader.cjs

@@ -0,0 +1,239 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __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 });
+  }
+  return to;
+};
+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,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  default: () => loader_default
+});
+module.exports = __toCommonJS(loader_exports);
+
+// src/transform.ts
+var import_parser = require("@babel/parser");
+var import_magic_string = __toESM(require("magic-string"), 1);
+var VALID_EXTENSIONS = /* @__PURE__ */ new Set([".jsx", ".tsx"]);
+var DEFAULT_PARSER_OPTIONS = {
+  sourceType: "module",
+  plugins: [
+    "jsx",
+    "typescript",
+    "decorators-legacy",
+    "classProperties",
+    "classPrivateProperties",
+    "classPrivateMethods",
+    "exportDefaultFrom",
+    "exportNamespaceFrom",
+    "asyncGenerators",
+    "functionBind",
+    "functionSent",
+    "dynamicImport",
+    "numericSeparator",
+    "optionalChaining",
+    "importMeta",
+    "bigInt",
+    "optionalCatchBinding",
+    "throwExpressions",
+    "nullishCoalescingOperator",
+    "topLevelAwait"
+  ],
+  errorRecovery: true
+};
+var SKIP_ELEMENTS = /* @__PURE__ */ new Set([
+  "Fragment",
+  "React.Fragment",
+  "Suspense",
+  "React.Suspense",
+  "StrictMode",
+  "React.StrictMode",
+  "Profiler",
+  "React.Profiler"
+]);
+function shouldProcessFile(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  return VALID_EXTENSIONS.has(ext);
+}
+function getElementName(node) {
+  if (!node || !node.name) return null;
+  const name = node.name;
+  if (name.type === "JSXIdentifier") {
+    return name.name;
+  }
+  if (name.type === "JSXMemberExpression") {
+    const parts = [];
+    let current = name;
+    while (current) {
+      if (current.type === "JSXMemberExpression") {
+        parts.unshift(current.property.name);
+        current = current.object;
+      } else if (current.type === "JSXIdentifier") {
+        parts.unshift(current.name);
+        break;
+      } else {
+        break;
+      }
+    }
+    return parts.join(".");
+  }
+  if (name.type === "JSXNamespacedName") {
+    return `${name.namespace.name}:${name.name.name}`;
+  }
+  return null;
+}
+function shouldSkipElement(elementName) {
+  if (!elementName) return true;
+  return SKIP_ELEMENTS.has(elementName);
+}
+function hasDataLocAttribute(node) {
+  if (!node.attributes) return false;
+  return node.attributes.some(
+    (attr) => attr.type === "JSXAttribute" && attr.name?.type === "JSXIdentifier" && attr.name.name === "data-loc"
+  );
+}
+function findInsertionPoint(node, source) {
+  let insertPos = node.name.end;
+  if (node.typeParameters) {
+    insertPos = node.typeParameters.end;
+  }
+  if (node.attributes && node.attributes.length > 0) {
+    const firstAttr = node.attributes[0];
+    const nameEnd = node.typeParameters ? node.typeParameters.end : node.name.end;
+    let pos = nameEnd;
+    while (pos < firstAttr.start && /\s/.test(source[pos])) {
+      pos++;
+    }
+    insertPos = pos;
+  }
+  return insertPos;
+}
+function normalizeFilePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function transformJsxCode(source, filePath, options = {}) {
+  const parserOptions = {
+    ...DEFAULT_PARSER_OPTIONS,
+    ...options.parserOptions
+  };
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(source, parserOptions);
+  } catch (error) {
+    console.error(`[jsx-loc] Failed to parse ${filePath}:`, error);
+    return null;
+  }
+  const magicString = new import_magic_string.default(source);
+  const normalizedPath = normalizeFilePath(filePath);
+  let hasChanges = false;
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    if (node.type === "JSXOpeningElement") {
+      const elementName = getElementName(node);
+      if (!shouldSkipElement(elementName) && !hasDataLocAttribute(node)) {
+        const loc = node.loc;
+        if (loc && loc.start) {
+          const line = loc.start.line;
+          const column = loc.start.column;
+          const locValue = `${normalizedPath}:${line}:${column}`;
+          const insertPos = findInsertionPoint(node, source);
+          magicString.appendLeft(insertPos, ` data-loc="${locValue}"`);
+          hasChanges = true;
+        }
+      }
+    }
+    for (const key of Object.keys(node)) {
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          walk(item);
+        }
+      } else if (child && typeof child === "object" && child.type) {
+        walk(child);
+      }
+    }
+  }
+  if (ast.program && ast.program.body) {
+    for (const node of ast.program.body) {
+      walk(node);
+    }
+  }
+  if (!hasChanges) {
+    return null;
+  }
+  return {
+    code: magicString.toString(),
+    map: magicString.generateMap({
+      source: filePath,
+      file: filePath,
+      includeContent: true
+    })
+  };
+}
+
+// src/loader.ts
+var import_fs = __toESM(require("fs"), 1);
+function isFile(filePath) {
+  try {
+    const stat = import_fs.default.statSync(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+async function jsxLocLoader(source) {
+  const callback = this.async();
+  console.log(`[jsx-loc-plugin] Processing: ${this.resourcePath}`);
+  if (!isFile(this.resourcePath)) {
+    console.log(`[jsx-loc-plugin] Skipping (not a file): ${this.resourcePath}`);
+    return callback(null, source);
+  }
+  if (!shouldProcessFile(this.resourcePath)) {
+    console.log(
+      `[jsx-loc-plugin] Skipping (shouldProcessFile=false): ${this.resourcePath}`
+    );
+    return callback(null, source);
+  }
+  try {
+    console.log(`[jsx-loc-plugin] resourcePath: ${this.resourcePath}`);
+    const result = transformJsxCode(source, this.resourcePath);
+    if (!result) {
+      console.log(
+        `[jsx-loc-plugin] No transform result for: ${this.resourcePath}`
+      );
+      return callback(null, source);
+    }
+    console.log(`[jsx-loc-plugin] Transformed: ${this.resourcePath}`);
+    callback(null, result.code, result.map);
+  } catch (error) {
+    console.error(
+      `[jsx-loc-plugin] Error processing file ${this.resourcePath}:`,
+      error
+    );
+    callback(null, source);
+  }
+}
+var loader_default = jsxLocLoader;

package/dist/loader.d.cts

@@ -0,0 +1,10 @@
+/**
+ * Webpack/Turbopack loader that transforms JSX to add data-loc attributes
+ */
+interface LoaderContext {
+    async(): (err: Error | null, content?: string, map?: any) => void;
+    resourcePath: string;
+}
+declare function jsxLocLoader(this: LoaderContext, source: string): Promise<void>;
+
+export { jsxLocLoader as default };

package/dist/loader.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Webpack/Turbopack loader that transforms JSX to add data-loc attributes
+ */
+interface LoaderContext {
+    async(): (err: Error | null, content?: string, map?: any) => void;
+    resourcePath: string;
+}
+declare function jsxLocLoader(this: LoaderContext, source: string): Promise<void>;
+
+export { jsxLocLoader as default };

package/dist/loader.js

@@ -0,0 +1,206 @@
+// src/transform.ts
+import { parse } from "@babel/parser";
+import MagicString from "magic-string";
+var VALID_EXTENSIONS = /* @__PURE__ */ new Set([".jsx", ".tsx"]);
+var DEFAULT_PARSER_OPTIONS = {
+  sourceType: "module",
+  plugins: [
+    "jsx",
+    "typescript",
+    "decorators-legacy",
+    "classProperties",
+    "classPrivateProperties",
+    "classPrivateMethods",
+    "exportDefaultFrom",
+    "exportNamespaceFrom",
+    "asyncGenerators",
+    "functionBind",
+    "functionSent",
+    "dynamicImport",
+    "numericSeparator",
+    "optionalChaining",
+    "importMeta",
+    "bigInt",
+    "optionalCatchBinding",
+    "throwExpressions",
+    "nullishCoalescingOperator",
+    "topLevelAwait"
+  ],
+  errorRecovery: true
+};
+var SKIP_ELEMENTS = /* @__PURE__ */ new Set([
+  "Fragment",
+  "React.Fragment",
+  "Suspense",
+  "React.Suspense",
+  "StrictMode",
+  "React.StrictMode",
+  "Profiler",
+  "React.Profiler"
+]);
+function shouldProcessFile(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  return VALID_EXTENSIONS.has(ext);
+}
+function getElementName(node) {
+  if (!node || !node.name) return null;
+  const name = node.name;
+  if (name.type === "JSXIdentifier") {
+    return name.name;
+  }
+  if (name.type === "JSXMemberExpression") {
+    const parts = [];
+    let current = name;
+    while (current) {
+      if (current.type === "JSXMemberExpression") {
+        parts.unshift(current.property.name);
+        current = current.object;
+      } else if (current.type === "JSXIdentifier") {
+        parts.unshift(current.name);
+        break;
+      } else {
+        break;
+      }
+    }
+    return parts.join(".");
+  }
+  if (name.type === "JSXNamespacedName") {
+    return `${name.namespace.name}:${name.name.name}`;
+  }
+  return null;
+}
+function shouldSkipElement(elementName) {
+  if (!elementName) return true;
+  return SKIP_ELEMENTS.has(elementName);
+}
+function hasDataLocAttribute(node) {
+  if (!node.attributes) return false;
+  return node.attributes.some(
+    (attr) => attr.type === "JSXAttribute" && attr.name?.type === "JSXIdentifier" && attr.name.name === "data-loc"
+  );
+}
+function findInsertionPoint(node, source) {
+  let insertPos = node.name.end;
+  if (node.typeParameters) {
+    insertPos = node.typeParameters.end;
+  }
+  if (node.attributes && node.attributes.length > 0) {
+    const firstAttr = node.attributes[0];
+    const nameEnd = node.typeParameters ? node.typeParameters.end : node.name.end;
+    let pos = nameEnd;
+    while (pos < firstAttr.start && /\s/.test(source[pos])) {
+      pos++;
+    }
+    insertPos = pos;
+  }
+  return insertPos;
+}
+function normalizeFilePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function transformJsxCode(source, filePath, options = {}) {
+  const parserOptions = {
+    ...DEFAULT_PARSER_OPTIONS,
+    ...options.parserOptions
+  };
+  let ast;
+  try {
+    ast = parse(source, parserOptions);
+  } catch (error) {
+    console.error(`[jsx-loc] Failed to parse ${filePath}:`, error);
+    return null;
+  }
+  const magicString = new MagicString(source);
+  const normalizedPath = normalizeFilePath(filePath);
+  let hasChanges = false;
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    if (node.type === "JSXOpeningElement") {
+      const elementName = getElementName(node);
+      if (!shouldSkipElement(elementName) && !hasDataLocAttribute(node)) {
+        const loc = node.loc;
+        if (loc && loc.start) {
+          const line = loc.start.line;
+          const column = loc.start.column;
+          const locValue = `${normalizedPath}:${line}:${column}`;
+          const insertPos = findInsertionPoint(node, source);
+          magicString.appendLeft(insertPos, ` data-loc="${locValue}"`);
+          hasChanges = true;
+        }
+      }
+    }
+    for (const key of Object.keys(node)) {
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          walk(item);
+        }
+      } else if (child && typeof child === "object" && child.type) {
+        walk(child);
+      }
+    }
+  }
+  if (ast.program && ast.program.body) {
+    for (const node of ast.program.body) {
+      walk(node);
+    }
+  }
+  if (!hasChanges) {
+    return null;
+  }
+  return {
+    code: magicString.toString(),
+    map: magicString.generateMap({
+      source: filePath,
+      file: filePath,
+      includeContent: true
+    })
+  };
+}
+
+// src/loader.ts
+import fs from "fs";
+function isFile(filePath) {
+  try {
+    const stat = fs.statSync(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+async function jsxLocLoader(source) {
+  const callback = this.async();
+  console.log(`[jsx-loc-plugin] Processing: ${this.resourcePath}`);
+  if (!isFile(this.resourcePath)) {
+    console.log(`[jsx-loc-plugin] Skipping (not a file): ${this.resourcePath}`);
+    return callback(null, source);
+  }
+  if (!shouldProcessFile(this.resourcePath)) {
+    console.log(
+      `[jsx-loc-plugin] Skipping (shouldProcessFile=false): ${this.resourcePath}`
+    );
+    return callback(null, source);
+  }
+  try {
+    console.log(`[jsx-loc-plugin] resourcePath: ${this.resourcePath}`);
+    const result = transformJsxCode(source, this.resourcePath);
+    if (!result) {
+      console.log(
+        `[jsx-loc-plugin] No transform result for: ${this.resourcePath}`
+      );
+      return callback(null, source);
+    }
+    console.log(`[jsx-loc-plugin] Transformed: ${this.resourcePath}`);
+    callback(null, result.code, result.map);
+  } catch (error) {
+    console.error(
+      `[jsx-loc-plugin] Error processing file ${this.resourcePath}:`,
+      error
+    );
+    callback(null, source);
+  }
+}
+var loader_default = jsxLocLoader;
+export {
+  loader_default as default
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "jsx-loc-plugin",
+  "version": "0.1.22",
+  "description": "Next.js plugin that adds data-loc attributes to JSX elements for UILint inspection",
+  "author": "Peter Suggate",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/peter-suggate/uilint.git",
+    "directory": "packages/jsx-loc-plugin"
+  },
+  "homepage": "https://github.com/peter-suggate/uilint#readme",
+  "bugs": {
+    "url": "https://github.com/peter-suggate/uilint/issues"
+  },
+  "keywords": [
+    "next",
+    "nextjs",
+    "jsx",
+    "uilint",
+    "plugin",
+    "webpack",
+    "turbopack"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@babel/parser": "^7.24.0",
+    "magic-string": "^0.30.10"
+  },
+  "devDependencies": {
+    "next": "^16.1.1",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "next": ">=14.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}