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 __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
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
));

// src/compat.ts
import { ASTUtils } from "@typescript-eslint/utils";
function getSourceCode(context) {
  if (typeof context.getSourceCode === "function") {
    return context.getSourceCode();
  }
  return context.sourceCode;
}
function getScope(context, node) {
  const sourceCode = getSourceCode(context);
  if (typeof sourceCode.getScope === "function") {
    return sourceCode.getScope(node);
  }
  if (typeof context.getScope === "function") {
    return context.getScope();
  }
  return context.sourceCode.getScope(node);
}
function findVariable(context, node) {
  return ASTUtils.findVariable(getScope(context, node), node);
}
function markVariableAsUsed(context, name2, node) {
  if (typeof context.markVariableAsUsed === "function") {
    context.markVariableAsUsed(name2);
  } else {
    getSourceCode(context).markVariableAsUsed(name2, node);
  }
}
var init_compat = __esm({
  "src/compat.ts"() {
    "use strict";
  }
});

// src/utils.ts
function findParent(node, predicate) {
  return node.parent ? find(node.parent, predicate) : null;
}
function trace(node, context) {
  if (node.type === "Identifier") {
    const variable = findVariable(context, node);
    if (!variable) return node;
    const def = variable.defs[0];
    switch (def?.type) {
      case "FunctionName":
      case "ClassName":
      case "ImportBinding":
        return def.node;
      case "Variable":
        if ((def.node.parent.kind === "const" || variable.references.every((ref) => ref.init || ref.isReadOnly())) && def.node.id.type === "Identifier" && def.node.init) {
          return trace(def.node.init, context);
        }
    }
  }
  return node;
}
function ignoreTransparentWrappers(node, up = false) {
  if (node.type === "TSAsExpression" || node.type === "TSNonNullExpression" || node.type === "TSSatisfiesExpression") {
    const next = up ? node.parent : node.expression;
    if (next) {
      return ignoreTransparentWrappers(next, up);
    }
  }
  return node;
}
function findInScope(node, scope, predicate) {
  const found = find(node, (node2) => node2 === scope || predicate(node2));
  return found === scope && !predicate(node) ? null : found;
}
function appendImports(fixer, sourceCode, importNode, identifiers) {
  const identifiersString = identifiers.join(", ");
  const reversedSpecifiers = importNode.specifiers.slice().reverse();
  const lastSpecifier = reversedSpecifiers.find((s) => s.type === "ImportSpecifier");
  if (lastSpecifier) {
    return fixer.insertTextAfter(lastSpecifier, `, ${identifiersString}`);
  }
  const otherSpecifier = importNode.specifiers.find(
    (s) => s.type === "ImportDefaultSpecifier" || s.type === "ImportNamespaceSpecifier"
  );
  if (otherSpecifier) {
    return fixer.insertTextAfter(otherSpecifier, `, { ${identifiersString} }`);
  }
  if (importNode.specifiers.length === 0) {
    const [importToken, maybeBrace] = sourceCode.getFirstTokens(importNode, { count: 2 });
    if (maybeBrace?.value === "{") {
      return fixer.insertTextAfter(maybeBrace, ` ${identifiersString} `);
    } else {
      return importToken ? fixer.insertTextAfter(importToken, ` { ${identifiersString} } from`) : null;
    }
  }
  return null;
}
function insertImports(fixer, sourceCode, source, identifiers, aboveImport, isType = false) {
  const identifiersString = identifiers.join(", ");
  const programNode = sourceCode.ast;
  const firstImport = aboveImport ?? programNode.body.find((n) => n.type === "ImportDeclaration");
  if (firstImport) {
    return fixer.insertTextBeforeRange(
      (getCommentBefore(firstImport, sourceCode) ?? firstImport).range,
      `import ${isType ? "type " : ""}{ ${identifiersString} } from "${source}";
`
    );
  }
  return fixer.insertTextBeforeRange(
    [0, 0],
    `import ${isType ? "type " : ""}{ ${identifiersString} } from "${source}";
`
  );
}
function removeSpecifier(fixer, sourceCode, specifier, pure = true) {
  const declaration = specifier.parent;
  if (declaration.specifiers.length === 1 && pure) {
    return fixer.remove(declaration);
  }
  const maybeComma = sourceCode.getTokenAfter(specifier);
  if (maybeComma?.value === ",") {
    return fixer.removeRange([specifier.range[0], maybeComma.range[1]]);
  }
  return fixer.remove(specifier);
}
function jsxPropName(prop) {
  if (prop.name.type === "JSXNamespacedName") {
    return `${prop.name.namespace.name}:${prop.name.name.name}`;
  }
  return prop.name.name;
}
function* jsxGetAllProps(props) {
  for (const attr of props) {
    if (attr.type === "JSXSpreadAttribute" && attr.argument.type === "ObjectExpression") {
      for (const property of attr.argument.properties) {
        if (property.type === "Property") {
          if (property.key.type === "Identifier") {
            yield [property.key.name, property.key];
          } else if (property.key.type === "Literal") {
            yield [String(property.key.value), property.key];
          }
        }
      }
    } else if (attr.type === "JSXAttribute") {
      yield [jsxPropName(attr), attr.name];
    }
  }
}
function jsxHasProp(props, prop) {
  for (const [p] of jsxGetAllProps(props)) {
    if (p === prop) return true;
  }
  return false;
}
function jsxGetProp(props, prop) {
  return props.find(
    (attribute) => attribute.type !== "JSXSpreadAttribute" && prop === jsxPropName(attribute)
  );
}
var domElementRegex, isDOMElementName, propsRegex, isPropsByName, formatList, find, FUNCTION_TYPES, isFunctionNode, PROGRAM_OR_FUNCTION_TYPES, isProgramOrFunctionNode, isJSXElementOrFragment, getFunctionName, getCommentBefore, trackImports;
var init_utils = __esm({
  "src/utils.ts"() {
    "use strict";
    init_compat();
    domElementRegex = /^[a-z]/;
    isDOMElementName = (name2) => domElementRegex.test(name2);
    propsRegex = /[pP]rops/;
    isPropsByName = (name2) => propsRegex.test(name2);
    formatList = (strings) => {
      if (strings.length === 0) {
        return "";
      } else if (strings.length === 1) {
        return `'${strings[0]}'`;
      } else if (strings.length === 2) {
        return `'${strings[0]}' and '${strings[1]}'`;
      } else {
        const last = strings.length - 1;
        return `${strings.slice(0, last).map((s) => `'${s}'`).join(", ")}, and '${strings[last]}'`;
      }
    };
    find = (node, predicate) => {
      let n = node;
      while (n) {
        const result = predicate(n);
        if (result) {
          return n;
        }
        n = n.parent;
      }
      return null;
    };
    FUNCTION_TYPES = ["FunctionExpression", "ArrowFunctionExpression", "FunctionDeclaration"];
    isFunctionNode = (node) => !!node && FUNCTION_TYPES.includes(node.type);
    PROGRAM_OR_FUNCTION_TYPES = ["Program"].concat(FUNCTION_TYPES);
    isProgramOrFunctionNode = (node) => !!node && PROGRAM_OR_FUNCTION_TYPES.includes(node.type);
    isJSXElementOrFragment = (node) => node?.type === "JSXElement" || node?.type === "JSXFragment";
    getFunctionName = (node) => {
      if ((node.type === "FunctionDeclaration" || node.type === "FunctionExpression") && node.id != null) {
        return node.id.name;
      }
      if (node.parent?.type === "VariableDeclarator" && node.parent.id.type === "Identifier") {
        return node.parent.id.name;
      }
      return null;
    };
    getCommentBefore = (node, sourceCode) => sourceCode.getCommentsBefore(node).find((comment) => comment.loc.end.line >= node.loc.start.line - 1);
    trackImports = (fromModule = /^solid-js(?:\/?|\b)/) => {
      const importMap = /* @__PURE__ */ new Map();
      const handleImportDeclaration = (node) => {
        if (fromModule.test(node.source.value)) {
          for (const specifier of node.specifiers) {
            if (specifier.type === "ImportSpecifier") {
              importMap.set(specifier.imported.name, specifier.local.name);
            }
          }
        }
      };
      const matchImport = (imports, str) => {
        const importArr = Array.isArray(imports) ? imports : [imports];
        return importArr.find((i) => importMap.get(i) === str);
      };
      return { matchImport, handleImportDeclaration };
    };
  }
});

// src/rules/components-return-once.ts
import { ESLintUtils } from "@typescript-eslint/utils";
var createRule, isNothing, getLineLength, components_return_once_default;
var init_components_return_once = __esm({
  "src/rules/components-return-once.ts"() {
    "use strict";
    init_utils();
    init_compat();
    createRule = ESLintUtils.RuleCreator.withoutDocs;
    isNothing = (node) => {
      if (!node) {
        return true;
      }
      switch (node.type) {
        case "Literal":
          return [null, void 0, false, ""].includes(node.value);
        case "JSXFragment":
          return !node.children || node.children.every(isNothing);
        default:
          return false;
      }
    };
    getLineLength = (loc) => loc.end.line - loc.start.line + 1;
    components_return_once_default = createRule({
      meta: {
        type: "problem",
        docs: {
          description: "Disallow early returns in components. Solid components only run once, and so conditionals should be inside JSX.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/components-return-once.md"
        },
        fixable: "code",
        schema: [],
        messages: {
          noEarlyReturn: "Solid components run once, so an early return breaks reactivity. Move the condition inside a JSX element, such as a fragment or <Show />.",
          noConditionalReturn: "Solid components run once, so a conditional return breaks reactivity. Move the condition inside a JSX element, such as a fragment or <Show />."
        }
      },
      defaultOptions: [],
      create(context) {
        const functionStack = [];
        const putIntoJSX = (node) => {
          const text = getSourceCode(context).getText(node);
          return node.type === "JSXElement" || node.type === "JSXFragment" ? text : `{${text}}`;
        };
        const currentFunction = () => functionStack[functionStack.length - 1];
        const onFunctionEnter = (node) => {
          let lastReturn;
          if (node.body.type === "BlockStatement") {
            const last = node.body.body.findLast((node2) => !node2.type.endsWith("Declaration"));
            if (last && last.type === "ReturnStatement") {
              lastReturn = last;
            }
          }
          functionStack.push({ isComponent: false, lastReturn, earlyReturns: [] });
        };
        const onFunctionExit = (node) => {
          if (
            // "render props" aren't components
            getFunctionName(node)?.match(/^[a-z]/) || node.parent?.type === "JSXExpressionContainer" || // ignore createMemo(() => conditional JSX), report HOC(() => conditional JSX)
            node.parent?.type === "CallExpression" && node.parent.arguments.some((n) => n === node) && !node.parent.callee.name?.match(/^[A-Z]/)
          ) {
            currentFunction().isComponent = false;
          }
          if (currentFunction().isComponent) {
            currentFunction().earlyReturns.forEach((earlyReturn) => {
              context.report({
                node: earlyReturn,
                messageId: "noEarlyReturn"
              });
            });
            const argument = currentFunction().lastReturn?.argument;
            if (argument?.type === "ConditionalExpression") {
              const sourceCode = getSourceCode(context);
              context.report({
                node: argument.parent,
                messageId: "noConditionalReturn",
                fix: (fixer) => {
                  const { test, consequent, alternate } = argument;
                  const conditions = [{ test, consequent }];
                  let fallback = alternate;
                  while (fallback.type === "ConditionalExpression") {
                    conditions.push({ test: fallback.test, consequent: fallback.consequent });
                    fallback = fallback.alternate;
                  }
                  if (conditions.length >= 2) {
                    const fallbackStr = !isNothing(fallback) ? ` fallback={${sourceCode.getText(fallback)}}` : "";
                    return fixer.replaceText(
                      argument,
                      `<Switch${fallbackStr}>
${conditions.map(
                        ({ test: test2, consequent: consequent2 }) => `<Match when={${sourceCode.getText(test2)}}>${putIntoJSX(
                          consequent2
                        )}</Match>`
                      ).join("\n")}
</Switch>`
                    );
                  }
                  if (isNothing(consequent)) {
                    return fixer.replaceText(
                      argument,
                      `<Show when={!(${sourceCode.getText(test)})}>${putIntoJSX(alternate)}</Show>`
                    );
                  }
                  if (isNothing(fallback) || getLineLength(consequent.loc) >= getLineLength(alternate.loc) * 1.5) {
                    const fallbackStr = !isNothing(fallback) ? ` fallback={${sourceCode.getText(fallback)}}` : "";
                    return fixer.replaceText(
                      argument,
                      `<Show when={${sourceCode.getText(test)}}${fallbackStr}>${putIntoJSX(
                        consequent
                      )}</Show>`
                    );
                  }
                  return fixer.replaceText(argument, `<>${putIntoJSX(argument)}</>`);
                }
              });
            } else if (argument?.type === "LogicalExpression") {
              if (argument.operator === "&&") {
                const sourceCode = getSourceCode(context);
                context.report({
                  node: argument,
                  messageId: "noConditionalReturn",
                  fix: (fixer) => {
                    const { left: test, right: consequent } = argument;
                    return fixer.replaceText(
                      argument,
                      `<Show when={${sourceCode.getText(test)}}>${putIntoJSX(consequent)}</Show>`
                    );
                  }
                });
              } else {
                context.report({
                  node: argument,
                  messageId: "noConditionalReturn"
                });
              }
            }
          }
          functionStack.pop();
        };
        return {
          FunctionDeclaration: onFunctionEnter,
          FunctionExpression: onFunctionEnter,
          ArrowFunctionExpression: onFunctionEnter,
          "FunctionDeclaration:exit": onFunctionExit,
          "FunctionExpression:exit": onFunctionExit,
          "ArrowFunctionExpression:exit": onFunctionExit,
          JSXElement() {
            if (functionStack.length) {
              currentFunction().isComponent = true;
            }
          },
          JSXFragment() {
            if (functionStack.length) {
              currentFunction().isComponent = true;
            }
          },
          ReturnStatement(node) {
            if (functionStack.length && node !== currentFunction().lastReturn) {
              currentFunction().earlyReturns.push(node);
            }
          }
        };
      }
    });
  }
});

