import { jsx, jsxs, Fragment } from 'solid-jsx/jsx-runtime';

/*@jsxRuntime automatic @jsxImportSource solid-jsx*/
const toc = [{
  "depth": 1,
  "value": "常见问题",
  "children": [{
    "depth": 3,
    "value": "没有虚拟 DOM 的 JSX？这是 雾件吗？我听过一些重要的声音说这是不可能的。",
    "children": []
  }, {
    "depth": 3,
    "value": "Solid 的性能如何？",
    "children": []
  }, {
    "depth": 3,
    "value": "是否有 React 兼容包吗，或者以某种方式在 Solid 中使用我的 React 库？",
    "children": []
  }, {
    "depth": 3,
    "value": "为什么我不应该在我的模板中使用 map，<For> 和 <Index> 有什么区别？",
    "children": []
  }, {
    "depth": 3,
    "value": "为什么我在解构 props 时会失去响应？",
    "children": []
  }, {
    "depth": 3,
    "value": "为什么我的 onChange 事件处理程序没有按时触发？",
    "children": []
  }, {
    "depth": 3,
    "value": "您可以添加对 class 组件的支持吗？我发现生命周期更容易推理。",
    "children": []
  }, {
    "depth": 3,
    "value": "我真的不喜欢 JSX，有没有机会使用不同的模板语言？ 哦，我看到有 Tagged Template Literals/HyperScript。也许我会用那些...",
    "children": []
  }, {
    "depth": 3,
    "value": "我什么时候使用 Signal 或者 Store? 它们有何不同?",
    "children": []
  }, {
    "depth": 3,
    "value": "为什么我不能像在 Vue、Svelte 或 MobX 中那样为 Solid 的 Store 赋值？有双向绑定么？",
    "children": []
  }, {
    "depth": 3,
    "value": "我可以单独使用 Solid 的响应性吗？",
    "children": []
  }, {
    "depth": 3,
    "value": "Solid 有我可以使用的 Next.js 或 Material Components 之类的库吗？",
    "children": []
  }]
}];
function _createMdxContent(props) {
  const _components = Object.assign({
    h1: "h1",
    a: "a",
    h3: "h3",
    p: "p",
    ol: "ol",
    li: "li",
    code: "code",
    pre: "pre",
    span: "span"
  }, props.components);
  return jsxs(Fragment, {
    children: [jsxs(_components.h1, {
      id: "常见问题",
      children: [jsx(_components.a, {
        className: "header-anchor",
        href: "#常见问题",
        children: "#"
      }), "常见问题"]
    }), "\n", jsxs(_components.h3, {
      id: "没有虚拟-dom-的-jsx这是-雾件吗我听过一些重要的声音说这是不可能的",
      children: [jsx(_components.a, {
        className: "header-anchor",
        href: "#没有虚拟-dom-的-jsx这是-雾件吗我听过一些重要的声音说这是不可能的",
        children: "#"
      }), "没有虚拟 DOM 的 JSX？这是 ", jsx(_components.a, {
        href: "https://zh.wikipedia.org/wiki/%E9%9C%A7%E4%BB%B6",
        children: "雾件"
      }), "吗？我听过一些重要的声音说这是不可能的。"]
    }), "\n", jsx(_components.p, {
      children: "当你没有 React 的更新模型时，这是可能的。JSX 是一种类似于 Svelte 或 Vue 中的模板语言——只是在某些方面更灵活。插入任意 JavaScript 有时可能具有挑战性，但与支持扩展运算符没有什么不同。所以不，这不是雾件，而是一种被证明是最高效的方法。"
    }), "\n", jsxs(_components.p, {
      children: ["真正的好处在于它的可扩展性。我们有一个编译器为您工作，为您提供最佳的原生 DOM 更新，但您拥有像 React 这样的库的所有自由。您可以使用诸如 ", jsx(_components.a, {
        href: "https://reactjs.org/docs/render-props.html",
        children: "render props"
      }), " 之类的标准技术和高阶组件以及您的响应性 “hooks” 来编写组件。不喜欢 Solid 的控制流程如何工作？写你自己的。"]
    }), "\n", jsxs(_components.h3, {
      id: "solid-的性能如何",
      children: [jsx(_components.a, {
        className: "header-anchor",
        href: "#solid-的性能如何",
        children: "#"
      }), "Solid 的性能如何？"]
    }), "\n", jsx(_components.p, {
      children: "我希望我只需要指出一件事，但它确实是几个重要设计决策的结合："
    }), "\n", jsxs(_components.ol, {
      children: ["\n", jsx(_components.li, {
        children: "显式响应性，因此只跟踪应该反应性的事物。"
      }), "\n", jsx(_components.li, {
        children: "编译时考虑到初始创建。Solid 使用启发式算法并结合正确的表达式来减少计算次数，同时保持关键更新的粒度和性能。"
      }), "\n", jsx(_components.li, {
        children: "响应式表达式只是函数。这使得 \"消失的组件\" 能够通过惰性 props 求值移除不必要的包装器和同步开销。"
      }), "\n"]
    }), "\n", jsx(_components.p, {
      children: "这些是目前独特的技术组合，使 Solid 在竞争中具有优势。"
    }), "\n", jsxs(_components.h3, {
      id: "是否有-react-兼容包吗或者以某种方式在-solid-中使用我的-react-库",
      children: [jsx(_components.a, {
        className: "header-anchor",
        href: "#是否有-react-兼容包吗或者以某种方式在-solid-中使用我的-react-库",
        children: "#"
      }), "是否有 React 兼容包吗，或者以某种方式在 Solid 中使用我的 React 库？"]
    }), "\n", jsx(_components.p, {
      children: "没有。而且很可能永远不会有。虽然 API 相似，并且组件通常可以通过少量修改来迁移，但更新模型根本不同。React 组件反复渲染，因此 Hooks 之外的代码工作方式非常不同。闭包和钩子规则不仅在 Solid 中是不必要的：它们可以规定在这里不起作用的代码。"
    }), "\n", jsx(_components.p, {
      children: "Vue 兼容包是可行的，尽管目前还没有实施它的计划。"
    }), "\n", jsxs(_components.p, {
      children: ["另一方面，可以在 React 中运行 Solid。", jsx(_components.a, {
        href: "https://github.com/solidjs/react-solid-state",
        children: "React Solid State"
      }), " 使 Solid API 在 React 函数组件中可访问。", jsx(_components.a, {
        href: "https://github.com/Sawtaytoes/reactjs-solidjs-bridge",
        children: "reactjs-solidjs-bridge"
      }), " 允许您在 Solid 组件中渲染 React 组件，反之亦然，这在逐步移植应用程序时很有用。"]
    }), "\n", jsxs(_components.h3, {
      id: "为什么我不应该在我的模板中使用-mapfor-和-index-有什么区别",
      children: [jsx(_components.a, {
        className: "header-anchor",
        href: "#为什么我不应该在我的模板中使用-mapfor-和-index-有什么区别",
        children: "#"
      }), "为什么我不应该在我的模板中使用 ", jsx(_components.code, {
        children: "map"
      }), "，", jsx(_components.code, {
        children: "<For>"
      }), " 和 ", jsx(_components.code, {
        children: "<Index>"
      }), " 有什么区别？"]
    }), "\n", jsxs(_components.p, {
      children: ["如果您的数组是静态的，则使用 map 没有任何问题。但是如果你在一个 signal 或 响应属性上循环，", jsx(_components.code, {
        children: "map"
      }), " 是低效的：如果数组因任何原因发生变化，整个 map 将重新运行，所有节点都将重新创建。"]
    }), "\n", jsxs(_components.p, {
      children: [jsx(_components.code, {
        children: "<For>"
      }), " 和 ", jsx(_components.code, {
        children: "<Index>"
      }), " 都提供了比这更智能的循环解决方案 它们将每个渲染的节点与数组中的一个元素耦合在一起，因此当数组元素发生变化时，只有相应的节点会重新渲染。"]
    }), "\n", jsxs(_components.p, {
      children: [jsx(_components.code, {
        children: "<Index>"
      }), " 将通过索引做到这一点：每个节点对应于数组中的一个索引； ", jsx(_components.code, {
        children: "<For>"
      }), " 将通过值来执行此操作：每个节点对应于数组中的一条数据。这就是为什么在回调中，", jsx(_components.code, {
        children: "<Index>"
      }), " 给你一个 item 的 signal：每个 item 的索引被认为是固定的，但该索引处的数据可以改变。另一方面，", jsx(_components.code, {
        children: "<For>"
      }), " 给你一个索引 signal：item 的内容被认为是固定的，但如果元素在数组中移动，它可以移动。"]
    }), "\n", jsxs(_components.p, {
      children: ["例如，如果数组中的两个元素被交换，", jsx(_components.code, {
        children: "<For>"
      }), " 将重新定位两个对应的 DOM 节点并在此过程中更新它们的 ", jsx(_components.code, {
        children: "index()"
      }), " 信号。", jsx(_components.code, {
        children: "<Index>"
      }), " 不会重新定位任何 DOM 节点，但会更新两个 DOM 节点的 ", jsx(_components.code, {
        children: "item()"
      }), " 信号并导致它们重新呈现。"]
    }), "\n", jsxs(_components.p, {
      children: ["有关差异的深入演示，请查看 Ryan 直播的 ", jsx(_components.a, {
        href: "https://www.youtube.com/watch?v=YxroH_MXuhw&t=2164s",
        children: "这个片段"
      }), "。"]
    }), "\n", jsxs(_components.h3, {
      id: "为什么我在解构-props-时会失去响应",
      children: [jsx(_components.a, {
        className: "header-anchor",
        href: "#为什么我在解构-props-时会失去响应",
        children: "#"
      }), "为什么我在解构 props 时会失去响应？"]
    }), "\n", jsx(_components.p, {
      children: "使用 props 对象，通过跟踪属性访问来启用响应性。如果您在跟踪范围内访问属性，例如 JSX 表达式或 effect，则 JSX 表达式将重新呈现，或者 effect 将在该属性更改时重新运行。"
    }), "\n", jsx(_components.p, {
      children: "解构时，您可以访问对象的属性。如果这发生在跟踪范围之外，Solid 将不会跟踪并重新运行您的代码。"
    }), "\n", jsx(_components.p, {
      children: "在此示例中，属性访问发生在 JSX 模板中，因此会对其进行跟踪，并在信号更改时更新 span 内容："
    }), "\n", jsx(_components.pre, {
      children: jsxs(_components.code, {
        className: "hljs language-jsx",
        children: [jsx(_components.span, {
          className: "hljs-keyword",
          children: "function"
        }), " ", jsx(_components.span, {
          className: "hljs-title function_",
          children: "BlueText"
        }), "(", jsx(_components.span, {
          className: "hljs-params",
          children: "props"
        }), ") {\n  ", jsx(_components.span, {
          className: "hljs-keyword",
          children: "return"
        }), " (\n    ", jsxs(_components.span, {
          className: "xml",
          children: [jsxs(_components.span, {
            className: "hljs-tag",
            children: ["<", jsx(_components.span, {
              className: "hljs-name",
              children: "span"
            }), " ", jsx(_components.span, {
              className: "hljs-attr",
              children: "style"
            }), "=", jsx(_components.span, {
              className: "hljs-string",
              children: "\"color: blue\""
            }), ">"]
          }), "{props.text}", jsxs(_components.span, {
            className: "hljs-tag",
            children: ["</", jsx(_components.span, {
              className: "hljs-name",
              children: "span"
            }), ">"]
          })]
        }), "\n  );\n}\n...\n<", jsx(_components.span, {
          className: "hljs-title class_",
          children: "BlueText"
        }), " text={", jsx(_components.span, {
          className: "hljs-title function_",
          children: "mySignal"
        }), "()}/>\n"]
      })
    }), "\n", jsx(_components.p, {
      children: "但是这些示例都不会更新 span 文本，因为属性访问发生在模板之外："
    }), "\n", jsx(_components.pre, {
      children: jsxs(_components.code, {
        className: "hljs language-jsx",
        children: [jsx(_components.span, {
          className: "hljs-keyword",
          children: "function"
        }), " ", jsx(_components.span, {
          className: "hljs-title function_",
          children: "BlueText"
        }), "(", jsx(_components.span, {
          className: "hljs-params",
          children: "props"
        }), ") {\n  ", jsx(_components.span, {
          className: "hljs-keyword",
          children: "const"
        }), " text = props.", jsx(_components.span, {
          className: "hljs-property",
          children: "text"
        }), ";\n  ", jsx(_components.span, {
          className: "hljs-keyword",
          children: "return"
        }), " (\n    ", jsxs(_components.span, {
          className: "xml",
          children: [jsxs(_components.span, {
            className: "hljs-tag",
            children: ["<", jsx(_components.span, {
              className: "hljs-name",
              children: "span"
            }), " ", jsx(_components.span, {
              className: "hljs-attr",
              children: "style"
            }), "=", jsx(_components.span, {
              className: "hljs-string",
              children: "\"color: blue\""
            }), ">"]
          }), "{text}", jsxs(_components.span, {
            className: "hljs-tag",
            children: ["</", jsx(_components.span, {
              className: "hljs-name",
              children: "span"
            }), ">"]
          })]
        }), "\n  );\n}\n...\n<", jsx(_components.span, {
          className: "hljs-title class_",
          children: "BlueText"
        }), " text={", jsx(_components.span, {
          className: "hljs-title function_",
          children: "mySignal"
        }), "()}/>\n"]
      })
    }), "\n", jsx(_components.pre, {
      children: jsxs(_components.code, {
        className: "hljs language-jsx",
        children: [jsx(_components.span, {
          className: "hljs-keyword",
          children: "function"
        }), " ", jsx(_components.span, {
          className: "hljs-title function_",
          children: "BlueText"
        }), "(", jsx(_components.span, {
          className: "hljs-params",
          children: "{text}"
        }), ") {\n  ", jsx(_components.span, {
          className: "hljs-keyword",
          children: "return"
        }), " (\n    ", jsxs(_components.span, {
          className: "xml",
          children: [jsxs(_components.span, {
            className: "hljs-tag",
            children: ["<", jsx(_components.span, {
              className: "hljs-name",
              children: "span"
            }), " ", jsx(_components.span, {
              className: "hljs-attr",
              children: "style"
            }), "=", jsx(_components.span, {
              className: "hljs-string",
              children: "\"color: blue\""
            }), ">"]
          }), "{text}", jsxs(_components.span, {
            className: "hljs-tag",
            children: ["</", jsx(_components.span, {
              className: "hljs-name",
              children: "span"
            }), ">"]
          })]
        }), "\n  );\n}\n...\n<", jsx(_components.span, {
          className: "hljs-title class_",
          children: "BlueText"
        }), " text={", jsx(_components.span, {
          className: "hljs-title function_",
          children: "mySignal"
        }), "()}/>\n"]
      })
    }), "\n", jsxs(_components.p, {
      children: ["但是，如果您更喜欢提前解构的风格，可以使用两种不同的 Babel 转换来使（某些风格的）解构再次具有响应性：", jsx(_components.a, {
        href: "https://github.com/orenelbaum/babel-plugin-solid-undestructure",
        children: "babel-plugin-solid-undestructure"
      }), " 和 ", jsx(_components.a, {
        href: "https://github.com/LXSMNSYC/solid-labels/blob/main/docs/ctf.md#objects",
        children: "Solid Labels object features"
      }), "。"]
    }), "\n", jsxs(_components.h3, {
      id: "为什么我的-onchange-事件处理程序没有按时触发",
      children: [jsx(_components.a, {
        className: "header-anchor",
        href: "#为什么我的-onchange-事件处理程序没有按时触发",
        children: "#"
      }), "为什么我的 ", jsx(_components.code, {
        children: "onChange"
      }), " 事件处理程序没有按时触发？"]
    }), "\n", jsxs(_components.p, {
      children: ["在某些框架中，输入的 ", jsx(_components.code, {
        children: "onChange"
      }), " 事件会被修改，以便在每次按键时触发。但这不是 ", jsx(_components.code, {
        children: "onChange"
      }), " 事件 ", jsx(_components.a, {
        href: "https://developer.mozilla.org/en-US/docs/Web/API/GlobalEventHandlers/onchange",
        children: "原生工作"
      }), " 的方式：它旨在反映对输入的已提交更改，并且通常会在输入失去焦点时触发。要处理对输入值的所有更改，请使用", jsx(_components.code, {
        children: "onInput"
      }), "。"]
    }), "\n", jsxs(_components.h3, {
      id: "您可以添加对-class-组件的支持吗我发现生命周期更容易推理",
      children: [jsx(_components.a, {
        className: "header-anchor",
        href: "#您可以添加对-class-组件的支持吗我发现生命周期更容易推理",
        children: "#"
      }), "您可以添加对 class 组件的支持吗？我发现生命周期更容易推理。"]
    }), "\n", jsx(_components.p, {
      children: "我们不打算支持 class 组件。Solid 中组件的生命周期与响应式系统的调度相关，并且是人为的。您可以从中创建一个类，但实际上所有非事件处理程序代码都将在构造函数中运行，包括渲染函数。这只是你不细化数据要求更多语法的借口。"
    }), "\n", jsx(_components.p, {
      children: "将数据及其行为组合在一起，而不是将生命周期组合在一起。这是一种已经奏效了数十年的响应式最佳实践。"
    }), "\n", jsxs(_components.h3, {
      id: "我真的不喜欢-jsx有没有机会使用不同的模板语言-哦我看到有-tagged-template-literalshyperscript也许我会用那些",
      children: [jsx(_components.a, {
        className: "header-anchor",
        href: "#我真的不喜欢-jsx有没有机会使用不同的模板语言-哦我看到有-tagged-template-literalshyperscript也许我会用那些",
        children: "#"
      }), "我真的不喜欢 JSX，有没有机会使用不同的模板语言？ 哦，我看到有 Tagged Template Literals/HyperScript。也许我会用那些..."]
    }), "\n", jsx(_components.p, {
      children: "我们使用 JSX 就像 Svelte 使用他们的模板一样，来创建优化的 DOM 指令。Tagged Template Literal 和 HyperScript 解决方案本身可能确实令人印象深刻，但除非您有真正的理由，例如不使用构建工具的要求，否则它们在各方面都较差。较大的捆绑包、较慢的性能以及需要手动解决方法包装值。"
    }), "\n", jsx(_components.p, {
      children: "有选择固然好，但 Solid 的 JSX 确实是这里最好的解决方案。一个模板 DSL 也很好，虽然限制性更强，但是 JSX 免费为我们提供了很多。现有的解析器、语法高亮、Prettier、代码完成，以及 TypeScript。"
    }), "\n", jsx(_components.p, {
      children: "其他的库一直在添加对这些功能的支持，仍然不完善，并且经常令人头疼。而这些功能在 jsx 中开箱即用，并且完成度非常的高，其他人很难再做出一个比 jsx 更好的模版语言。"
    }), "\n", jsxs(_components.h3, {
      id: "我什么时候使用-signal-或者-store-它们有何不同",
      children: [jsx(_components.a, {
        className: "header-anchor",
        href: "#我什么时候使用-signal-或者-store-它们有何不同",
        children: "#"
      }), "我什么时候使用 Signal 或者 Store? 它们有何不同?"]
    }), "\n", jsx(_components.p, {
      children: "store 自动包装嵌套值，使其成为深层数据结构，是数据模型的理想选择。对于大多数其他情况，Signal 是轻量级的，并且可以出色地完成工作。"
    }), "\n", jsxs(_components.p, {
      children: ["尽管我很想将这些包装在一起作为一个单一的 API，但你不能代理基本数据类型。函数是最简单的接口，任何响应式式表达式（包括状态访问）都可以在传输时包装成一个，如果这提供了一个通用 API。你可以随意命名你的 signal 和状态，并且它保持最小。我想要做的最后一件事是在用户端强制键入 ", jsx(_components.code, {
        children: ".get()"
      }), " ", jsx(_components.code, {
        children: ".set()"
      }), " 或更糟的 ", jsx(_components.code, {
        children: ".value"
      }), "。为了简洁起见，至少前者可以使用别名，而后者只是调用函数的最简单的方法。"]
    }), "\n", jsxs(_components.h3, {
      id: "为什么我不能像在-vuesvelte-或-mobx-中那样为-solid-的-store-赋值有双向绑定么",
      children: [jsx(_components.a, {
        className: "header-anchor",
        href: "#为什么我不能像在-vuesvelte-或-mobx-中那样为-solid-的-store-赋值有双向绑定么",
        children: "#"
      }), "为什么我不能像在 Vue、Svelte 或 MobX 中那样为 Solid 的 Store 赋值？有双向绑定么？"]
    }), "\n", jsx(_components.p, {
      children: "响应性是一种强大的工具，但也是一种危险的工具。MobX 知道这一点并引入了严格模式和 Action 来限制更新发生的位置/时间。在 Solid 处理整个组件数据树时，我意识到我们可以从 React 中学到一些东西。只要你提供拥有相同约定的方法，你就不需要实际上是不可变的数据。"
    }), "\n", jsx(_components.p, {
      children: "能够传递更新状态的能力可以说比决定传递状态更重要。因此，能够将其分开很重要，而且只有在读取不可变的情况下才有可能。如果我们仍然可以粒度更新，我们也不需要付出不可变的成本。幸运的是，ImmutableJS 和 Immer 有大量的现有技术。具有讽刺意味的是，Solid 主要用作具有可变内部结构和不可变接口，和 Immer 刚好相反。"
    }), "\n", jsxs(_components.h3, {
      id: "我可以单独使用-solid-的响应性吗",
      children: [jsx(_components.a, {
        className: "header-anchor",
        href: "#我可以单独使用-solid-的响应性吗",
        children: "#"
      }), "我可以单独使用 Solid 的响应性吗？"]
    }), "\n", jsxs(_components.p, {
      children: ["当然。虽然我没有导出一个独立的包，但很容易在没有编译器的情况下安装 Solid，只需使用反应 primitive。粒度响应性的好处之一是它与库无关。就此而言，几乎每个反应式库都是这样工作的。这启发了 ", jsx(_components.a, {
        href: "https://github.com/solidjs/solid",
        children: "Solid"
      }), " ，Solid 内部使用 ", jsx(_components.a, {
        href: "https://github.com/ryansolid/dom-expressions",
        children: "DOM 表达式库"
      }), " 并根据纯粹的响应式系统来创建的渲染器。"]
    }), "\n", jsxs(_components.p, {
      children: ["列出一些可尝试的库: ", jsx(_components.a, {
        href: "https://github.com/solidjs/solid",
        children: "Solid"
      }), ", ", jsx(_components.a, {
        href: "https://github.com/mobxjs/mobx",
        children: "MobX"
      }), ", ", jsx(_components.a, {
        href: "https://github.com/knockout/knockout",
        children: "Knockout"
      }), ", ", jsx(_components.a, {
        href: "https://github.com/sveltejs/svelte",
        children: "Svelte"
      }), ", ", jsx(_components.a, {
        href: "https://github.com/adamhaile/S",
        children: "S.js"
      }), ", ", jsx(_components.a, {
        href: "https://github.com/Riim/cellx",
        children: "CellX"
      }), ", ", jsx(_components.a, {
        href: "https://github.com/ds300/derivablejs",
        children: "Derivable"
      }), ", ", jsx(_components.a, {
        href: "https://github.com/luwes/sinuous",
        children: "Sinuous"
      }), ", 甚至最近的 ", jsx(_components.a, {
        href: "https://github.com/vuejs/vue",
        children: "Vue"
      }), ". 制作响应式库比将其标记到渲染器上工作量要多得多，例如 ", jsx(_components.a, {
        href: "https://github.com/Polymer/lit-html",
        children: "lit-html"
      }), "，但这有助于帮你找到感觉。"]
    }), "\n", jsxs(_components.h3, {
      id: "solid-有我可以使用的-nextjs-或-material-components-之类的库吗",
      children: [jsx(_components.a, {
        className: "header-anchor",
        href: "#solid-有我可以使用的-nextjs-或-material-components-之类的库吗",
        children: "#"
      }), "Solid 有我可以使用的 Next.js 或 Material Components 之类的库吗？"]
    }), "\n", jsxs(_components.p, {
      children: ["我们正在开发 ", jsx(_components.a, {
        href: "https://github.com/solidjs/solid-start",
        children: "SolidStart"
      }), "，类似于 Next.js 或 SvelteKit。"]
    }), "\n", jsxs(_components.p, {
      children: ["对于组件库，我们有用于 Material 的 ", jsx(_components.a, {
        href: "https://suid.io/",
        children: "SUID"
      }), "、用于类似 Chakra 的解决方案的 ", jsx(_components.a, {
        href: "https://hope-ui.com/",
        children: "Hope UI"
      }), "、", jsx(_components.a, {
        href: "https://solid-libs.github.io/solid-bootstrap/",
        children: "Solid Bootstrap"
      }), " 等等！ 查看我们的快速增长的库和工具 ", jsx(_components.a, {
        href: "https://www.solidjs.com/ecosystem",
        children: "生态系统"
      }), "。"]
    }), "\n", jsxs(_components.p, {
      children: ["如果您有兴趣构建自己的生态系统工具或者加入现有的生态系统工作，可以加入我们的 ", jsx(_components.a, {
        href: "https://discord.com/invite/solidjs",
        children: "Discord"
      }), " 的频道一起讨论。"]
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = props.components || ({});
  return MDXLayout ? jsx(MDXLayout, Object.assign({}, props, {
    children: jsx(_createMdxContent, props)
  })) : _createMdxContent(props);
}

export { MDXContent as default, toc };
//# sourceMappingURL=faq-1afdc7ee.js.map