// src/rules/event-handlers.ts
import { ESLintUtils as ESLintUtils2, ASTUtils as ASTUtils2 } from "@typescript-eslint/utils";
var createRule2, getStaticValue, COMMON_EVENTS, COMMON_EVENTS_MAP, NONSTANDARD_EVENTS_MAP, isCommonHandlerName, getCommonEventHandlerName, isNonstandardEventName, getStandardEventHandlerName, event_handlers_default;
var init_event_handlers = __esm({
  "src/rules/event-handlers.ts"() {
    "use strict";
    init_utils();
    init_compat();
    createRule2 = ESLintUtils2.RuleCreator.withoutDocs;
    ({ getStaticValue } = ASTUtils2);
    COMMON_EVENTS = [
      "onAnimationEnd",
      "onAnimationIteration",
      "onAnimationStart",
      "onBeforeInput",
      "onBlur",
      "onChange",
      "onClick",
      "onContextMenu",
      "onCopy",
      "onCut",
      "onDblClick",
      "onDrag",
      "onDragEnd",
      "onDragEnter",
      "onDragExit",
      "onDragLeave",
      "onDragOver",
      "onDragStart",
      "onDrop",
      "onError",
      "onFocus",
      "onFocusIn",
      "onFocusOut",
      "onGotPointerCapture",
      "onInput",
      "onInvalid",
      "onKeyDown",
      "onKeyPress",
      "onKeyUp",
      "onLoad",
      "onLostPointerCapture",
      "onMouseDown",
      "onMouseEnter",
      "onMouseLeave",
      "onMouseMove",
      "onMouseOut",
      "onMouseOver",
      "onMouseUp",
      "onPaste",
      "onPointerCancel",
      "onPointerDown",
      "onPointerEnter",
      "onPointerLeave",
      "onPointerMove",
      "onPointerOut",
      "onPointerOver",
      "onPointerUp",
      "onReset",
      "onScroll",
      "onSelect",
      "onSubmit",
      "onToggle",
      "onTouchCancel",
      "onTouchEnd",
      "onTouchMove",
      "onTouchStart",
      "onTransitionEnd",
      "onWheel"
    ];
    COMMON_EVENTS_MAP = new Map(
      function* () {
        for (const event of COMMON_EVENTS) {
          yield [event.toLowerCase(), event];
        }
      }()
    );
    NONSTANDARD_EVENTS_MAP = {
      ondoubleclick: "onDblClick"
    };
    isCommonHandlerName = (lowercaseHandlerName) => COMMON_EVENTS_MAP.has(lowercaseHandlerName);
    getCommonEventHandlerName = (lowercaseHandlerName) => COMMON_EVENTS_MAP.get(lowercaseHandlerName);
    isNonstandardEventName = (lowercaseEventName) => Boolean(NONSTANDARD_EVENTS_MAP[lowercaseEventName]);
    getStandardEventHandlerName = (lowercaseEventName) => NONSTANDARD_EVENTS_MAP[lowercaseEventName];
    event_handlers_default = createRule2({
      meta: {
        type: "problem",
        docs: {
          description: "Enforce naming DOM element event handlers consistently and prevent Solid's analysis from misunderstanding whether a prop should be an event handler.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/event-handlers.md"
        },
        fixable: "code",
        hasSuggestions: true,
        schema: [
          {
            type: "object",
            properties: {
              ignoreCase: {
                type: "boolean",
                description: "if true, don't warn on ambiguously named event handlers like `onclick` or `onchange`",
                default: false
              },
              warnOnSpread: {
                type: "boolean",
                description: "if true, warn when spreading event handlers onto JSX. Enable for Solid < v1.6.",
                default: false
              }
            },
            additionalProperties: false
          }
        ],
        messages: {
          "detected-attr": 'The {{name}} prop is named as an event handler (starts with "on"), but Solid knows its value ({{staticValue}}) is a string or number, so it will be treated as an attribute. If this is intentional, name this prop attr:{{name}}.',
          naming: "The {{name}} prop is ambiguous. If it is an event handler, change it to {{handlerName}}. If it is an attribute, change it to {{attrName}}.",
          capitalization: "The {{name}} prop should be renamed to {{fixedName}} for readability.",
          nonstandard: "The {{name}} prop should be renamed to {{fixedName}}, because it's not a standard event handler.",
          "make-handler": "Change the {{name}} prop to {{handlerName}}.",
          "make-attr": "Change the {{name}} prop to {{attrName}}.",
          "spread-handler": "The {{name}} prop should be added as a JSX attribute, not spread in. Solid doesn't add listeners when spreading into JSX."
        }
      },
      defaultOptions: [],
      create(context) {
        const sourceCode = getSourceCode(context);
        return {
          JSXAttribute(node) {
            const openingElement = node.parent;
            if (openingElement.name.type !== "JSXIdentifier" || !isDOMElementName(openingElement.name.name)) {
              return;
            }
            if (node.name.type === "JSXNamespacedName") {
              return;
            }
            const { name: name2 } = node.name;
            if (!/^on[a-zA-Z]/.test(name2)) {
              return;
            }
            let staticValue = null;
            if (node.value?.type === "JSXExpressionContainer" && node.value.expression.type !== "JSXEmptyExpression" && node.value.expression.type !== "ArrayExpression" && // array syntax prevents inlining
            (staticValue = getStaticValue(node.value.expression, getScope(context, node))) !== null && (typeof staticValue.value === "string" || typeof staticValue.value === "number")) {
              context.report({
                node,
                messageId: "detected-attr",
                data: {
                  name: name2,
                  staticValue: staticValue.value
                }
              });
            } else if (node.value === null || node.value?.type === "Literal") {
              context.report({
                node,
                messageId: "detected-attr",
                data: {
                  name: name2,
                  staticValue: node.value !== null ? node.value.value : true
                }
              });
            } else if (!context.options[0]?.ignoreCase) {
              const lowercaseHandlerName = name2.toLowerCase();
              if (isNonstandardEventName(lowercaseHandlerName)) {
                const fixedName = getStandardEventHandlerName(lowercaseHandlerName);
                context.report({
                  node: node.name,
                  messageId: "nonstandard",
                  data: { name: name2, fixedName },
                  fix: (fixer) => fixer.replaceText(node.name, fixedName)
                });
              } else if (isCommonHandlerName(lowercaseHandlerName)) {
                const fixedName = getCommonEventHandlerName(lowercaseHandlerName);
                if (fixedName !== name2) {
                  context.report({
                    node: node.name,
                    messageId: "capitalization",
                    data: { name: name2, fixedName },
                    fix: (fixer) => fixer.replaceText(node.name, fixedName)
                  });
                }
              } else if (name2[2] === name2[2].toLowerCase()) {
                const handlerName = `on${name2[2].toUpperCase()}${name2.slice(3)}`;
                const attrName = `attr:${name2}`;
                context.report({
                  node: node.name,
                  messageId: "naming",
                  data: { name: name2, attrName, handlerName },
                  suggest: [
                    {
                      messageId: "make-handler",
                      data: { name: name2, handlerName },
                      fix: (fixer) => fixer.replaceText(node.name, handlerName)
                    },
                    {
                      messageId: "make-attr",
                      data: { name: name2, attrName },
                      fix: (fixer) => fixer.replaceText(node.name, attrName)
                    }
                  ]
                });
              }
            }
          },
          Property(node) {
            if (context.options[0]?.warnOnSpread && node.parent?.type === "ObjectExpression" && node.parent.parent?.type === "JSXSpreadAttribute" && node.parent.parent.parent?.type === "JSXOpeningElement") {
              const openingElement = node.parent.parent.parent;
              if (openingElement.name.type === "JSXIdentifier" && isDOMElementName(openingElement.name.name)) {
                if (node.key.type === "Identifier" && /^on/.test(node.key.name)) {
                  const handlerName = node.key.name;
                  context.report({
                    node,
                    messageId: "spread-handler",
                    data: {
                      name: node.key.name
                    },
                    *fix(fixer) {
                      const commaAfter = sourceCode.getTokenAfter(node);
                      yield fixer.remove(
                        node.parent.properties.length === 1 ? node.parent.parent : node
                      );
                      if (commaAfter?.value === ",") {
                        yield fixer.remove(commaAfter);
                      }
                      yield fixer.insertTextAfter(
                        node.parent.parent,
                        ` ${handlerName}={${sourceCode.getText(node.value)}}`
                      );
                    }
                  });
                }
              }
            }
          }
        };
      }
    });
  }
});

// src/rules/imports.ts
import { ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
var createRule3, primitiveMap, typeMap, sourceRegex, isSource, imports_default;
var init_imports = __esm({
  "src/rules/imports.ts"() {
    "use strict";
    init_utils();
    init_compat();
    createRule3 = ESLintUtils3.RuleCreator.withoutDocs;
    primitiveMap = /* @__PURE__ */ new Map();
    for (const primitive of [
      "createSignal",
      "createEffect",
      "createMemo",
      "createResource",
      "onMount",
      "onCleanup",
      "onError",
      "untrack",
      "batch",
      "on",
      "createRoot",
      "getOwner",
      "runWithOwner",
      "mergeProps",
      "splitProps",
      "useTransition",
      "observable",
      "from",
      "mapArray",
      "indexArray",
      "createContext",
      "useContext",
      "children",
      "lazy",
      "createUniqueId",
      "createDeferred",
      "createRenderEffect",
      "createComputed",
      "createReaction",
      "createSelector",
      "DEV",
      "For",
      "Show",
      "Switch",
      "Match",
      "Index",
      "ErrorBoundary",
      "Suspense",
      "SuspenseList"
    ]) {
      primitiveMap.set(primitive, "solid-js");
    }
    for (const primitive of [
      "Portal",
      "render",
      "hydrate",
      "renderToString",
      "renderToStream",
      "isServer",
      "renderToStringAsync",
      "generateHydrationScript",
      "HydrationScript",
      "Dynamic"
    ]) {
      primitiveMap.set(primitive, "solid-js/web");
    }
    for (const primitive of [
      "createStore",
      "produce",
      "reconcile",
      "unwrap",
      "createMutable",
      "modifyMutable"
    ]) {
      primitiveMap.set(primitive, "solid-js/store");
    }
    typeMap = /* @__PURE__ */ new Map();
    for (const type of [
      "Signal",
      "Accessor",
      "Setter",
      "Resource",
      "ResourceActions",
      "ResourceOptions",
      "ResourceReturn",
      "ResourceFetcher",
      "InitializedResourceReturn",
      "Component",
      "VoidProps",
      "VoidComponent",
      "ParentProps",
      "ParentComponent",
      "FlowProps",
      "FlowComponent",
      "ValidComponent",
      "ComponentProps",
      "Ref",
      "MergeProps",
      "SplitPrips",
      "Context",
      "JSX",
      "ResolvedChildren",
      "MatchProps"
    ]) {
      typeMap.set(type, "solid-js");
    }
    for (const type of [
      /* "JSX", */
      "MountableElement"
    ]) {
      typeMap.set(type, "solid-js/web");
    }
    for (const type of ["StoreNode", "Store", "SetStoreFunction"]) {
      typeMap.set(type, "solid-js/store");
    }
    sourceRegex = /^solid-js(?:\/web|\/store)?$/;
    isSource = (source) => sourceRegex.test(source);
    imports_default = createRule3({
      meta: {
        type: "suggestion",
        docs: {
          description: 'Enforce consistent imports from "solid-js", "solid-js/web", and "solid-js/store".',
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/imports.md"
        },
        fixable: "code",
        schema: [],
        messages: {
          "prefer-source": 'Prefer importing {{name}} from "{{source}}".'
        }
      },
      defaultOptions: [],
      create(context) {
        return {
          ImportDeclaration(node) {
            const source = node.source.value;
            if (!isSource(source)) return;
            for (const specifier of node.specifiers) {
              if (specifier.type === "ImportSpecifier") {
                const isType = specifier.importKind === "type" || node.importKind === "type";
                const map = isType ? typeMap : primitiveMap;
                const correctSource = map.get(specifier.imported.name);
                if (correctSource != null && correctSource !== source) {
                  context.report({
                    node: specifier,
                    messageId: "prefer-source",
                    data: {
                      name: specifier.imported.name,
                      source: correctSource
                    },
                    fix(fixer) {
                      const sourceCode = getSourceCode(context);
                      const program = sourceCode.ast;
                      const correctDeclaration = program.body.find(
                        (node2) => node2.type === "ImportDeclaration" && node2.source.value === correctSource
                      );
                      if (correctDeclaration) {
                        return [
                          removeSpecifier(fixer, sourceCode, specifier),
                          appendImports(fixer, sourceCode, correctDeclaration, [
                            sourceCode.getText(specifier)
                          ])
                        ].filter(Boolean);
                      }
                      const firstSolidDeclaration = program.body.find(
                        (node2) => node2.type === "ImportDeclaration" && isSource(node2.source.value)
                      );
                      return [
                        removeSpecifier(fixer, sourceCode, specifier),
                        insertImports(
                          fixer,
                          sourceCode,
                          correctSource,
                          [sourceCode.getText(specifier)],
                          firstSolidDeclaration,
                          isType
                        )
                      ];
                    }
                  });
                }
              }
            }
          }
        };
      }
    });
  }
});

// src/rules/jsx-no-duplicate-props.ts
import { ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
var createRule4, jsx_no_duplicate_props_default;
var init_jsx_no_duplicate_props = __esm({
  "src/rules/jsx-no-duplicate-props.ts"() {
    "use strict";
    init_utils();
    createRule4 = ESLintUtils4.RuleCreator.withoutDocs;
    jsx_no_duplicate_props_default = createRule4({
      meta: {
        type: "problem",
        docs: {
          description: "Disallow passing the same prop twice in JSX.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/jsx-no-duplicate-props.md"
        },
        schema: [
          {
            type: "object",
            properties: {
              ignoreCase: {
                type: "boolean",
                description: "Consider two prop names differing only by case to be the same.",
                default: false
              }
            }
          }
        ],
        messages: {
          noDuplicateProps: "Duplicate props are not allowed.",
          noDuplicateClass: "Duplicate `class` props are not allowed; while it might seem to work, it can break unexpectedly. Use `classList` instead.",
          noDuplicateChildren: "Using {{used}} at the same time is not allowed."
        }
      },
      defaultOptions: [],
      create(context) {
        return {
          JSXOpeningElement(node) {
            const ignoreCase = context.options[0]?.ignoreCase ?? false;
            const props = /* @__PURE__ */ new Set();
            const checkPropName = (name2, node2) => {
              if (ignoreCase || name2.startsWith("on")) {
                name2 = name2.toLowerCase().replace(/^on(?:capture)?:/, "on").replace(/^(?:attr|prop):/, "");
              }
              if (props.has(name2)) {
                context.report({
                  node: node2,
                  messageId: name2 === "class" ? "noDuplicateClass" : "noDuplicateProps"
                });
              }
              props.add(name2);
            };
            for (const [name2, propNode] of jsxGetAllProps(node.attributes)) {
              checkPropName(name2, propNode);
            }
            const hasChildrenProp = props.has("children");
            const hasChildren = node.parent.children.length > 0;
            const hasInnerHTML = props.has("innerHTML") || props.has("innerhtml");
            const hasTextContent = props.has("textContent") || props.has("textContent");
            const used = [
              hasChildrenProp && "`props.children`",
              hasChildren && "JSX children",
              hasInnerHTML && "`props.innerHTML`",
              hasTextContent && "`props.textContent`"
            ].filter(Boolean);
            if (used.length > 1) {
              context.report({
                node,
                messageId: "noDuplicateChildren",
                data: {
                  used: used.join(", ")
                }
              });
            }
          }
        };
      }
    });
  }
});

// src/rules/jsx-no-script-url.ts
import { ESLintUtils as ESLintUtils5, ASTUtils as ASTUtils3 } from "@typescript-eslint/utils";
var createRule5, getStaticValue2, isJavaScriptProtocol, jsx_no_script_url_default;
var init_jsx_no_script_url = __esm({
  "src/rules/jsx-no-script-url.ts"() {
    "use strict";
    init_compat();
    createRule5 = ESLintUtils5.RuleCreator.withoutDocs;
    ({ getStaticValue: getStaticValue2 } = ASTUtils3);
    isJavaScriptProtocol = /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;
    jsx_no_script_url_default = createRule5({
      meta: {
        type: "problem",
        docs: {
          description: "Disallow javascript: URLs.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/jsx-no-script-url.md"
        },
        schema: [],
        messages: {
          noJSURL: "For security, don't use javascript: URLs. Use event handlers instead if you can."
        }
      },
      defaultOptions: [],
      create(context) {
        return {
          JSXAttribute(node) {
            if (node.name.type === "JSXIdentifier" && node.value) {
              const link = getStaticValue2(
                node.value.type === "JSXExpressionContainer" ? node.value.expression : node.value,
                getScope(context, node)
              );
              if (link && typeof link.value === "string" && isJavaScriptProtocol.test(link.value)) {
                context.report({
                  node: node.value,
                  messageId: "noJSURL"
                });
              }
            }
          }
        };
      }
    });
  }
});

// src/rules/jsx-no-undef.ts
import { ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
var createRule6, AUTO_COMPONENTS, SOURCE_MODULE, jsx_no_undef_default;
var init_jsx_no_undef = __esm({
  "src/rules/jsx-no-undef.ts"() {
    "use strict";
    init_utils();
    init_compat();
    createRule6 = ESLintUtils6.RuleCreator.withoutDocs;
    AUTO_COMPONENTS = ["Show", "For", "Index", "Switch", "Match"];
    SOURCE_MODULE = "solid-js";
    jsx_no_undef_default = createRule6({
      meta: {
        type: "problem",
        docs: {
          description: "Disallow references to undefined variables in JSX. Handles custom directives.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/jsx-no-undef.md"
        },
        fixable: "code",
        schema: [
          {
            type: "object",
            properties: {
              allowGlobals: {
                type: "boolean",
                description: "When true, the rule will consider the global scope when checking for defined components.",
                default: false
              },
              autoImport: {
                type: "boolean",
                description: 'Automatically import certain components from `"solid-js"` if they are undefined.',
                default: true
              },
              typescriptEnabled: {
                type: "boolean",
                description: "Adjusts behavior not to conflict with TypeScript's type checking.",
                default: false
              }
            },
            additionalProperties: false
          }
        ],
        messages: {
          undefined: "'{{identifier}}' is not defined.",
          customDirectiveUndefined: "Custom directive '{{identifier}}' is not defined.",
          autoImport: "{{imports}} should be imported from '{{source}}'."
        }
      },
      defaultOptions: [],
      create(context) {
        const allowGlobals = context.options[0]?.allowGlobals ?? false;
        const autoImport = context.options[0]?.autoImport !== false;
        const isTypeScriptEnabled = context.options[0]?.typescriptEnabled ?? false;
        const missingComponentsSet = /* @__PURE__ */ new Set();
        function checkIdentifierInJSX(node, {
          isComponent: isComponent2,
          isCustomDirective
        } = {}) {
          let scope = getScope(context, node);
          const sourceCode = getSourceCode(context);
          const sourceType = sourceCode.ast.sourceType;
          const scopeUpperBound = !allowGlobals && sourceType === "module" ? "module" : "global";
          const variables = [...scope.variables];
          if (node.name === "this") {
            return;
          }
          while (scope.type !== scopeUpperBound && scope.type !== "global" && scope.upper) {
            scope = scope.upper;
            variables.push(...scope.variables);
          }
          if (scope.childScopes.length) {
            variables.push(...scope.childScopes[0].variables);
            if (scope.childScopes[0].childScopes.length) {
              variables.push(...scope.childScopes[0].childScopes[0].variables);
            }
          }
          if (variables.find((variable) => variable.name === node.name)) {
            return;
          }
          if (isComponent2 && autoImport && AUTO_COMPONENTS.includes(node.name) && !missingComponentsSet.has(node.name)) {
            missingComponentsSet.add(node.name);
          } else if (isCustomDirective) {
            context.report({
              node,
              messageId: "customDirectiveUndefined",
              data: {
                identifier: node.name
              }
            });
          } else if (!isTypeScriptEnabled) {
            context.report({
              node,
              messageId: "undefined",
              data: {
                identifier: node.name
              }
            });
          }
        }
        return {
          JSXOpeningElement(node) {
            let n;
            switch (node.name.type) {
              case "JSXIdentifier":
                if (!isDOMElementName(node.name.name)) {
                  checkIdentifierInJSX(node.name, { isComponent: true });
                }
                break;
              case "JSXMemberExpression":
                n = node.name;
                do {
                  n = n.object;
                } while (n && n.type !== "JSXIdentifier");
                if (n) {
                  checkIdentifierInJSX(n);
                }
                break;
              default:
                break;
            }
          },
          "JSXAttribute > JSXNamespacedName": (node) => {
            if (node.namespace?.type === "JSXIdentifier" && node.namespace.name === "use" && node.name?.type === "JSXIdentifier") {
              checkIdentifierInJSX(node.name, { isCustomDirective: true });
            }
          },
          "Program:exit": (programNode) => {
            const missingComponents = Array.from(missingComponentsSet.values());
            if (autoImport && missingComponents.length) {
              const importNode = programNode.body.find(
                (n) => n.type === "ImportDeclaration" && n.importKind !== "type" && n.source.type === "Literal" && n.source.value === SOURCE_MODULE
              );
              if (importNode) {
                context.report({
                  node: importNode,
                  messageId: "autoImport",
                  data: {
                    imports: formatList(missingComponents),
                    // "Show, For, and Switch"
                    source: SOURCE_MODULE
                  },
                  fix: (fixer) => {
                    return appendImports(fixer, getSourceCode(context), importNode, missingComponents);
                  }
                });
              } else {
                context.report({
                  node: programNode,
                  messageId: "autoImport",
                  data: {
                    imports: formatList(missingComponents),
                    source: SOURCE_MODULE
                  },
                  fix: (fixer) => {
                    return insertImports(fixer, getSourceCode(context), "solid-js", missingComponents);
                  }
                });
              }
            }
          }
        };
      }
    });
  }
});

// src/rules/jsx-uses-vars.ts
import { ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
var createRule7, jsx_uses_vars_default;
var init_jsx_uses_vars = __esm({
  "src/rules/jsx-uses-vars.ts"() {
    "use strict";
    init_compat();
    createRule7 = ESLintUtils7.RuleCreator.withoutDocs;
    jsx_uses_vars_default = createRule7({
      meta: {
        type: "problem",
        docs: {
          // eslint-disable-next-line eslint-plugin/require-meta-docs-description
          description: "Prevent variables used in JSX from being marked as unused.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/jsx-uses-vars.md"
        },
        schema: [],
        // eslint-disable-next-line eslint-plugin/prefer-message-ids
        messages: {}
      },
      defaultOptions: [],
      create(context) {
        return {
          JSXOpeningElement(node) {
            let parent;
            switch (node.name.type) {
              case "JSXNamespacedName":
                return;
              case "JSXIdentifier":
                markVariableAsUsed(context, node.name.name, node.name);
                break;
              case "JSXMemberExpression":
                parent = node.name.object;
                while (parent?.type === "JSXMemberExpression") {
                  parent = parent.object;
                }
                if (parent.type === "JSXIdentifier") {
                  markVariableAsUsed(context, parent.name, parent);
                }
                break;
            }
          },
          "JSXAttribute > JSXNamespacedName": (node) => {
            if (node.namespace?.type === "JSXIdentifier" && node.namespace.name === "use" && node.name?.type === "JSXIdentifier") {
              markVariableAsUsed(context, node.name.name, node.name);
            }
          }
        };
      }
    });
  }
});

// src/rules/no-destructure.ts
import { ESLintUtils as ESLintUtils8, ASTUtils as ASTUtils4 } from "@typescript-eslint/utils";
var createRule8, getStringIfConstant, getName, getPropertyInfo, no_destructure_default;
var init_no_destructure = __esm({
  "src/rules/no-destructure.ts"() {
    "use strict";
    init_compat();
    createRule8 = ESLintUtils8.RuleCreator.withoutDocs;
    ({ getStringIfConstant } = ASTUtils4);
    getName = (node) => {
      switch (node.type) {
        case "Literal":
          return typeof node.value === "string" ? node.value : null;
        case "Identifier":
          return node.name;
        case "AssignmentPattern":
          return getName(node.left);
        default:
          return getStringIfConstant(node);
      }
    };
    getPropertyInfo = (prop) => {
      const valueName = getName(prop.value);
      if (valueName !== null) {
        return {
          real: prop.key,
          var: valueName,
          computed: prop.computed,
          init: prop.value.type === "AssignmentPattern" ? prop.value.right : void 0
        };
      } else {
        return null;
      }
    };
    no_destructure_default = createRule8({
      meta: {
        type: "problem",
        docs: {
          description: "Disallow destructuring props. In Solid, props must be used with property accesses (`props.foo`) to preserve reactivity. This rule only tracks destructuring in the parameter list.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-destructure.md"
        },
        fixable: "code",
        schema: [],
        messages: {
          noDestructure: "Destructuring component props breaks Solid's reactivity; use property access instead."
          // noWriteToProps: "Component props are readonly, writing to props is not supported.",
        }
      },
      defaultOptions: [],
      create(context) {
        const functionStack = [];
        const currentFunction = () => functionStack[functionStack.length - 1];
        const onFunctionEnter = () => {
          functionStack.push({ hasJSX: false });
        };
        const onFunctionExit = (node) => {
          if (node.params.length === 1) {
            const props = node.params[0];
            if (props.type === "ObjectPattern" && currentFunction().hasJSX && node.parent?.type !== "JSXExpressionContainer") {
              context.report({
                node: props,
                messageId: "noDestructure",
                fix: (fixer) => fixDestructure(node, props, fixer)
              });
            }
          }
          functionStack.pop();
        };
        function* fixDestructure(func, props, fixer) {
          const propsName = "props";
          const properties = props.properties;
          const propertyInfo = [];
          let rest = null;
          for (const property of properties) {
            if (property.type === "RestElement") {
              rest = property;
            } else {
              const info = getPropertyInfo(property);
              if (info === null) {
                continue;
              }
              propertyInfo.push(info);
            }
          }
          const hasDefaults = propertyInfo.some((info) => info.init);
          const origProps = !(hasDefaults || rest) ? propsName : "_" + propsName;
          if (props.typeAnnotation) {
            const range = [props.range[0], props.typeAnnotation.range[0]];
            yield fixer.replaceTextRange(range, origProps);
          } else {
            yield fixer.replaceText(props, origProps);
          }
          const sourceCode = getSourceCode(context);
          const defaultsObjectString = () => propertyInfo.filter((info) => info.init).map(
            (info) => `${info.computed ? "[" : ""}${sourceCode.getText(info.real)}${info.computed ? "]" : ""}: ${sourceCode.getText(info.init)}`
          ).join(", ");
          const splitPropsArray = () => `[${propertyInfo.map(
            (info) => info.real.type === "Identifier" ? JSON.stringify(info.real.name) : sourceCode.getText(info.real)
          ).join(", ")}]`;
          let lineToInsert = "";
          if (hasDefaults && rest) {
            lineToInsert = `  const [${propsName}, ${rest.argument.type === "Identifier" && rest.argument.name || "rest"}] = splitProps(mergeProps({ ${defaultsObjectString()} }, ${origProps}), ${splitPropsArray()});`;
          } else if (hasDefaults) {
            lineToInsert = `  const ${propsName} = mergeProps({ ${defaultsObjectString()} }, ${origProps});
`;
          } else if (rest) {
            lineToInsert = `  const [${propsName}, ${rest.argument.type === "Identifier" && rest.argument.name || "rest"}] = splitProps(${origProps}, ${splitPropsArray()});
`;
          }
          if (lineToInsert) {
            const body = func.body;
            if (body.type === "BlockStatement") {
              if (body.body.length > 0) {
                yield fixer.insertTextBefore(body.body[0], lineToInsert);
              }
            } else {
              const maybeOpenParen = sourceCode.getTokenBefore(body);
              if (maybeOpenParen?.value === "(") {
                yield fixer.remove(maybeOpenParen);
              }
              const maybeCloseParen = sourceCode.getTokenAfter(body);
              if (maybeCloseParen?.value === ")") {
                yield fixer.remove(maybeCloseParen);
              }
              yield fixer.insertTextBefore(body, `{
${lineToInsert}  return (`);
              yield fixer.insertTextAfter(body, `);
}`);
            }
          }
          const scope = sourceCode.scopeManager?.acquire(func);
          if (scope) {
            for (const [info, variable] of propertyInfo.map(
              (info2) => [info2, scope.set.get(info2.var)]
            )) {
              if (variable) {
                for (const reference of variable.references) {
                  if (reference.isReadOnly()) {
                    const access = info.real.type === "Identifier" && !info.computed ? `.${info.real.name}` : `[${sourceCode.getText(info.real)}]`;
                    yield fixer.replaceText(reference.identifier, `${propsName}${access}`);
                  }
                }
              }
            }
          }
        }
        return {
          FunctionDeclaration: onFunctionEnter,
          FunctionExpression: onFunctionEnter,
          ArrowFunctionExpression: onFunctionEnter,
          "FunctionDeclaration:exit": onFunctionExit,
          "FunctionExpression:exit": onFunctionExit,
          "ArrowFunctionExpression:exit": onFunctionExit,
          JSXElement() {
            if (functionStack.length) {
              currentFunction().hasJSX = true;
            }
          },
          JSXFragment() {
            if (functionStack.length) {
              currentFunction().hasJSX = true;
            }
          }
        };
      }
    });
  }
});

// src/rules/no-innerhtml.ts
import { ESLintUtils as ESLintUtils9, ASTUtils as ASTUtils5 } from "@typescript-eslint/utils";
import isHtml from "is-html";
var createRule9, getStringIfConstant2, no_innerhtml_default;
var init_no_innerhtml = __esm({
  "src/rules/no-innerhtml.ts"() {
    "use strict";
    init_utils();
    createRule9 = ESLintUtils9.RuleCreator.withoutDocs;
    ({ getStringIfConstant: getStringIfConstant2 } = ASTUtils5);
    no_innerhtml_default = createRule9({
      meta: {
        type: "problem",
        docs: {
          description: "Disallow usage of the innerHTML attribute, which can often lead to security vulnerabilities.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-innerhtml.md"
        },
        fixable: "code",
        hasSuggestions: true,
        schema: [
          {
            type: "object",
            properties: {
              allowStatic: {
                description: "if the innerHTML value is guaranteed to be a static HTML string (i.e. no user input), allow it",
                type: "boolean",
                default: true
              }
            },
            additionalProperties: false
          }
        ],
        messages: {
          dangerous: "The innerHTML attribute is dangerous; passing unsanitized input can lead to security vulnerabilities.",
          conflict: "The innerHTML attribute should not be used on an element with child elements; they will be overwritten.",
          notHtml: "The string passed to innerHTML does not appear to be valid HTML.",
          useInnerText: "For text content, using innerText is clearer and safer.",
          dangerouslySetInnerHTML: "The dangerouslySetInnerHTML prop is not supported; use innerHTML instead."
        }
      },
      defaultOptions: [{ allowStatic: true }],
      create(context) {
        const allowStatic = Boolean(context.options[0]?.allowStatic ?? true);
        return {
          JSXAttribute(node) {
            if (jsxPropName(node) === "dangerouslySetInnerHTML") {
              if (node.value?.type === "JSXExpressionContainer" && node.value.expression.type === "ObjectExpression" && node.value.expression.properties.length === 1) {
                const htmlProp = node.value.expression.properties[0];
                if (htmlProp.type === "Property" && htmlProp.key.type === "Identifier" && htmlProp.key.name === "__html") {
                  context.report({
                    node,
                    messageId: "dangerouslySetInnerHTML",
                    fix: (fixer) => {
                      const propRange = node.range;
                      const valueRange = htmlProp.value.range;
                      return [
                        fixer.replaceTextRange([propRange[0], valueRange[0]], "innerHTML={"),
                        fixer.replaceTextRange([valueRange[1], propRange[1]], "}")
                      ];
                    }
                  });
                } else {
                  context.report({
                    node,
                    messageId: "dangerouslySetInnerHTML"
                  });
                }
              } else {
                context.report({
                  node,
                  messageId: "dangerouslySetInnerHTML"
                });
              }
              return;
            } else if (jsxPropName(node) !== "innerHTML") {
              return;
            }
            if (allowStatic) {
              const innerHtmlNode = node.value?.type === "JSXExpressionContainer" ? node.value.expression : node.value;
              const innerHtml = innerHtmlNode && getStringIfConstant2(innerHtmlNode);
              if (typeof innerHtml === "string") {
                if (isHtml(innerHtml)) {
                  if (node.parent?.parent?.type === "JSXElement" && node.parent.parent.children?.length) {
                    context.report({
                      node: node.parent.parent,
                      // report error on JSXElement instead of JSXAttribute
                      messageId: "conflict"
                    });
                  }
                } else {
                  context.report({
                    node,
                    messageId: "notHtml",
                    suggest: [
                      {
                        fix: (fixer) => fixer.replaceText(node.name, "innerText"),
                        messageId: "useInnerText"
                      }
                    ]
                  });
                }
              } else {
                context.report({
                  node,
                  messageId: "dangerous"
                });
              }
            } else {
              context.report({
                node,
                messageId: "dangerous"
              });
            }
          }
        };
      }
    });
  }
});

// src/rules/no-proxy-apis.ts
import { ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
var createRule10, no_proxy_apis_default;
var init_no_proxy_apis = __esm({
  "src/rules/no-proxy-apis.ts"() {
    "use strict";
    init_utils();
    createRule10 = ESLintUtils10.RuleCreator.withoutDocs;
    no_proxy_apis_default = createRule10({
      meta: {
        type: "problem",
        docs: {
          description: "Disallow usage of APIs that use ES6 Proxies, only to target environments that don't support them.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-proxy-apis.md"
        },
        schema: [],
        messages: {
          noStore: "Solid Store APIs use Proxies, which are incompatible with your target environment.",
          spreadCall: "Using a function call in JSX spread makes Solid use Proxies, which are incompatible with your target environment.",
          spreadMember: "Using a property access in JSX spread makes Solid use Proxies, which are incompatible with your target environment.",
          proxyLiteral: "Proxies are incompatible with your target environment.",
          mergeProps: "If you pass a function to `mergeProps`, it will create a Proxy, which are incompatible with your target environment."
        }
      },
      defaultOptions: [],
      create(context) {
        const { matchImport, handleImportDeclaration } = trackImports();
        return {
          ImportDeclaration(node) {
            handleImportDeclaration(node);
            const source = node.source.value;
            if (source === "solid-js/store") {
              context.report({
                node,
                messageId: "noStore"
              });
            }
          },
          "JSXSpreadAttribute MemberExpression"(node) {
            context.report({ node, messageId: "spreadMember" });
          },
          "JSXSpreadAttribute CallExpression"(node) {
            context.report({ node, messageId: "spreadCall" });
          },
          CallExpression(node) {
            if (node.callee.type === "Identifier") {
              if (matchImport("mergeProps", node.callee.name)) {
                node.arguments.filter((arg) => {
                  if (arg.type === "SpreadElement") return true;
                  const traced = trace(arg, context);
                  return traced.type === "Identifier" && !isPropsByName(traced.name) || isFunctionNode(traced);
                }).forEach((badArg) => {
                  context.report({
                    node: badArg,
                    messageId: "mergeProps"
                  });
                });
              }
            } else if (node.callee.type === "MemberExpression") {
              if (node.callee.object.type === "Identifier" && node.callee.object.name === "Proxy" && node.callee.property.type === "Identifier" && node.callee.property.name === "revocable") {
                context.report({
                  node,
                  messageId: "proxyLiteral"
                });
              }
            }
          },
          NewExpression(node) {
            if (node.callee.type === "Identifier" && node.callee.name === "Proxy") {
              context.report({ node, messageId: "proxyLiteral" });
            }
          }
        };
      }
    });
  }
});

// src/rules/no-react-deps.ts
import { ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
var createRule11, no_react_deps_default;
var init_no_react_deps = __esm({
  "src/rules/no-react-deps.ts"() {
    "use strict";
    init_utils();
    createRule11 = ESLintUtils11.RuleCreator.withoutDocs;
    no_react_deps_default = createRule11({
      meta: {
        type: "problem",
        docs: {
          description: "Disallow usage of dependency arrays in `createEffect` and `createMemo`.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-react-deps.md"
        },
        fixable: "code",
        schema: [],
        messages: {
          noUselessDep: "In Solid, `{{name}}` doesn't accept a dependency array because it automatically tracks its dependencies. If you really need to override the list of dependencies, use `on`."
        }
      },
      defaultOptions: [],
      create(context) {
        const { matchImport, handleImportDeclaration } = trackImports();
        return {
          ImportDeclaration: handleImportDeclaration,
          CallExpression(node) {
            if (node.callee.type === "Identifier" && matchImport(["createEffect", "createMemo"], node.callee.name) && node.arguments.length === 2 && node.arguments.every((arg) => arg.type !== "SpreadElement")) {
              const [arg0, arg1] = node.arguments.map((arg) => trace(arg, context));
              if (isFunctionNode(arg0) && arg0.params.length === 0 && arg1.type === "ArrayExpression") {
                context.report({
                  node: node.arguments[1],
                  // if this is a variable, highlight the usage, not the initialization
                  messageId: "noUselessDep",
                  data: {
                    name: node.callee.name
                  },
                  // remove dep array if it's given inline, otherwise don't fix
                  fix: arg1 === node.arguments[1] ? (fixer) => fixer.remove(arg1) : void 0
                });
              }
            }
          }
        };
      }
    });
  }
});

// src/rules/no-react-specific-props.ts
import { ESLintUtils as ESLintUtils12 } from "@typescript-eslint/utils";
var createRule12, reactSpecificProps, no_react_specific_props_default;
var init_no_react_specific_props = __esm({
  "src/rules/no-react-specific-props.ts"() {
    "use strict";
    init_utils();
    createRule12 = ESLintUtils12.RuleCreator.withoutDocs;
    reactSpecificProps = [
      { from: "className", to: "class" },
      { from: "htmlFor", to: "for" }
    ];
    no_react_specific_props_default = createRule12({
      meta: {
        type: "problem",
        docs: {
          description: "Disallow usage of React-specific `className`/`htmlFor` props, which were deprecated in v1.4.0.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-react-specific-props.md"
        },
        fixable: "code",
        schema: [],
        messages: {
          prefer: "Prefer the `{{ to }}` prop over the deprecated `{{ from }}` prop.",
          noUselessKey: "Elements in a <For> or <Index> list do not need a key prop."
        }
      },
      defaultOptions: [],
      create(context) {
        return {
          JSXOpeningElement(node) {
            for (const { from, to } of reactSpecificProps) {
              const classNameAttribute = jsxGetProp(node.attributes, from);
              if (classNameAttribute) {
                const fix = !jsxHasProp(node.attributes, to) ? (fixer) => fixer.replaceText(classNameAttribute.name, to) : void 0;
                context.report({
                  node: classNameAttribute,
                  messageId: "prefer",
                  data: { from, to },
                  fix
                });
              }
            }
            if (node.name.type === "JSXIdentifier" && isDOMElementName(node.name.name)) {
              const keyProp = jsxGetProp(node.attributes, "key");
              if (keyProp) {
                context.report({
                  node: keyProp,
                  messageId: "noUselessKey",
                  fix: (fixer) => fixer.remove(keyProp)
                });
              }
            }
          }
        };
      }
    });
  }
});

// src/rules/no-unknown-namespaces.ts
import { ESLintUtils as ESLintUtils13 } from "@typescript-eslint/utils";
var createRule13, knownNamespaces, styleNamespaces, otherNamespaces, no_unknown_namespaces_default;
var init_no_unknown_namespaces = __esm({
  "src/rules/no-unknown-namespaces.ts"() {
    "use strict";
    init_utils();
    createRule13 = ESLintUtils13.RuleCreator.withoutDocs;
    knownNamespaces = ["on", "oncapture", "use", "prop", "attr", "bool"];
    styleNamespaces = ["style", "class"];
    otherNamespaces = ["xmlns", "xlink"];
    no_unknown_namespaces_default = createRule13({
      meta: {
        type: "problem",
        docs: {
          description: "Enforce using only Solid-specific namespaced attribute names (i.e. `'on:'` in `<div on:click={...} />`).",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-unknown-namespaces.md"
        },
        hasSuggestions: true,
        schema: [
          {
            type: "object",
            properties: {
              allowedNamespaces: {
                description: "an array of additional namespace names to allow",
                type: "array",
                items: {
                  type: "string"
                },
                default: [],
                minItems: 1,
                uniqueItems: true
              }
            },
            additionalProperties: false
          }
        ],
        messages: {
          unknown: `'{{namespace}}:' is not one of Solid's special prefixes for JSX attributes (${knownNamespaces.map((n) => `'${n}:'`).join(", ")}).`,
          style: "Using the '{{namespace}}:' special prefix is potentially confusing, prefer the '{{namespace}}' prop instead.",
          component: "Namespaced props have no effect on components.",
          "component-suggest": "Replace {{namespace}}:{{name}} with {{name}}."
        }
      },
      defaultOptions: [],
      create(context) {
        const explicitlyAllowedNamespaces = context.options?.[0]?.allowedNamespaces;
        return {
          "JSXAttribute > JSXNamespacedName": (node) => {
            const openingElement = node.parent.parent;
            if (openingElement.name.type === "JSXIdentifier" && !isDOMElementName(openingElement.name.name)) {
              context.report({
                node,
                messageId: "component",
                suggest: [
                  {
                    messageId: "component-suggest",
                    data: { namespace: node.namespace.name, name: node.name.name },
                    fix: (fixer) => fixer.replaceText(node, node.name.name)
                  }
                ]
              });
              return;
            }
            const namespace = node.namespace?.name;
            if (!(knownNamespaces.includes(namespace) || otherNamespaces.includes(namespace) || explicitlyAllowedNamespaces?.includes(namespace))) {
              if (styleNamespaces.includes(namespace)) {
                context.report({
                  node,
                  messageId: "style",
                  data: { namespace }
                });
              } else {
                context.report({
                  node,
                  messageId: "unknown",
                  data: { namespace }
                });
              }
            }
          }
        };
      }
    });
  }
});

// src/rules/prefer-classlist.ts
import { ESLintUtils as ESLintUtils14 } from "@typescript-eslint/utils";
var createRule14, prefer_classlist_default;
var init_prefer_classlist = __esm({
  "src/rules/prefer-classlist.ts"() {
    "use strict";
    init_utils();
    createRule14 = ESLintUtils14.RuleCreator.withoutDocs;
    prefer_classlist_default = createRule14({
      meta: {
        type: "problem",
        docs: {
          description: "Enforce using the classlist prop over importing a classnames helper. The classlist prop accepts an object `{ [class: string]: boolean }` just like classnames.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/prefer-classlist.md"
        },
        fixable: "code",
        deprecated: true,
        schema: [
          {
            type: "object",
            properties: {
              classnames: {
                type: "array",
                description: "An array of names to treat as `classnames` functions",
                default: ["cn", "clsx", "classnames"],
                items: {
                  type: "string"
                },
                minItems: 1,
                uniqueItems: true
              }
            },
            additionalProperties: false
          }
        ],
        messages: {
          preferClasslist: "The classlist prop should be used instead of {{ classnames }} to efficiently set classes based on an object."
        }
      },
      defaultOptions: [],
      create(context) {
        const classnames = context.options[0]?.classnames ?? ["cn", "clsx", "classnames"];
        return {
          JSXAttribute(node) {
            if (["class", "className"].indexOf(jsxPropName(node)) === -1 || jsxHasProp(
              node.parent?.attributes ?? [],
              "classlist"
            )) {
              return;
            }
            if (node.value?.type === "JSXExpressionContainer") {
              const expr = node.value.expression;
              if (expr.type === "CallExpression" && expr.callee.type === "Identifier" && classnames.indexOf(expr.callee.name) !== -1 && expr.arguments.length === 1 && expr.arguments[0].type === "ObjectExpression") {
                context.report({
                  node,
                  messageId: "preferClasslist",
                  data: {
                    classnames: expr.callee.name
                  },
                  fix: (fixer) => {
                    const attrRange = node.range;
                    const objectRange = expr.arguments[0].range;
                    return [
                      fixer.replaceTextRange([attrRange[0], objectRange[0]], "classlist={"),
                      fixer.replaceTextRange([objectRange[1], attrRange[1]], "}")
                    ];
                  }
                });
              }
            }
          }
        };
      }
    });
  }
});

// src/rules/prefer-for.ts
import { ESLintUtils as ESLintUtils15, ASTUtils as ASTUtils6 } from "@typescript-eslint/utils";
var createRule15, getPropertyName, prefer_for_default;
var init_prefer_for = __esm({
  "src/rules/prefer-for.ts"() {
    "use strict";
    init_utils();
    createRule15 = ESLintUtils15.RuleCreator.withoutDocs;
    ({ getPropertyName } = ASTUtils6);
    prefer_for_default = createRule15({
      meta: {
        type: "problem",
        docs: {
          description: "Enforce using Solid's `<For />` component for mapping an array to JSX elements.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/prefer-for.md"
        },
        fixable: "code",
        schema: [],
        messages: {
          preferFor: "Use Solid's `<For />` component for efficiently rendering lists. Array#map causes DOM elements to be recreated.",
          preferForOrIndex: "Use Solid's `<For />` component or `<Index />` component for rendering lists. Array#map causes DOM elements to be recreated."
        }
      },
      defaultOptions: [],
      create(context) {
        const reportPreferFor = (node) => {
          const jsxExpressionContainerNode = node.parent;
          const arrayNode = node.callee.object;
          const mapFnNode = node.arguments[0];
          context.report({
            node,
            messageId: "preferFor",
            fix: (fixer) => {
              const beforeArray = [
                jsxExpressionContainerNode.range[0],
                arrayNode.range[0]
              ];
              const betweenArrayAndMapFn = [arrayNode.range[1], mapFnNode.range[0]];
              const afterMapFn = [
                mapFnNode.range[1],
                jsxExpressionContainerNode.range[1]
              ];
              return [
                fixer.replaceTextRange(beforeArray, "<For each={"),
                fixer.replaceTextRange(betweenArrayAndMapFn, "}>{"),
                fixer.replaceTextRange(afterMapFn, "}</For>")
              ];
            }
          });
        };
        return {
          CallExpression(node) {
            const callOrChain = node.parent?.type === "ChainExpression" ? node.parent : node;
            if (callOrChain.parent?.type === "JSXExpressionContainer" && isJSXElementOrFragment(callOrChain.parent.parent)) {
              if (node.callee.type === "MemberExpression" && getPropertyName(node.callee) === "map" && node.arguments.length === 1 && // passing thisArg to Array.prototype.map is rare, deopt in that case
              isFunctionNode(node.arguments[0])) {
                const mapFnNode = node.arguments[0];
                if (mapFnNode.params.length === 1 && mapFnNode.params[0].type !== "RestElement") {
                  reportPreferFor(node);
                } else {
                  context.report({
                    node,
                    messageId: "preferForOrIndex"
                  });
                }
              }
            }
          }
        };
      }
    });
  }
});

// src/rules/prefer-show.ts
import { ESLintUtils as ESLintUtils16 } from "@typescript-eslint/utils";
var createRule16, EXPENSIVE_TYPES, prefer_show_default;
var init_prefer_show = __esm({
  "src/rules/prefer-show.ts"() {
    "use strict";
    init_utils();
    init_compat();
    createRule16 = ESLintUtils16.RuleCreator.withoutDocs;
    EXPENSIVE_TYPES = ["JSXElement", "JSXFragment", "Identifier"];
    prefer_show_default = createRule16({
      meta: {
        type: "problem",
        docs: {
          description: "Enforce using Solid's `<Show />` component for conditionally showing content. Solid's compiler covers this case, so it's a stylistic rule only.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/prefer-show.md"
        },
        fixable: "code",
        schema: [],
        messages: {
          preferShowAnd: "Use Solid's `<Show />` component for conditionally showing content.",
          preferShowTernary: "Use Solid's `<Show />` component for conditionally showing content with a fallback."
        }
      },
      defaultOptions: [],
      create(context) {
        const sourceCode = getSourceCode(context);
        const putIntoJSX = (node) => {
          const text = sourceCode.getText(node);
          return isJSXElementOrFragment(node) ? text : `{${text}}`;
        };
        const logicalExpressionHandler = (node) => {
          if (node.operator === "&&" && EXPENSIVE_TYPES.includes(node.right.type)) {
            context.report({
              node,
              messageId: "preferShowAnd",
              fix: (fixer) => fixer.replaceText(
                node.parent?.type === "JSXExpressionContainer" && isJSXElementOrFragment(node.parent.parent) ? node.parent : node,
                `<Show when={${sourceCode.getText(node.left)}}>${putIntoJSX(node.right)}</Show>`
              )
            });
          }
        };
        const conditionalExpressionHandler = (node) => {
          if (EXPENSIVE_TYPES.includes(node.consequent.type) || EXPENSIVE_TYPES.includes(node.alternate.type)) {
            context.report({
              node,
              messageId: "preferShowTernary",
              fix: (fixer) => fixer.replaceText(
                node.parent?.type === "JSXExpressionContainer" && isJSXElementOrFragment(node.parent.parent) ? node.parent : node,
                `<Show when={${sourceCode.getText(node.test)}} fallback={${sourceCode.getText(
                  node.alternate
                )}}>${putIntoJSX(node.consequent)}</Show>`
              )
            });
          }
        };
        return {
          JSXExpressionContainer(node) {
            if (!isJSXElementOrFragment(node.parent)) {
              return;
            }
            if (node.expression.type === "LogicalExpression") {
              logicalExpressionHandler(node.expression);
            } else if (node.expression.type === "ArrowFunctionExpression" && node.expression.body.type === "LogicalExpression") {
              logicalExpressionHandler(node.expression.body);
            } else if (node.expression.type === "ConditionalExpression") {
              conditionalExpressionHandler(node.expression);
            } else if (node.expression.type === "ArrowFunctionExpression" && node.expression.body.type === "ConditionalExpression") {
              conditionalExpressionHandler(node.expression.body);
            }
          }
        };
      }
    });
  }
});

// src/rules/reactivity.ts
import { ESLintUtils as ESLintUtils17, ASTUtils as ASTUtils7 } from "@typescript-eslint/utils";
import { traverse } from "estraverse";
var getFunctionHeadLocation, createRule17, ScopeStackItem, ScopeStack, getNthDestructuredVar, getReturnedVar, reactivity_default;
var init_reactivity = __esm({
  "src/rules/reactivity.ts"() {
    "use strict";
    init_utils();
    init_compat();
    ({ getFunctionHeadLocation } = ASTUtils7);
    createRule17 = ESLintUtils17.RuleCreator.withoutDocs;
    ScopeStackItem = class {
      /** the node for the current scope, or program if global scope */
      node;
      /**
       * nodes whose descendants in the current scope are allowed to be reactive.
       * JSXExpressionContainers can be any expression containing reactivity, while
       * function nodes/identifiers are typically arguments to solid-js primitives
       * and should match a tracked scope exactly.
       */
      trackedScopes = [];
      /** nameless functions with reactivity, should exactly match a tracked scope */
      unnamedDerivedSignals = /* @__PURE__ */ new Set();
      /** switched to true by time of :exit if JSX is detected in the current scope */
      hasJSX = false;
      constructor(node) {
        this.node = node;
      }
    };
    ScopeStack = class extends Array {
      currentScope = () => this[this.length - 1];
      parentScope = () => this[this.length - 2];
      /** Add references to a signal, memo, derived signal, etc. */
      pushSignal(variable, declarationScope = this.currentScope().node) {
        this.signals.push({
          references: variable.references.filter((reference) => !reference.init),
          variable,
          declarationScope
        });
      }
      /**
       * Add references to a signal, merging with existing references if the
       * variable is the same. Derived signals are special; they don't use the
       * declaration scope of the function, but rather the minimum declaration scope
       * of any signals they contain.
       */
      pushUniqueSignal(variable, declarationScope) {
        const foundSignal = this.signals.find((s) => s.variable === variable);
        if (!foundSignal) {
          this.pushSignal(variable, declarationScope);
        } else {
          foundSignal.declarationScope = this.findDeepestDeclarationScope(
            foundSignal.declarationScope,
            declarationScope
          );
        }
      }
      /** Add references to a props or store. */
      pushProps(variable, declarationScope = this.currentScope().node) {
        this.props.push({
          references: variable.references.filter((reference) => !reference.init),
          variable,
          declarationScope
        });
      }
      /** Function callbacks that run synchronously and don't create a new scope. */
      syncCallbacks = /* @__PURE__ */ new Set();
      /**
       * Iterate through and remove the signal references in the current scope.
       * That way, the next Scope up can safely check for references in its scope.
       */
      *consumeSignalReferencesInScope() {
        yield* this.consumeReferencesInScope(this.signals);
        this.signals = this.signals.filter((variable) => variable.references.length !== 0);
      }
      /** Iterate through and remove the props references in the current scope. */
      *consumePropsReferencesInScope() {
        yield* this.consumeReferencesInScope(this.props);
        this.props = this.props.filter((variable) => variable.references.length !== 0);
      }
      *consumeReferencesInScope(variables) {
        for (const variable of variables) {
          const { references } = variable;
          const inScope = [], notInScope = [];
          references.forEach((reference) => {
            if (this.isReferenceInCurrentScope(reference)) {
              inScope.push(reference);
            } else {
              notInScope.push(reference);
            }
          });
          yield* inScope.map((reference) => ({
            reference,
            declarationScope: variable.declarationScope
          }));
          variable.references = notInScope;
        }
      }
      /** Returns the function node deepest in the tree. Assumes a === b, a is inside b, or b is inside a. */
      findDeepestDeclarationScope = (a, b) => {
        if (a === b) return a;
        for (let i = this.length - 1; i >= 0; i -= 1) {
          const { node } = this[i];
          if (a === node || b === node) {
            return node;
          }
        }
        throw new Error("This should never happen");
      };
      /**
       * Returns true if the reference is in the current scope, handling sync
       * callbacks. Must be called on the :exit pass only.
       */
      isReferenceInCurrentScope(reference) {
        let parentFunction = findParent(reference.identifier, isProgramOrFunctionNode);
        while (isFunctionNode(parentFunction) && this.syncCallbacks.has(parentFunction)) {
          parentFunction = findParent(parentFunction, isProgramOrFunctionNode);
        }
        return parentFunction === this.currentScope().node;
      }
      /** variable references to be treated as signals, memos, derived signals, etc. */
      signals = [];
      /** variables references to be treated as props (or stores) */
      props = [];
    };
    getNthDestructuredVar = (id, n, context) => {
      if (id?.type === "ArrayPattern") {
        const el = id.elements[n];
        if (el?.type === "Identifier") {
          return findVariable(context, el);
        }
      }
      return null;
    };
    getReturnedVar = (id, context) => {
      if (id.type === "Identifier") {
        return findVariable(context, id);
      }
      return null;
    };
    reactivity_default = createRule17({
      meta: {
        type: "problem",
        docs: {
          description: "Enforce that reactivity (props, signals, memos, etc.) is properly used, so changes in those values will be tracked and update the view as expected.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/reactivity.md"
        },
        schema: [
          {
            type: "object",
            properties: {
              customReactiveFunctions: {
                description: "List of function names to consider as reactive functions (allow signals to be safely passed as arguments). In addition, any create* or use* functions are automatically included.",
                type: "array",
                items: {
                  type: "string"
                },
                default: []
              }
            },
            additionalProperties: false
          }
        ],
        messages: {
          noWrite: "The reactive variable '{{name}}' should not be reassigned or altered directly.",
          untrackedReactive: "The reactive variable '{{name}}' should be used within JSX, a tracked scope (like createEffect), or inside an event handler function, or else changes will be ignored.",
          expectedFunctionGotExpression: "The reactive variable '{{name}}' should be wrapped in a function for reactivity. This includes event handler bindings on native elements, which are not reactive like other JSX props.",
          badSignal: "The reactive variable '{{name}}' should be called as a function when used in {{where}}.",
          badUnnamedDerivedSignal: "This function should be passed to a tracked scope (like createEffect) or an event handler because it contains reactivity, or else changes will be ignored.",
          shouldDestructure: "For proper analysis, array destructuring should be used to capture the {{nth}}result of this function call.",
          shouldAssign: "For proper analysis, a variable should be used to capture the result of this function call.",
          noAsyncTrackedScope: "This tracked scope should not be async. Solid's reactivity only tracks synchronously."
        }
      },
      defaultOptions: [
        {
          customReactiveFunctions: []
        }
      ],
      create(context, [options]) {
        const warnShouldDestructure = (node, nth) => context.report({
          node,
          messageId: "shouldDestructure",
          data: nth ? { nth: nth + " " } : void 0
        });
        const warnShouldAssign = (node) => context.report({ node, messageId: "shouldAssign" });
        const sourceCode = getSourceCode(context);
        const scopeStack = new ScopeStack();
        const { currentScope, parentScope } = scopeStack;
        const { matchImport, handleImportDeclaration } = trackImports();
        const markPropsOnCondition = (node, cb) => {
          if (node.params.length === 1 && node.params[0].type === "Identifier" && node.parent?.type !== "JSXExpressionContainer" && // "render props" aren't components
          node.parent?.type !== "TemplateLiteral" && // inline functions in tagged template literals aren't components
          cb(node.params[0])) {
            const propsParam = findVariable(context, node.params[0]);
            if (propsParam) {
              scopeStack.pushProps(propsParam, node);
            }
          }
        };
        const onFunctionEnter = (node) => {
          if (isFunctionNode(node)) {
            if (scopeStack.syncCallbacks.has(node)) {
              return;
            }
            markPropsOnCondition(node, (props) => isPropsByName(props.name));
          }
          scopeStack.push(new ScopeStackItem(node));
        };
        const matchTrackedScope = (trackedScope, node) => {
          switch (trackedScope.expect) {
            case "function":
            case "called-function":
              return node === trackedScope.node;
            case "expression":
              return Boolean(
                findInScope(node, currentScope().node, (node2) => node2 === trackedScope.node)
              );
          }
        };
        const handleTrackedScopes = (identifier, declarationScope) => {
          const currentScopeNode = currentScope().node;
          if (!currentScope().trackedScopes.find(
            (trackedScope) => matchTrackedScope(trackedScope, identifier)
          )) {
            const matchedExpression = currentScope().trackedScopes.find(
              (trackedScope) => matchTrackedScope({ ...trackedScope, expect: "expression" }, identifier)
            );
            if (declarationScope === currentScopeNode) {
              let parentMemberExpression = null;
              if (identifier.parent?.type === "MemberExpression") {
                parentMemberExpression = identifier.parent;
                while (parentMemberExpression.parent?.type === "MemberExpression") {
                  parentMemberExpression = parentMemberExpression.parent;
                }
              }
              const parentCallExpression = identifier.parent?.type === "CallExpression" ? identifier.parent : null;
              context.report({
                node: parentMemberExpression ?? parentCallExpression ?? identifier,
                messageId: matchedExpression ? "expectedFunctionGotExpression" : "untrackedReactive",
                data: {
                  name: parentMemberExpression ? sourceCode.getText(parentMemberExpression) : identifier.name
                }
              });
            } else {
              if (!parentScope() || !isFunctionNode(currentScopeNode)) {
                throw new Error("this shouldn't happen!");
              }
              const pushUnnamedDerivedSignal = () => (parentScope().unnamedDerivedSignals ??= /* @__PURE__ */ new Set()).add(currentScopeNode);
              if (currentScopeNode.type === "FunctionDeclaration") {
                const functionVariable = sourceCode.scopeManager?.getDeclaredVariables(currentScopeNode)?.[0];
                if (functionVariable) {
                  scopeStack.pushUniqueSignal(
                    functionVariable,
                    declarationScope
                    // use declaration scope of a signal contained in this function
                  );
                } else {
                  pushUnnamedDerivedSignal();
                }
              } else if (currentScopeNode.parent?.type === "VariableDeclarator") {
                const declarator = currentScopeNode.parent;
                const functionVariable = sourceCode.scopeManager?.getDeclaredVariables(declarator)?.[0];
                if (functionVariable) {
                  scopeStack.pushUniqueSignal(functionVariable, declarationScope);
                } else {
                  pushUnnamedDerivedSignal();
                }
              } else if (currentScopeNode.parent?.type === "Property") {
              } else {
                pushUnnamedDerivedSignal();
              }
            }
          }
        };
        const onFunctionExit = (currentScopeNode) => {
          if (isFunctionNode(currentScopeNode)) {
            markPropsOnCondition(currentScopeNode, (props) => {
              if (!isPropsByName(props.name) && // already added in markPropsOnEnter
              currentScope().hasJSX) {
                const functionName = getFunctionName(currentScopeNode);
                if (functionName && !/^[a-z]/.test(functionName)) return true;
              }
              return false;
            });
          }
          if (isFunctionNode(currentScopeNode) && scopeStack.syncCallbacks.has(currentScopeNode)) {
            return;
          }
          for (const { reference, declarationScope } of scopeStack.consumeSignalReferencesInScope()) {
            const identifier = reference.identifier;
            if (reference.isWrite()) {
              context.report({
                node: identifier,
                messageId: "noWrite",
                data: {
                  name: identifier.name
                }
              });
            } else if (identifier.type === "Identifier") {
              const reportBadSignal = (where) => context.report({
                node: identifier,
                messageId: "badSignal",
                data: { name: identifier.name, where }
              });
              if (
                // This allows both calling a signal and calling a function with a signal.
                identifier.parent?.type === "CallExpression" || // Also allow the case where we pass an array of signals, such as in a custom hook
                identifier.parent?.type === "ArrayExpression" && identifier.parent.parent?.type === "CallExpression"
              ) {
                handleTrackedScopes(identifier, declarationScope);
              } else if (identifier.parent?.type === "TemplateLiteral") {
                reportBadSignal("template literals");
              } else if (identifier.parent?.type === "BinaryExpression" && [
                "<",
                "<=",
                ">",
                ">=",
                "<<",
                ">>",
                ">>>",
                "+",
                "-",
                "*",
                "/",
                "%",
                "**",
                "|",
                "^",
                "&",
                "in"
              ].includes(identifier.parent.operator)) {
                reportBadSignal("arithmetic or comparisons");
              } else if (identifier.parent?.type === "UnaryExpression" && ["-", "+", "~"].includes(identifier.parent.operator)) {
                reportBadSignal("unary expressions");
              } else if (identifier.parent?.type === "MemberExpression" && identifier.parent.computed && identifier.parent.property === identifier) {
                reportBadSignal("property accesses");
              } else if (identifier.parent?.type === "JSXExpressionContainer" && !currentScope().trackedScopes.find(
                (trackedScope) => trackedScope.node === identifier && (trackedScope.expect === "function" || trackedScope.expect === "called-function")
              )) {
                const elementOrAttribute = identifier.parent.parent;
                if (
                  // The signal is not being called and is being used as a props.children, where calling
                  // the signal was the likely intent.
                  isJSXElementOrFragment(elementOrAttribute) || // We can't say for sure about user components, but we know for a fact that a signal
                  // should not be passed to a non-event handler DOM element attribute without calling it.
                  elementOrAttribute?.type === "JSXAttribute" && elementOrAttribute.parent?.type === "JSXOpeningElement" && elementOrAttribute.parent.name.type === "JSXIdentifier" && isDOMElementName(elementOrAttribute.parent.name.name)
                ) {
                  reportBadSignal("JSX");
                }
              }
            }
          }
          for (const { reference, declarationScope } of scopeStack.consumePropsReferencesInScope()) {
            const identifier = reference.identifier;
            if (reference.isWrite()) {
              context.report({
                node: identifier,
                messageId: "noWrite",
                data: {
                  name: identifier.name
                }
              });
            } else if (identifier.parent?.type === "MemberExpression" && identifier.parent.object === identifier) {
              const { parent } = identifier;
              if (parent.parent?.type === "AssignmentExpression" && parent.parent.left === parent) {
                context.report({
                  node: identifier,
                  messageId: "noWrite",
                  data: {
                    name: identifier.name
                  }
                });
              } else if (parent.property.type === "Identifier" && /^(?:initial|default|static[A-Z])/.test(parent.property.name)) {
              } else {
                handleTrackedScopes(identifier, declarationScope);
              }
            } else if (identifier.parent?.type === "AssignmentExpression" || identifier.parent?.type === "VariableDeclarator") {
              context.report({
                node: identifier,
                messageId: "untrackedReactive",
                data: { name: identifier.name }
              });
            }
          }
          const { unnamedDerivedSignals } = currentScope();
          if (unnamedDerivedSignals) {
            for (const node of unnamedDerivedSignals) {
              if (!currentScope().trackedScopes.find(
                (trackedScope) => matchTrackedScope(trackedScope, node)
              )) {
                context.report({
                  loc: getFunctionHeadLocation(node, sourceCode),
                  messageId: "badUnnamedDerivedSignal"
                });
              }
            }
          }
          scopeStack.pop();
        };
        const checkForSyncCallbacks = (node) => {
          if (node.arguments.length === 1 && isFunctionNode(node.arguments[0]) && !node.arguments[0].async) {
            if (node.callee.type === "Identifier" && matchImport(["batch", "produce"], node.callee.name)) {
              scopeStack.syncCallbacks.add(node.arguments[0]);
            } else if (node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.object.type !== "ObjectExpression" && /^(?:forEach|map|flatMap|reduce|reduceRight|find|findIndex|filter|every|some)$/.test(
              node.callee.property.name
            )) {
              scopeStack.syncCallbacks.add(node.arguments[0]);
            }
          }
          if (node.callee.type === "Identifier") {
            if (matchImport(["createSignal", "createStore"], node.callee.name) && node.parent?.type === "VariableDeclarator") {
              const setter = getNthDestructuredVar(node.parent.id, 1, context);
              if (setter) {
                for (const reference of setter.references) {
                  const { identifier } = reference;
                  if (!reference.init && reference.isRead() && identifier.parent?.type === "CallExpression") {
                    for (const arg of identifier.parent.arguments) {
                      if (isFunctionNode(arg) && !arg.async) {
                        scopeStack.syncCallbacks.add(arg);
                      }
                    }
                  }
                }
              }
            } else if (matchImport(["mapArray", "indexArray"], node.callee.name)) {
              const arg1 = node.arguments[1];
              if (isFunctionNode(arg1)) {
                scopeStack.syncCallbacks.add(arg1);
              }
            }
          }
          if (isFunctionNode(node.callee)) {
            scopeStack.syncCallbacks.add(node.callee);
          }
        };
        const checkForReactiveAssignment = (id, init) => {
          init = ignoreTransparentWrappers(init);
          if (init.type === "CallExpression" && init.callee.type === "Identifier") {
            const { callee } = init;
            if (matchImport(["createSignal", "useTransition"], callee.name)) {
              const signal = id && getNthDestructuredVar(id, 0, context);
              if (signal) {
                scopeStack.pushSignal(signal, currentScope().node);
              } else {
                warnShouldDestructure(id ?? init, "first");
              }
            } else if (matchImport(["createMemo", "createSelector"], callee.name)) {
              const memo = id && getReturnedVar(id, context);
              if (memo) {
                scopeStack.pushSignal(memo, currentScope().node);
              } else {
                warnShouldAssign(id ?? init);
              }
            } else if (matchImport("createStore", callee.name)) {
              const store = id && getNthDestructuredVar(id, 0, context);
              if (store) {
                scopeStack.pushProps(store, currentScope().node);
              } else {
                warnShouldDestructure(id ?? init, "first");
              }
            } else if (matchImport("mergeProps", callee.name)) {
              const merged = id && getReturnedVar(id, context);
              if (merged) {
                scopeStack.pushProps(merged, currentScope().node);
              } else {
                warnShouldAssign(id ?? init);
              }
            } else if (matchImport("splitProps", callee.name)) {
              if (id?.type === "ArrayPattern") {
                const vars = id.elements.map((_, i) => getNthDestructuredVar(id, i, context)).filter(Boolean);
                if (vars.length === 0) {
                  warnShouldDestructure(id);
                } else {
                  vars.forEach((variable) => {
                    scopeStack.pushProps(variable, currentScope().node);
                  });
                }
              } else {
                const vars = id && getReturnedVar(id, context);
                if (vars) {
                  scopeStack.pushProps(vars, currentScope().node);
                }
              }
            } else if (matchImport("createResource", callee.name)) {
              const resourceReturn = id && getNthDestructuredVar(id, 0, context);
              if (resourceReturn) {
                scopeStack.pushProps(resourceReturn, currentScope().node);
              }
            } else if (matchImport("createMutable", callee.name)) {
              const mutable = id && getReturnedVar(id, context);
              if (mutable) {
                scopeStack.pushProps(mutable, currentScope().node);
              }
            } else if (matchImport("mapArray", callee.name)) {
              const arg1 = init.arguments[1];
              if (isFunctionNode(arg1) && arg1.params.length >= 2 && arg1.params[1].type === "Identifier") {
                const indexSignal = findVariable(context, arg1.params[1]);
                if (indexSignal) {
                  scopeStack.pushSignal(indexSignal);
                }
              }
            } else if (matchImport("indexArray", callee.name)) {
              const arg1 = init.arguments[1];
              if (isFunctionNode(arg1) && arg1.params.length >= 1 && arg1.params[0].type === "Identifier") {
                const valueSignal = findVariable(context, arg1.params[0]);
                if (valueSignal) {
                  scopeStack.pushSignal(valueSignal);
                }
              }
            }
          }
        };
        const checkForTrackedScopes = (node) => {
          const pushTrackedScope = (node2, expect) => {
            currentScope().trackedScopes.push({ node: node2, expect });
            if (expect !== "called-function" && isFunctionNode(node2) && node2.async) {
              context.report({
                node: node2,
                messageId: "noAsyncTrackedScope"
              });
            }
          };
          const permissivelyTrackNode = (node2) => {
            traverse(node2, {
              enter(cn) {
                const childNode = cn;
                const traced = trace(childNode, context);
                if (isFunctionNode(traced) || traced.type === "Identifier" && traced.parent.type !== "MemberExpression" && !(traced.parent.type === "CallExpression" && traced.parent.callee === traced)) {
                  pushTrackedScope(childNode, "called-function");
                  this.skip();
                }
              },
              fallback: "iteration"
              // Don't crash when encounter unknown node.
            });
          };
          if (node.type === "JSXExpressionContainer") {
            if (node.parent?.type === "JSXAttribute" && sourceCode.getText(node.parent.name).startsWith("on") && node.parent.parent?.type === "JSXOpeningElement" && node.parent.parent.name.type === "JSXIdentifier" && isDOMElementName(node.parent.parent.name.name)) {
              pushTrackedScope(node.expression, "called-function");
            } else if (node.parent?.type === "JSXAttribute" && node.parent.name.type === "JSXNamespacedName" && node.parent.name.namespace.name === "use" && isFunctionNode(node.expression)) {
              pushTrackedScope(node.expression, "called-function");
            } else if (node.parent?.type === "JSXAttribute" && node.parent.name.name === "value" && node.parent.parent?.type === "JSXOpeningElement" && (node.parent.parent.name.type === "JSXIdentifier" && node.parent.parent.name.name.endsWith("Provider") || node.parent.parent.name.type === "JSXMemberExpression" && node.parent.parent.name.property.name === "Provider")) {
            } else if (node.parent?.type === "JSXAttribute" && node.parent.name?.type === "JSXIdentifier" && /^static[A-Z]/.test(node.parent.name.name) && node.parent.parent?.type === "JSXOpeningElement" && node.parent.parent.name.type === "JSXIdentifier" && !isDOMElementName(node.parent.parent.name.name)) {
            } else if (node.parent?.type === "JSXAttribute" && node.parent.name.name === "ref" && isFunctionNode(node.expression)) {
              pushTrackedScope(node.expression, "called-function");
            } else if (isJSXElementOrFragment(node.parent) && isFunctionNode(node.expression)) {
              pushTrackedScope(node.expression, "function");
            } else {
              pushTrackedScope(node.expression, "expression");
            }
          } else if (node.type === "JSXSpreadAttribute") {
            pushTrackedScope(node.argument, "expression");
          } else if (node.type === "NewExpression") {
            const {
              callee,
              arguments: { 0: arg0 }
            } = node;
            if (callee.type === "Identifier" && arg0 && // Observers from Standard Web APIs
            [
              "IntersectionObserver",
              "MutationObserver",
              "PerformanceObserver",
              "ReportingObserver",
              "ResizeObserver"
            ].includes(callee.name)) {
              pushTrackedScope(arg0, "called-function");
            }
          } else if (node.type === "CallExpression") {
            if (node.callee.type === "Identifier") {
              const {
                callee,
                arguments: { 0: arg0, 1: arg1 }
              } = node;
              if (matchImport(
                [
                  "createMemo",
                  "children",
                  "createEffect",
                  "createRenderEffect",
                  "createDeferred",
                  "createComputed",
                  "createSelector",
                  "untrack",
                  "mapArray",
                  "indexArray",
                  "observable"
                ],
                callee.name
              ) || matchImport("createResource", callee.name) && node.arguments.length >= 2) {
                pushTrackedScope(arg0, "function");
              } else if (matchImport(["onMount", "onCleanup", "onError"], callee.name) || [
                // Timers
                "setInterval",
                "setTimeout",
                "setImmediate",
                "requestAnimationFrame",
                "requestIdleCallback"
              ].includes(callee.name)) {
                pushTrackedScope(arg0, "called-function");
              } else if (matchImport("on", callee.name)) {
                if (arg0) {
                  if (arg0.type === "ArrayExpression") {
                    arg0.elements.forEach((element) => {
                      if (element && element?.type !== "SpreadElement") {
                        pushTrackedScope(element, "function");
                      }
                    });
                  } else {
                    pushTrackedScope(arg0, "function");
                  }
                }
                if (arg1) {
                  pushTrackedScope(arg1, "called-function");
                }
              } else if (matchImport("createStore", callee.name) && arg0?.type === "ObjectExpression") {
                for (const property of arg0.properties) {
                  if (property.type === "Property" && property.kind === "get" && isFunctionNode(property.value)) {
                    pushTrackedScope(property.value, "function");
                  }
                }
              } else if (matchImport("runWithOwner", callee.name)) {
                if (arg1) {
                  let isTrackedScope = true;
                  const owner = arg0.type === "Identifier" && findVariable(context, arg0);
                  if (owner) {
                    const decl = owner.defs[0];
                    if (decl && decl.node.type === "VariableDeclarator" && decl.node.init?.type === "CallExpression" && decl.node.init.callee.type === "Identifier" && matchImport("getOwner", decl.node.init.callee.name)) {
                      const ownerFunction = findParent(decl.node, isProgramOrFunctionNode);
                      const scopeStackIndex = scopeStack.findIndex(
                        ({ node: node2 }) => ownerFunction === node2
                      );
                      if (scopeStackIndex >= 1 && !scopeStack[scopeStackIndex - 1].trackedScopes.some(
                        (trackedScope) => trackedScope.expect === "function" && trackedScope.node === ownerFunction
                      ) || scopeStackIndex === 0) {
                        isTrackedScope = false;
                      }
                    }
                  }
                  if (isTrackedScope) {
                    pushTrackedScope(arg1, "function");
                  }
                }
              } else if (/^(?:use|create)[A-Z]/.test(callee.name) || options.customReactiveFunctions.includes(callee.name)) {
                for (const arg of node.arguments) {
                  permissivelyTrackNode(arg);
                }
              }
            } else if (node.callee.type === "MemberExpression") {
              const { property } = node.callee;
              if (property.type === "Identifier" && property.name === "addEventListener" && node.arguments.length >= 2) {
                pushTrackedScope(node.arguments[1], "called-function");
              } else if (property.type === "Identifier" && (/^(?:use|create)[A-Z]/.test(property.name) || options.customReactiveFunctions.includes(property.name))) {
                for (const arg of node.arguments) {
                  permissivelyTrackNode(arg);
                }
              }
            }
          } else if (node.type === "VariableDeclarator") {
            if (node.init?.type === "CallExpression" && node.init.callee.type === "Identifier") {
              if (matchImport(["createReactive", "createReaction"], node.init.callee.name)) {
                const track = getReturnedVar(node.id, context);
                if (track) {
                  for (const reference of track.references) {
                    if (!reference.init && reference.isReadOnly() && reference.identifier.parent?.type === "CallExpression" && reference.identifier.parent.callee === reference.identifier) {
                      const arg0 = reference.identifier.parent.arguments[0];
                      if (arg0) {
                        pushTrackedScope(arg0, "function");
                      }
                    }
                  }
                }
                if (isFunctionNode(node.init.arguments[0])) {
                  pushTrackedScope(node.init.arguments[0], "called-function");
                }
              }
            }
          } else if (node.type === "AssignmentExpression") {
            if (node.left.type === "MemberExpression" && node.left.property.type === "Identifier" && isFunctionNode(node.right) && /^on[a-z]+$/.test(node.left.property.name)) {
              pushTrackedScope(node.right, "called-function");
            }
          } else if (node.type === "TaggedTemplateExpression") {
            for (const expression of node.quasi.expressions) {
              if (isFunctionNode(expression)) {
                pushTrackedScope(expression, "called-function");
                for (const param of expression.params) {
                  if (param.type === "Identifier" && isPropsByName(param.name)) {
                    const variable = findVariable(context, param);
                    if (variable) scopeStack.pushProps(variable, currentScope().node);
                  }
                }
              }
            }
          }
        };
        return {
          ImportDeclaration: handleImportDeclaration,
          JSXExpressionContainer(node) {
            checkForTrackedScopes(node);
          },
          JSXSpreadAttribute(node) {
            checkForTrackedScopes(node);
          },
          CallExpression(node) {
            checkForTrackedScopes(node);
            checkForSyncCallbacks(node);
            const parent = node.parent && ignoreTransparentWrappers(node.parent, true);
            if (parent?.type !== "AssignmentExpression" && parent?.type !== "VariableDeclarator") {
              checkForReactiveAssignment(null, node);
            }
          },
          NewExpression(node) {
            checkForTrackedScopes(node);
          },
          VariableDeclarator(node) {
            if (node.init) {
              checkForReactiveAssignment(node.id, node.init);
              checkForTrackedScopes(node);
            }
          },
          AssignmentExpression(node) {
            if (node.left.type !== "MemberExpression") {
              checkForReactiveAssignment(node.left, node.right);
            }
            checkForTrackedScopes(node);
          },
          TaggedTemplateExpression(node) {
            checkForTrackedScopes(node);
          },
          "JSXElement > JSXExpressionContainer > :function"(node) {
            if (isFunctionNode(node) && node.parent?.type === "JSXExpressionContainer" && node.parent.parent?.type === "JSXElement") {
              const element = node.parent.parent;
              if (element.openingElement.name.type === "JSXIdentifier") {
                const tagName = element.openingElement.name.name;
                if (matchImport("For", tagName) && node.params.length === 2 && node.params[1].type === "Identifier") {
                  const index = findVariable(context, node.params[1]);
                  if (index) {
                    scopeStack.pushSignal(index, currentScope().node);
                  }
                } else if (matchImport("Index", tagName) && node.params.length >= 1 && node.params[0].type === "Identifier") {
                  const item = findVariable(context, node.params[0]);
                  if (item) {
                    scopeStack.pushSignal(item, currentScope().node);
                  }
                }
              }
            }
          },
          /* Function enter/exit */
          FunctionExpression: onFunctionEnter,
          ArrowFunctionExpression: onFunctionEnter,
          FunctionDeclaration: onFunctionEnter,
          Program: onFunctionEnter,
          "FunctionExpression:exit": onFunctionExit,
          "ArrowFunctionExpression:exit": onFunctionExit,
          "FunctionDeclaration:exit": onFunctionExit,
          "Program:exit": onFunctionExit,
          /* Detect JSX for adding props */
          JSXElement() {
            if (scopeStack.length) {
              currentScope().hasJSX = true;
            }
          },
          JSXFragment() {
            if (scopeStack.length) {
              currentScope().hasJSX = true;
            }
          }
        };
      }
    });
  }
});

// src/rules/self-closing-comp.ts
import { ESLintUtils as ESLintUtils18 } from "@typescript-eslint/utils";
function isComponent(node) {
  return node.name.type === "JSXIdentifier" && !isDOMElementName(node.name.name) || node.name.type === "JSXMemberExpression";
}
function isVoidDOMElementName(name2) {
  return voidDOMElementRegex.test(name2);
}
function childrenIsEmpty(node) {
  return node.parent.children.length === 0;
}
function childrenIsMultilineSpaces(node) {
  const childrens = node.parent.children;
  return childrens.length === 1 && childrens[0].type === "JSXText" && childrens[0].value.indexOf("\n") !== -1 && childrens[0].value.replace(/(?!\xA0)\s/g, "") === "";
}
var createRule18, voidDOMElementRegex, self_closing_comp_default;
var init_self_closing_comp = __esm({
  "src/rules/self-closing-comp.ts"() {
    "use strict";
    init_utils();
    init_compat();
    createRule18 = ESLintUtils18.RuleCreator.withoutDocs;
    voidDOMElementRegex = /^(?:area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$/;
    self_closing_comp_default = createRule18({
      meta: {
        type: "layout",
        docs: {
          description: "Disallow extra closing tags for components without children.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/self-closing-comp.md"
        },
        fixable: "code",
        schema: [
          {
            type: "object",
            properties: {
              component: {
                type: "string",
                description: "which Solid components should be self-closing when possible",
                enum: ["all", "none"],
                default: "all"
              },
              html: {
                type: "string",
                description: "which native elements should be self-closing when possible",
                enum: ["all", "void", "none"],
                default: "all"
              }
            },
            additionalProperties: false
          }
        ],
        messages: {
          selfClose: "Empty components are self-closing.",
          dontSelfClose: "This element should not be self-closing."
        }
      },
      defaultOptions: [],
      create(context) {
        function shouldBeSelfClosedWhenPossible(node) {
          if (isComponent(node)) {
            const whichComponents = context.options[0]?.component ?? "all";
            return whichComponents === "all";
          } else if (node.name.type === "JSXIdentifier" && isDOMElementName(node.name.name)) {
            const whichComponents = context.options[0]?.html ?? "all";
            switch (whichComponents) {
              case "all":
                return true;
              case "void":
                return isVoidDOMElementName(node.name.name);
              case "none":
                return false;
            }
          }
          return true;
        }
        return {
          JSXOpeningElement(node) {
            const canSelfClose = childrenIsEmpty(node) || childrenIsMultilineSpaces(node);
            if (canSelfClose) {
              const shouldSelfClose = shouldBeSelfClosedWhenPossible(node);
              if (shouldSelfClose && !node.selfClosing) {
                context.report({
                  node,
                  messageId: "selfClose",
                  fix(fixer) {
                    const openingElementEnding = node.range[1] - 1;
                    const closingElementEnding = node.parent.closingElement.range[1];
                    const range = [openingElementEnding, closingElementEnding];
                    return fixer.replaceTextRange(range, " />");
                  }
                });
              } else if (!shouldSelfClose && node.selfClosing) {
                context.report({
                  node,
                  messageId: "dontSelfClose",
                  fix(fixer) {
                    const sourceCode = getSourceCode(context);
                    const tagName = sourceCode.getText(node.name);
                    const selfCloseEnding = node.range[1];
                    const lastTokens = sourceCode.getLastTokens(node, { count: 3 });
                    const isSpaceBeforeSelfClose = sourceCode.isSpaceBetween?.(
                      lastTokens[0],
                      lastTokens[1]
                    );
                    const range = [
                      isSpaceBeforeSelfClose ? selfCloseEnding - 3 : selfCloseEnding - 2,
                      selfCloseEnding
                    ];
                    return fixer.replaceTextRange(range, `></${tagName}>`);
                  }
                });
              }
            }
          }
        };
      }
    });
  }
});

// src/rules/style-prop.ts
import { ESLintUtils as ESLintUtils19, ASTUtils as ASTUtils8 } from "@typescript-eslint/utils";
import kebabCase from "kebab-case";
import { all as allCssProperties } from "known-css-properties";
import parse from "style-to-object";
var createRule19, getPropertyName2, getStaticValue3, lengthPercentageRegex, style_prop_default;
var init_style_prop = __esm({
  "src/rules/style-prop.ts"() {
    "use strict";
    init_utils();
    init_compat();
    createRule19 = ESLintUtils19.RuleCreator.withoutDocs;
    ({ getPropertyName: getPropertyName2, getStaticValue: getStaticValue3 } = ASTUtils8);
    lengthPercentageRegex = /\b(?:width|height|margin|padding|border-width|font-size)\b/i;
    style_prop_default = createRule19({
      meta: {
        type: "problem",
        docs: {
          description: "Require CSS properties in the `style` prop to be valid and kebab-cased (ex. 'font-size'), not camel-cased (ex. 'fontSize') like in React, and that property values with dimensions are strings, not numbers with implicit 'px' units.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/style-prop.md"
        },
        fixable: "code",
        schema: [
          {
            type: "object",
            properties: {
              styleProps: {
                description: "an array of prop names to treat as a CSS style object",
                default: ["style"],
                type: "array",
                items: {
                  type: "string"
                },
                minItems: 1,
                uniqueItems: true
              },
              allowString: {
                description: "if allowString is set to true, this rule will not convert a style string literal into a style object (not recommended for performance)",
                type: "boolean",
                default: false
              }
            },
            additionalProperties: false
          }
        ],
        messages: {
          kebabStyleProp: "Use {{ kebabName }} instead of {{ name }}.",
          invalidStyleProp: "{{ name }} is not a valid CSS property.",
          numericStyleValue: 'This CSS property value should be a string with a unit; Solid does not automatically append a "px" unit.',
          stringStyle: "Use an object for the style prop instead of a string."
        }
      },
      defaultOptions: [],
      create(context) {
        const allCssPropertiesSet = new Set(allCssProperties);
        const allowString = Boolean(context.options[0]?.allowString);
        const styleProps = context.options[0]?.styleProps || ["style"];
        return {
          JSXAttribute(node) {
            if (styleProps.indexOf(jsxPropName(node)) === -1) {
              return;
            }
            const style = node.value?.type === "JSXExpressionContainer" ? node.value.expression : node.value;
            if (!style) {
              return;
            } else if (style.type === "Literal" && typeof style.value === "string" && !allowString) {
              let objectStyles;
              try {
                objectStyles = parse(style.value) ?? void 0;
              } catch {
              }
              context.report({
                node: style,
                messageId: "stringStyle",
                // replace full prop value, wrap in JSXExpressionContainer, more fixes may be applied below
                fix: objectStyles && ((fixer) => fixer.replaceText(node.value, `{${JSON.stringify(objectStyles)}}`))
              });
            } else if (style.type === "TemplateLiteral" && !allowString) {
              context.report({
                node: style,
                messageId: "stringStyle"
              });
            } else if (style.type === "ObjectExpression") {
              const properties = style.properties.filter(
                (prop) => prop.type === "Property"
              );
              properties.forEach((prop) => {
                const name2 = getPropertyName2(prop, getScope(context, prop));
                if (name2 && !name2.startsWith("--") && !allCssPropertiesSet.has(name2)) {
                  const kebabName = kebabCase(name2);
                  if (allCssPropertiesSet.has(kebabName)) {
                    context.report({
                      node: prop.key,
                      messageId: "kebabStyleProp",
                      data: { name: name2, kebabName },
                      fix: (fixer) => fixer.replaceText(prop.key, `"${kebabName}"`)
                      // wrap kebab name in quotes to be a valid object key
                    });
                  } else {
                    context.report({
                      node: prop.key,
                      messageId: "invalidStyleProp",
                      data: { name: name2 }
                    });
                  }
                } else if (!name2 || !name2.startsWith("--") && lengthPercentageRegex.test(name2)) {
                  const value = getStaticValue3(prop.value)?.value;
                  if (typeof value === "number" && value !== 0) {
                    context.report({ node: prop.value, messageId: "numericStyleValue" });
                  }
                }
              });
            }
          }
        };
      }
    });
  }
});

// src/rules/no-array-handlers.ts
import { ESLintUtils as ESLintUtils20 } from "@typescript-eslint/utils";
var createRule20, no_array_handlers_default;
var init_no_array_handlers = __esm({
  "src/rules/no-array-handlers.ts"() {
    "use strict";
    init_utils();
    createRule20 = ESLintUtils20.RuleCreator.withoutDocs;
    no_array_handlers_default = createRule20({
      meta: {
        type: "problem",
        docs: {
          description: "Disallow usage of type-unsafe event handlers.",
          url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-array-handlers.md"
        },
        schema: [],
        messages: {
          noArrayHandlers: "Passing an array as an event handler is potentially type-unsafe."
        }
      },
      defaultOptions: [],
      create(context) {
        return {
          JSXAttribute(node) {
            const openingElement = node.parent;
            if (openingElement.name.type !== "JSXIdentifier" || !isDOMElementName(openingElement.name.name)) {
              return;
            }
            const isNamespacedHandler = node.name.type === "JSXNamespacedName" && node.name.namespace.name === "on";
            const isNormalEventHandler = node.name.type === "JSXIdentifier" && /^on[a-zA-Z]/.test(node.name.name);
            if ((isNamespacedHandler || isNormalEventHandler) && node.value?.type === "JSXExpressionContainer" && trace(node.value.expression, context).type === "ArrayExpression") {
              context.report({
                node,
                messageId: "noArrayHandlers"
              });
            }
          }
        };
      }
    });
  }
});

// package.json
var require_package = __commonJS({
  "package.json"(exports, module) {
    module.exports = {
      name: "eslint-plugin-solid",
      version: "0.14.5",
      description: "Solid-specific linting rules for ESLint.",
      keywords: [
        "eslint",
        "eslintplugin",
        "solid",
        "solidjs",
        "reactivity"
      ],
      repository: "https://github.com/solidjs-community/eslint-plugin-solid",
      license: "MIT",
      author: "Josh Wilson <joshwilsonvu@gmail.com>",
      exports: {
        ".": {
          types: {
            import: "./dist/index.d.mts",
            require: "./dist/index.d.ts"
          },
          import: "./dist/index.mjs",
          require: "./dist/index.js"
        },
        "./configs/recommended": {
          types: {
            import: "./dist/configs/recommended.d.mts",
            require: "./dist/configs/recommended.d.ts"
          },
          import: "./dist/configs/recommended.mjs",
          require: "./dist/configs/recommended.js"
        },
        "./configs/typescript": {
          types: {
            import: "./dist/configs/typescript.d.mts",
            require: "./dist/configs/typescript.d.ts"
          },
          import: "./dist/configs/typescript.mjs",
          require: "./dist/configs/typescript.js"
        },
        "./package.json": "./package.json"
      },
      main: "dist/index.js",
      types: "dist/index.d.ts",
      files: [
        "src",
        "dist",
        "README.md"
      ],
      scripts: {
        build: "tsup",
        test: "vitest --run",
        "test:all": "PARSER=all vitest --run",
        "test:babel": "PARSER=babel vitest --run",
        "test:ts": "PARSER=ts vitest --run",
        "test:v6": "PARSER=v6 vitest --run",
        "test:v7": "PARSER=v7 vitest --run",
        "test:watch": "vitest",
        "turbo:build": "tsup",
        "turbo:docs": "PARSER=none tsx scripts/docs.ts",
        "turbo:test": "vitest --run"
      },
      dependencies: {
        "@typescript-eslint/utils": "^7.13.1 || ^8.0.0",
        estraverse: "^5.3.0",
        "is-html": "^2.0.0",
        "kebab-case": "^1.0.2",
        "known-css-properties": "^0.30.0",
        "style-to-object": "^1.0.6"
      },
      devDependencies: {
        "@babel/core": "^7.24.4",
        "@babel/eslint-parser": "^7.24.7",
        "@microsoft/api-extractor": "^7.47.6",
        "@types/eslint": "^8.56.10",
        "@types/eslint-v6": "npm:@types/eslint@6",
        "@types/eslint-v7": "npm:@types/eslint@7",
        "@types/eslint-v8": "npm:@types/eslint@8",
        "@types/eslint__js": "^8.42.3",
        "@types/estraverse": "^5.1.7",
        "@types/is-html": "^2.0.2",
        "@typescript-eslint/eslint-plugin": "^8.0.0",
        "@typescript-eslint/parser": "^8.0.0",
        eslint: "^9.5.0",
        "eslint-v6": "npm:eslint@6",
        "eslint-v7": "npm:eslint@7",
        "eslint-v8": "npm:eslint@8",
        "markdown-magic": "^3.3.0",
        prettier: "^2.8.8",
        tsup: "^8.2.4",
        tsx: "^4.17.0",
        vitest: "^1.5.2"
      },
      peerDependencies: {
        eslint: "^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0",
        typescript: ">=4.8.4"
      },
      engines: {
        node: ">=18.0.0"
      }
    };
  }
});

// src/plugin.ts
var name, version, meta, allRules, plugin;
var init_plugin = __esm({
  "src/plugin.ts"() {
    "use strict";
    init_components_return_once();
    init_event_handlers();
    init_imports();
    init_jsx_no_duplicate_props();
    init_jsx_no_script_url();
    init_jsx_no_undef();
    init_jsx_uses_vars();
    init_no_destructure();
    init_no_innerhtml();
    init_no_proxy_apis();
    init_no_react_deps();
    init_no_react_specific_props();
    init_no_unknown_namespaces();
    init_prefer_classlist();
    init_prefer_for();
    init_prefer_show();
    init_reactivity();
    init_self_closing_comp();
    init_style_prop();
    init_no_array_handlers();
    ({ name, version } = require_package());
    meta = { name, version };
    allRules = {
      "components-return-once": components_return_once_default,
      "event-handlers": event_handlers_default,
      imports: imports_default,
      "jsx-no-duplicate-props": jsx_no_duplicate_props_default,
      "jsx-no-undef": jsx_no_undef_default,
      "jsx-no-script-url": jsx_no_script_url_default,
      "jsx-uses-vars": jsx_uses_vars_default,
      "no-destructure": no_destructure_default,
      "no-innerhtml": no_innerhtml_default,
      "no-proxy-apis": no_proxy_apis_default,
      "no-react-deps": no_react_deps_default,
      "no-react-specific-props": no_react_specific_props_default,
      "no-unknown-namespaces": no_unknown_namespaces_default,
      "prefer-classlist": prefer_classlist_default,
      "prefer-for": prefer_for_default,
      "prefer-show": prefer_show_default,
      reactivity: reactivity_default,
      "self-closing-comp": self_closing_comp_default,
      "style-prop": style_prop_default,
      "no-array-handlers": no_array_handlers_default
      // "validate-jsx-nesting": validateJsxNesting
    };
    plugin = { meta, rules: allRules };
  }
});

// src/configs/recommended.ts
var require_recommended = __commonJS({
  "src/configs/recommended.ts"(exports, module) {
    init_plugin();
    var recommended = {
      plugins: {
        solid: plugin
      },
      languageOptions: {
        sourceType: "module",
        parserOptions: {
          ecmaFeatures: {
            jsx: true
          }
        }
      },
      rules: {
        // identifier usage is important
        "solid/jsx-no-duplicate-props": 2,
        "solid/jsx-no-undef": 2,
        "solid/jsx-uses-vars": 2,
        "solid/no-unknown-namespaces": 2,
        // security problems
        "solid/no-innerhtml": 2,
        "solid/jsx-no-script-url": 2,
        // reactivity
        "solid/components-return-once": 1,
        "solid/no-destructure": 2,
        "solid/prefer-for": 2,
        "solid/reactivity": 1,
        "solid/event-handlers": 1,
        // these rules are mostly style suggestions
        "solid/imports": 1,
        "solid/style-prop": 1,
        "solid/no-react-deps": 1,
        "solid/no-react-specific-props": 1,
        "solid/self-closing-comp": 1,
        "solid/no-array-handlers": 0,
        // handled by Solid compiler, opt-in style suggestion
        "solid/prefer-show": 0,
        // only necessary for resource-constrained environments
        "solid/no-proxy-apis": 0,
        // deprecated
        "solid/prefer-classlist": 0
      }
    };
    module.exports = recommended;
  }
});

export {
  __commonJS,
  __toESM,
  plugin,
  init_plugin,
  require_recommended
};
//# sourceMappingURL=chunk-5IRTCPIR.mjs.map