Merge pull request #62 from moonlight-mod/lunast

API v2

.prettierignore

···
-pnpm-lock.yml
+pnpm-lock.yaml

build.mjs

···
   "module",
   "events",
   "original-fs", // wtf asar?
+  "discord", // mappings
 
   // Silence an esbuild warning
   "./node-preload.js"

packages/core-extensions/src/common/index.ts

···
 import { ExtensionWebExports } from "@moonlight-mod/types";
 
 export const webpackModules: ExtensionWebExports["webpackModules"] = {
-  components: {
+  stores: {
     dependencies: [
-      { ext: "spacepack", id: "spacepack" },
-      "MasonryList:",
-      ".flexGutterSmall,"
+      {
+        id: "discord/packages/flux"
+      }
     ]
-  },
-
-  flux: {
-    dependencies: [{ ext: "spacepack", id: "spacepack" }, "connectStores:"]
-  },
-
-  fluxDispatcher: {
-    dependencies: [
-      { ext: "spacepack", id: "spacepack" },
-      "isDispatching",
-      "dispatch"
-    ]
-  },
-
-  react: {
-    dependencies: [
-      { ext: "spacepack", id: "spacepack" },
-      "__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED",
-      /\.?version(?:=|:)/,
-      /\.?createElement(?:=|:)/
-    ]
-  },
-
-  stores: {
-    dependencies: [{ ext: "common", id: "flux" }]
   }
 };

packages/core-extensions/src/common/manifest.json

···
 {
   "id": "common",
+  "apiLevel": 2,
   "meta": {
     "name": "Common",
     "tagline": "A *lot* of common clientmodding utilities from the Discord client",

packages/core-extensions/src/common/webpackModules/components.ts

···
-import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
-
-const Components = spacepack.findByCode("MasonryList:function")[0].exports;
-const MarkdownParser = spacepack.findByCode(
-  "parseAutoModerationSystemMessage:"
-)[0].exports.Z;
-const LegacyText = spacepack.findByCode(".selectable", ".colorStandard")[0]
-  .exports.default;
-const Flex = Object.values(
-  spacepack.findByCode(".flex" + "GutterSmall,")[0].exports
-)[0];
-
-const CardClasses = {};
-spacepack
-  .lazyLoad(
-    "renderArtisanalHack",
-    /\[(?:.\.e\("\d+?"\),?)+\][^}]+?webpackId:\d+,name:"ChannelSettings"/,
-    /webpackId:(\d+),name:"ChannelSettings"/
-  )
-  .then(() =>
-    Object.assign(
-      CardClasses,
-      spacepack.findByExports("card", "cardHeader", "inModal")[0].exports
-    )
-  );
-
-const ControlClasses = spacepack.findByCode(
-  "title",
-  "titleDefault",
-  "dividerDefault"
-)[0].exports;
-
-// We use CJS export here because merging the exports from Components is annoying as shit
-module.exports = {
-  ...Components,
-  MarkdownParser,
-  LegacyText,
-  Flex,
-  CardClasses,
-  ControlClasses
-};

packages/core-extensions/src/common/webpackModules/flux.ts

···
-import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
-
-const mod = spacepack.findByCode("connectStores:")[0].exports;
-
-const useStateFromStores = spacepack.findFunctionByStrings(
-  mod,
-  '"useStateFromStores"'
-)!;
-
-module.exports = {
-  BatchedStoreListener: spacepack.findFunctionByStrings(
-    mod,
-    " tried to load a non-existent store."
-  ),
-  Dispatcher: spacepack.findFunctionByStrings(mod, "_dispatchWithDevtools("),
-  Store: spacepack.findFunctionByStrings(mod, "registerActionHandlers("),
-  default: mod.ZP,
-  statesWillNeverBeEqual: spacepack.findFunctionByStrings(mod, "return!1"),
-  useStateFromStores,
-  useStateFromStoresArray: spacepack.findFunctionByStrings(
-    mod,
-    new RegExp(`return ${useStateFromStores.name}\\(.+?\\.[^Z]\\)`)
-  ),
-  useStateFromStoresObject: spacepack.findFunctionByStrings(
-    mod,
-    new RegExp(`return ${useStateFromStores.name}\\(.+?\\.Z\\)`)
-  )
-};

packages/core-extensions/src/common/webpackModules/fluxDispatcher.ts

···
-import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
-
-module.exports = spacepack.findByExports(
-  "isDispatching",
-  "dispatch"
-)[0].exports.Z;

packages/core-extensions/src/common/webpackModules/react.ts

···
-import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
-
-module.exports = spacepack.findByCode(
-  "__SECRET_INTERNALS_DO_NOT_USE" + "_OR_YOU_WILL_BE_FIRED",
-  /\.?version(?:=|:)/,
-  /\.?createElement(?:=|:)/
-)[0].exports;

packages/core-extensions/src/common/webpackModules/stores.ts

···
-import Flux from "@moonlight-mod/wp/common_flux";
+import { Store } from "@moonlight-mod/wp/discord/packages/flux";
 
 module.exports = new Proxy(
   {},
   {
     get: function (target, key, receiver) {
-      const allStores = Flux.Store.getAll();
+      const allStores = Store.getAll();
 
       let targetStore;
       for (const store of allStores) {

packages/core-extensions/src/contextMenu/manifest.json

···
 {
   "id": "contextMenu",
+  "apiLevel": 2,
   "meta": {
     "name": "Context Menu",
     "tagline": "A library for patching and creating context menus",

packages/core-extensions/src/disableSentry/manifest.json

···
 {
   "id": "disableSentry",
+  "apiLevel": 2,
   "meta": {
     "name": "Disable Sentry",
     "tagline": "Turns off Discord's error reporting systems",

packages/core-extensions/src/experiments/manifest.json

···
 {
   "id": "experiments",
+  "apiLevel": 2,
   "meta": {
     "name": "Experiments",
     "tagline": "Allows you to configure Discord's internal A/B testing features",

packages/core-extensions/src/markdown/manifest.json

···
 {
   "id": "markdown",
+  "apiLevel": 2,
   "meta": {
     "name": "Markdown",
     "tagline": "A library for adding new markdown rules",

packages/core-extensions/src/moonbase/index.tsx

···
 export const webpackModules: ExtensionWebExports["webpackModules"] = {
   stores: {
     dependencies: [
-      { ext: "common", id: "flux" },
-      { ext: "common", id: "fluxDispatcher" }
+      { id: "discord/packages/flux" },
+      { id: "discord/Dispatcher" }
     ]
   },
 
   ui: {
     dependencies: [
       { ext: "spacepack", id: "spacepack" },
-      { ext: "common", id: "react" },
-      { ext: "common", id: "components" },
+      { id: "react" },
+      { id: "discord/components/common/index" },
       { ext: "moonbase", id: "stores" },
+      { id: "discord/modules/guild_settings/IntegrationCard.css" },
       "Masks.PANEL_BUTTON",
-      "renderArtisanalHack(){",
       '"Missing channel in Channel.openChannelContextMenu"',
       ".forumOrHome]:"
     ]
···
     dependencies: [
       { ext: "spacepack", id: "spacepack" },
       { ext: "settings", id: "settings" },
-      { ext: "common", id: "react" },
+      { id: "react" },
       { ext: "moonbase", id: "ui" }
     ],
     entrypoint: true

packages/core-extensions/src/moonbase/manifest.json

···
 {
   "id": "moonbase",
+  "apiLevel": 2,
   "meta": {
     "name": "Moonbase",
     "tagline": "The official settings UI for moonlight",

packages/core-extensions/src/moonbase/webpackModules/moonbase.tsx

···
 import settings from "@moonlight-mod/wp/settings_settings";
-import React from "@moonlight-mod/wp/common_react";
+import React from "@moonlight-mod/wp/react";
 import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
 import { Moonbase, pages } from "@moonlight-mod/wp/moonbase_ui";
 
 import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
-import { MenuItem } from "@moonlight-mod/wp/common_components";
+import { MenuItem } from "@moonlight-mod/wp/discord/components/common/index";
 
 const { open } = spacepack.findByExports("setSection", "clearSubsection")[0]
   .exports.Z;

packages/core-extensions/src/moonbase/webpackModules/stores.ts

···
 import { Config, ExtensionLoadSource } from "@moonlight-mod/types";
 import { ExtensionState, MoonbaseExtension, MoonbaseNatives } from "../types";
-import Flux from "@moonlight-mod/wp/common_flux";
-import Dispatcher from "@moonlight-mod/wp/common_fluxDispatcher";
+import { Store } from "@moonlight-mod/wp/discord/packages/flux";
+import Dispatcher from "@moonlight-mod/wp/discord/Dispatcher";
 
 const natives: MoonbaseNatives = moonlight.getNatives("moonbase");
 const logger = moonlight.getLogger("moonbase");
 
-class MoonbaseSettingsStore extends Flux.Store<any> {
+class MoonbaseSettingsStore extends Store<any> {
   private origConfig: Config;
   private config: Config;
   private extensionIndex: number;
···
       for (const [repo, exts] of Object.entries(ret)) {
         try {
           for (const ext of exts) {
+            const level = ext.apiLevel ?? 1;
+            if (level !== window.moonlight.apiLevel) continue;
+
             const uniqueId = this.extensionIndex++;
             const extensionData = {
               id: ext.id,

packages/core-extensions/src/moonbase/webpackModules/ui/config/index.tsx

···
   (v) => typeof v === "string"
 ) as string[];
 
-import React from "@moonlight-mod/wp/common_react";
+import React from "@moonlight-mod/wp/react";
 import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
 import {
   FormDivider,
···
   FormText,
   FormSwitch,
   TextInput,
-  Flex,
   Button,
   SingleSelect,
   Tooltip,
   Clickable
-} from "@moonlight-mod/wp/common_components";
-import CommonComponents from "@moonlight-mod/wp/common_components";
+} from "@moonlight-mod/wp/discord/components/common/index";
+import Flex from "@moonlight-mod/wp/discord/uikit/Flex";
+import * as Components from "@moonlight-mod/wp/discord/components/common/index";
 
 import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
 
···
         .exports)
   );
 
-const { CircleXIcon } = CommonComponents;
+// FIXME: type component keys
+const { CircleXIcon } = Components;
+
 function RemoveEntryButton({ onClick }: { onClick: () => void }) {
   return (
     <div className={RemoveButtonClasses.removeButtonContainer}>

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/card.tsx

···
 import { ExtensionState } from "../../../types";
 import { ExtensionLoadSource } from "@moonlight-mod/types";
 
-import React from "@moonlight-mod/wp/common_react";
 import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
-import CommonComponents from "@moonlight-mod/wp/common_components";
-import * as Flux from "@moonlight-mod/wp/common_flux";
+import * as Components from "@moonlight-mod/wp/discord/components/common/index";
+import React from "@moonlight-mod/wp/react";
+import { useStateFromStores } from "@moonlight-mod/wp/discord/packages/flux";
+import Flex from "@moonlight-mod/wp/discord/uikit/Flex";
+import MarkupUtils from "@moonlight-mod/wp/discord/modules/markup/MarkupUtils";
+import IntegrationCard from "@moonlight-mod/wp/discord/modules/guild_settings/IntegrationCard.css";
 
 import ExtensionInfo from "./info";
 import Settings from "./settings";
···
 
 import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
 
-const { DownloadIcon, TrashIcon, CircleWarningIcon } = CommonComponents;
+const { DownloadIcon, TrashIcon, CircleWarningIcon } = Components;
 
 const PanelButton = spacepack.findByCode("Masks.PANEL_BUTTON")[0].exports.Z;
 const TabBarClasses = spacepack.findByExports(
···
   const [tab, setTab] = React.useState(ExtensionPage.Info);
   const [restartNeeded, setRestartNeeded] = React.useState(false);
 
-  const { ext, enabled, busy, update, conflicting } = Flux.useStateFromStores(
+  const { ext, enabled, busy, update, conflicting } = useStateFromStores(
     [MoonbaseSettingsStore],
     () => {
       return {
···
   // Why it work like that :sob:
   if (ext == null) return <></>;
 
-  const {
-    Card,
-    CardClasses,
-    Flex,
-    Text,
-    MarkdownParser,
-    Switch,
-    TabBar,
-    Button
-  } = CommonComponents;
+  const { Card, Text, Switch, TabBar, Button } = Components;
 
   const tagline = ext.manifest?.meta?.tagline;
   const settings = ext.manifest?.settings;
   const description = ext.manifest?.meta?.description;
 
   return (
-    <Card editable={true} className={CardClasses.card}>
-      <div className={CardClasses.cardHeader}>
+    <Card editable={true} className={IntegrationCard.card}>
+      <div className={IntegrationCard.cardHeader}>
         <Flex direction={Flex.Direction.VERTICAL}>
           <Flex direction={Flex.Direction.HORIZONTAL}>
             <Text variant="text-md/semibold">
···
           </Flex>
 
           {tagline != null && (
-            <Text variant="text-sm/normal">
-              {MarkdownParser.parse(tagline)}
-            </Text>
+            <Text variant="text-sm/normal">{MarkupUtils.parse(tagline)}</Text>
           )}
         </Flex>
 
···
                 <PanelButton
                   icon={() => (
                     <CircleWarningIcon
-                      color={CommonComponents.tokens.colors.STATUS_DANGER}
+                      color={Components.tokens.colors.STATUS_DANGER}
                     />
                   )}
                   onClick={() => window.location.reload()}
···
           {tab === ExtensionPage.Info && <ExtensionInfo ext={ext} />}
           {tab === ExtensionPage.Description && (
             <Text variant="text-md/normal">
-              {MarkdownParser.parse(description ?? "*No description*")}
+              {MarkupUtils.parse(description ?? "*No description*")}
             </Text>
           )}
           {tab === ExtensionPage.Settings && <Settings ext={ext} />}

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/filterBar.tsx

···
 import { tagNames } from "./info";
 
 import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
-import React from "@moonlight-mod/wp/common_react";
-import * as Flux from "@moonlight-mod/wp/common_flux";
+import * as React from "@moonlight-mod/wp/react";
+import { useStateFromStores } from "@moonlight-mod/wp/discord/packages/flux";
 import { WindowStore } from "@moonlight-mod/wp/common_stores";
 import {
   Button,
···
   MenuGroup,
   MenuCheckboxItem,
   MenuItem
-} from "@moonlight-mod/wp/common_components";
-import CommonComponents from "@moonlight-mod/wp/common_components";
+} from "@moonlight-mod/wp/discord/components/common/index";
+import * as Components from "@moonlight-mod/wp/discord/components/common/index";
 
 export enum Filter {
   Core = 1 << 0,
···
 const TagItem = spacepack.findByCode(".FORUM_TAG_A11Y_FILTER_BY_TAG")[0].exports
   .Z;
 
+// FIXME: type component keys
 const { ChevronSmallDownIcon, ChevronSmallUpIcon, ArrowsUpDownIcon } =
-  CommonComponents;
+  Components;
 
 function toggleTag(
   selectedTags: Set<string>,
···
   selectedTags: Set<string>;
   setSelectedTags: (tags: Set<string>) => void;
 }) {
-  const windowSize = Flux.useStateFromStores([WindowStore], () =>
+  const windowSize = useStateFromStores([WindowStore], () =>
     WindowStore.windowSize()
   );
 

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/index.tsx

···
 import FilterBar, { Filter, defaultFilter } from "./filterBar";
 import ExtensionCard from "./card";
 
-import React from "@moonlight-mod/wp/common_react";
+import React from "@moonlight-mod/wp/react";
 import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
-import * as Flux from "@moonlight-mod/wp/common_flux";
+import { useStateFromStoresObject } from "@moonlight-mod/wp/discord/packages/flux";
 
 import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
 
···
 
 export default function ExtensionsPage() {
   const moonbaseId = MoonbaseSettingsStore.getExtensionUniqueId("moonbase")!;
-  const { extensions, savedFilter } = Flux.useStateFromStoresObject(
+  const { extensions, savedFilter } = useStateFromStoresObject(
     [MoonbaseSettingsStore],
     () => {
       return {

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/info.tsx

···
 import { ExtensionTag } from "@moonlight-mod/types";
 import { MoonbaseExtension } from "../../../types";
 
-import React from "@moonlight-mod/wp/common_react";
-import CommonComponents from "@moonlight-mod/wp/common_components";
+import React from "@moonlight-mod/wp/react";
+import * as Components from "@moonlight-mod/wp/discord/components/common/index";
 import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
 
 type Dependency = {
···
 
 import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
 
+// FIXME: type component keys
+const { Text } = Components;
+
 function InfoSection({
   title,
   children
···
         marginRight: "1em"
       }}
     >
-      <CommonComponents.Text
-        variant="eyebrow"
-        className={UserInfoClasses.userInfoSectionHeader}
-      >
+      <Text variant="eyebrow" className={UserInfoClasses.userInfoSectionHeader}>
         {title}
-      </CommonComponents.Text>
+      </Text>
 
-      <CommonComponents.Text variant="text-sm/normal">
-        {children}
-      </CommonComponents.Text>
+      <Text variant="text-sm/normal">{children}</Text>
     </div>
   );
 }

packages/core-extensions/src/moonbase/webpackModules/ui/extensions/settings.tsx

···
 
 import { ExtensionState, MoonbaseExtension } from "../../../types";
 
-import React from "@moonlight-mod/wp/common_react";
-import CommonComponents from "@moonlight-mod/wp/common_components";
-import * as Flux from "@moonlight-mod/wp/common_flux";
 import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
+import React from "@moonlight-mod/wp/react";
+import * as Components from "@moonlight-mod/wp/discord/components/common/index";
+import { useStateFromStores } from "@moonlight-mod/wp/discord/packages/flux";
+import Flex from "@moonlight-mod/wp/discord/uikit/Flex";
 
 type SettingsProps = {
   ext: MoonbaseExtension;
···
 type SettingsComponent = React.ComponentType<SettingsProps>;
 
 import { MoonbaseSettingsStore } from "@moonlight-mod/wp/moonbase_stores";
-
-const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;
+const Margins = spacepack.require("discord/styles/shared/Margins.css");
 
 function useConfigEntry<T>(uniqueId: number, name: string) {
-  return Flux.useStateFromStores(
+  return useStateFromStores(
     [MoonbaseSettingsStore],
     () => {
       return {
···
 }
 
 function Boolean({ ext, name, setting, disabled }: SettingsProps) {
-  const { FormSwitch } = CommonComponents;
+  const { FormSwitch } = Components;
   const { value, displayName, description } = useConfigEntry<boolean>(
     ext.uniqueId,
     name
···
 }
 
 function Number({ ext, name, setting, disabled }: SettingsProps) {
-  const { FormItem, FormText, Slider } = CommonComponents;
+  const { FormItem, FormText, Slider } = Components;
   const { value, displayName, description } = useConfigEntry<number>(
     ext.uniqueId,
     name
···
 }
 
 function String({ ext, name, setting, disabled }: SettingsProps) {
-  const { FormItem, FormText, TextInput } = CommonComponents;
+  const { FormItem, FormText, TextInput } = Components;
   const { value, displayName, description } = useConfigEntry<string>(
     ext.uniqueId,
     name
···
 }
 
 function MultilineString({ ext, name, setting, disabled }: SettingsProps) {
-  const { FormItem, FormText, TextArea } = CommonComponents;
+  const { FormItem, FormText, TextArea } = Components;
   const { value, displayName, description } = useConfigEntry<string>(
     ext.uniqueId,
     name
···
 }
 
 function Select({ ext, name, setting, disabled }: SettingsProps) {
-  const { FormItem, FormText, SingleSelect } = CommonComponents;
+  const { FormItem, FormText, SingleSelect } = Components;
   const { value, displayName, description } = useConfigEntry<string>(
     ext.uniqueId,
     name
···
 
 function MultiSelect({ ext, name, setting, disabled }: SettingsProps) {
   const { FormItem, FormText, Select, useVariableSelect, multiSelect } =
-    CommonComponents;
+    Components;
   const { value, displayName, description } = useConfigEntry<string | string[]>(
     ext.uniqueId,
     name
···
 
 const RemoveButtonClasses = spacepack.findByCode("removeButtonContainer")[0]
   .exports;
-const CircleXIcon = CommonComponents.CircleXIcon;
+
+// FIXME: type component keys
+const { CircleXIcon } = Components;
+
 function RemoveEntryButton({
   onClick,
   disabled
···
   onClick: () => void;
   disabled: boolean;
 }) {
-  const { Tooltip, Clickable } = CommonComponents;
+  const { Tooltip, Clickable } = Components;
   return (
     <div className={RemoveButtonClasses.removeButtonContainer}>
       <Tooltip text="Remove entry" position="top">
···
 }
 
 function List({ ext, name, setting, disabled }: SettingsProps) {
-  const { FormItem, FormText, TextInput, Button, Flex } = CommonComponents;
+  const { FormItem, FormText, TextInput, Button } = Components;
   const { value, displayName, description } = useConfigEntry<string[]>(
     ext.uniqueId,
     name
···
 }
 
 function Dictionary({ ext, name, setting, disabled }: SettingsProps) {
-  const { FormItem, FormText, TextInput, Button, Flex } = CommonComponents;
+  const { FormItem, FormText, TextInput, Button } = Components;
   const { value, displayName, description } = useConfigEntry<
     Record<string, string>
   >(ext.uniqueId, name);
···
 }
 
 export default function Settings({ ext }: { ext: MoonbaseExtension }) {
-  const { Flex } = CommonComponents;
   return (
     <Flex className="moonbase-settings" direction={Flex.Direction.VERTICAL}>
       {Object.entries(ext.manifest.settings!).map(([name, setting]) => (

packages/core-extensions/src/moonbase/webpackModules/ui/index.tsx

···
-import React from "@moonlight-mod/wp/common_react";
+import React from "@moonlight-mod/wp/react";
 import spacepack from "@moonlight-mod/wp/spacepack_spacepack";
-import { Text, TabBar } from "@moonlight-mod/wp/common_components";
-import * as Flux from "@moonlight-mod/wp/common_flux";
+import {
+  Text,
+  TabBar
+} from "@moonlight-mod/wp/discord/components/common/index";
+import { useStateFromStores } from "@moonlight-mod/wp/discord/packages/flux";
 import { UserSettingsModalStore } from "@moonlight-mod/wp/common_stores";
 
 import ExtensionsPage from "./extensions";
 import ConfigPage from "./config";
-
-const Margins = spacepack.findByCode("marginCenterHorz:")[0].exports;
 
 const { Divider } = spacepack.findByCode(".forumOrHome]:")[0].exports.Z;
 const TitleBarClasses = spacepack.findByCode("iconWrapper:", "children:")[0]
···
   "setSection",
   "clearSubsection"
 )[0].exports.Z;
+const Margins = spacepack.require("discord/styles/shared/Margins.css");
 
 export const pages: {
   id: string;
···
 ];
 
 export function Moonbase(props: { initialTab?: number } = {}) {
-  const subsection = Flux.useStateFromStores(
+  const subsection = useStateFromStores(
     [UserSettingsModalStore],
     () => UserSettingsModalStore.getSubsection() ?? 0
   );

packages/core-extensions/src/noHideToken/manifest.json

···
 {
   "id": "noHideToken",
+  "apiLevel": 2,
   "meta": {
     "name": "No Hide Token",
     "tagline": "Disables removal of token from localStorage when opening dev tools",

packages/core-extensions/src/noTrack/manifest.json

···
 {
   "id": "noTrack",
+  "apiLevel": 2,
   "meta": {
     "name": "No Track",
     "tagline": "Disables /api/science and analytics",

packages/core-extensions/src/quietLoggers/manifest.json

···
 {
   "id": "quietLoggers",
+  "apiLevel": 2,
   "meta": {
     "name": "Quiet Loggers",
     "tagline": "Quiet errors on startup, and disable unnecesary loggers",

packages/core-extensions/src/settings/manifest.json

···
 {
   "id": "settings",
+  "apiLevel": 2,
   "meta": {
     "name": "Settings",
     "tagline": "An API for adding to Discord's settings menu",

packages/core-extensions/src/settings/webpackModules/settings.ts

···
 import {
   SettingsSection,
   Settings as SettingsType
-} from "@moonlight-mod/types/coreExtensions";
+} from "@moonlight-mod/types/coreExtensions/settings";
 
 export const Settings: SettingsType = {
   ourSections: [],

packages/core-extensions/src/spacepack/index.ts

···
 import { ExtensionWebExports } from "@moonlight-mod/types";
-import { Spacepack } from "@moonlight-mod/types/coreExtensions";
+import { Spacepack } from "@moonlight-mod/types/coreExtensions/spacepack";
 
 declare global {
   interface Window {

packages/core-extensions/src/spacepack/manifest.json

···
 {
   "id": "spacepack",
+  "apiLevel": 2,
   "meta": {
     "name": "Spacepack",
     "tagline": "Search utilities across all Webpack modules",

packages/core-extensions/src/spacepack/webpackModules/spacepack.ts

···
   WebpackModuleFunc,
   WebpackRequireType
 } from "@moonlight-mod/types";
-import { Spacepack } from "@moonlight-mod/types/coreExtensions";
+import { Spacepack } from "@moonlight-mod/types/coreExtensions/spacepack";
 
 const webpackRequire = require as unknown as WebpackRequireType;
 const cache = webpackRequire.c;
···
   inspect: (module: number | string) => {
     if (typeof module === "number") {
       module = module.toString();
+    }
+
+    if (module in moonlight.moonmap.modules) {
+      module = moonlight.moonmap.modules[module];
     }
 
     if (!(module in modules)) {

packages/core/src/extension.ts

···
     const manifest: ExtensionManifest = JSON.parse(
       fs.readFileSync(manifestPath, "utf8")
     );
+    const level = manifest.apiLevel ?? 1;
+    if (level !== constants.apiLevel) {
+      continue;
+    }
 
     const webPath = path.join(dir, "index.js");
     const nodePath = path.join(dir, "node.js");

packages/core/src/extension/loader.ts

···
 async function loadExt(ext: DetectedExtension) {
   webPreload: {
     if (ext.scripts.web != null) {
-      const source =
-        ext.scripts.web + "\n//# sourceURL=file:///" + ext.scripts.webPath;
+      const source = ext.scripts.web;
       const fn = new Function("require", "module", "exports", source);
 
       const module = { id: ext.id, exports: {} };

packages/core/src/patch.ts

···
   IdentifiedWebpackModule,
   WebpackJsonp,
   WebpackJsonpEntry,
-  WebpackModuleFunc
+  WebpackModuleFunc,
+  WebpackRequireType
 } from "@moonlight-mod/types";
 import Logger from "./util/logger";
 import calculateDependencies, { Dependency } from "./util/dependency";
···
 // Can't be Set because we need splice
 const patches: IdentifiedPatch[] = [];
 let webpackModules: Set<IdentifiedWebpackModule> = new Set();
+let webpackRequire: WebpackRequireType | null = null;
 
 const moduleLoadSubscriptions: Map<string, ((moduleId: string) => void)[]> =
   new Map();
···
 const patched: Record<string, Array<string>> = {};
 
 function patchModules(entry: WebpackJsonpEntry[1]) {
+  function patchModule(id: string, patchId: string, replaced: string) {
+    // Store what extensions patched what modules for easier debugging
+    patched[id] = patched[id] || [];
+    patched[id].push(patchId);
+
+    // Webpack module arguments are minified, so we replace them with consistent names
+    // We have to wrap it so things don't break, though
+    const patchedStr = patched[id].sort().join(", ");
+
+    const wrapped =
+      `(${replaced}).apply(this, arguments)\n` +
+      `// Patched by moonlight: ${patchedStr}\n` +
+      `//# sourceURL=Webpack-Module-${id}`;
+
+    try {
+      const func = new Function(
+        "module",
+        "exports",
+        "require",
+        wrapped
+      ) as WebpackModuleFunc;
+      entry[id] = func;
+      entry[id].__moonlight = true;
+      return true;
+    } catch (e) {
+      logger.warn("Error constructing function for patch", patchId, e);
+      patched[id].pop();
+      return false;
+    }
+  }
+
+  // Populate the module cache
   for (const [id, func] of Object.entries(entry)) {
-    let moduleString = Object.prototype.hasOwnProperty.call(moduleCache, id)
-      ? moduleCache[id]
-      : func.toString().replace(/\n/g, "");
+    if (!Object.hasOwn(moduleCache, id) && func.__moonlight !== true) {
+      moduleCache[id] = func.toString().replace(/\n/g, "");
+      moonlight.moonmap.parseScript(id, moduleCache[id]);
+    }
+  }
+
+  for (const [id, func] of Object.entries(entry)) {
+    if (func.__moonlight === true) continue;
+    let moduleString = moduleCache[id];
 
     for (let i = 0; i < patches.length; i++) {
       const patch = patches[i];
···
             continue;
           }
 
-          // Store what extensions patched what modules for easier debugging
-          patched[id] = patched[id] || [];
-          patched[id].push(`${patch.ext}#${patch.id}`);
-
-          // Webpack module arguments are minified, so we replace them with consistent names
-          // We have to wrap it so things don't break, though
-          const patchedStr = patched[id].sort().join(", ");
-
-          const wrapped =
-            `(${replaced}).apply(this, arguments)\n` +
-            `// Patched by moonlight: ${patchedStr}\n` +
-            `//# sourceURL=Webpack-Module-${id}`;
-
-          try {
-            const func = new Function(
-              "module",
-              "exports",
-              "require",
-              wrapped
-            ) as WebpackModuleFunc;
-            entry[id] = func;
-            entry[id].__moonlight = true;
+          if (patchModule(id, `${patch.ext}#${patch.id}`, replaced)) {
             moduleString = replaced;
-          } catch (e) {
-            logger.warn("Error constructing function for patch", patch, e);
-            patched[id].pop();
           }
         } else if (replace.type === PatchReplaceType.Module) {
           // Directly replace the module with a new one
···
       }
     }
 
+    moduleCache[id] = moduleString;
+
+    try {
+      const parsed = moonlight.lunast.parseScript(id, moduleString);
+      if (parsed != null) {
+        for (const [parsedId, parsedScript] of Object.entries(parsed)) {
+          if (patchModule(parsedId, "lunast", parsedScript)) {
+            moduleCache[parsedId] = parsedScript;
+          }
+        }
+      }
+    } catch (e) {
+      logger.error("Failed to parse script for LunAST", id, e);
+    }
+
     if (moonlightNode.config.patchAll === true) {
       if (
         (typeof id !== "string" || !id.includes("_")) &&
         !entry[id].__moonlight
       ) {
         const wrapped =
-          `(${moduleString}).apply(this, arguments)\n` +
+          `(${moduleCache[id]}).apply(this, arguments)\n` +
           `//# sourceURL=Webpack-Module-${id}`;
         entry[id] = new Function(
           "module",
···
   mark when we've completed it already.
 */
 let chunkId = Number.MAX_SAFE_INTEGER;
+
+function depToString(x: ExplicitExtensionDependency) {
+  return x.ext != null ? `${x.ext}_${x.id}` : x.id;
+}
 
 function handleModuleDependencies() {
   const modules = Array.from(webpackModules.values());
···
   const dependencies: Dependency<string, IdentifiedWebpackModule>[] =
     modules.map((wp) => {
       return {
-        id: `${wp.ext}_${wp.id}`,
+        id: depToString(wp),
         data: wp
       };
     });
 
   const [sorted, _] = calculateDependencies(dependencies, {
     fetchDep: (id) => {
-      return modules.find((x) => id === `${x.ext}_${x.id}`) ?? null;
+      return modules.find((x) => id === depToString(x)) ?? null;
     },
 
     getDeps: (item) => {
···
       return (
         deps.filter(
           (dep) =>
-            !(
-              dep instanceof RegExp ||
-              typeof dep === "string" ||
-              dep.ext === undefined
-            )
+            !(dep instanceof RegExp || typeof dep === "string") &&
+            dep.ext != null
         ) as ExplicitExtensionDependency[]
-      ).map((x) => `${x.ext}_${x.id}`);
+      ).map(depToString);
     }
   });
 
···
   for (const [_modId, mod] of Object.entries(entry)) {
     const modStr = mod.toString();
     for (const wpModule of webpackModules) {
-      const id = wpModule.ext ? wpModule.ext + "_" + wpModule.id : wpModule.id;
+      const id = depToString(wpModule);
       if (wpModule.dependencies) {
         const deps = new Set(wpModule.dependencies);
 
···
             } else if (dep instanceof RegExp) {
               if (dep.test(modStr)) deps.delete(dep);
             } else if (
-              injectedWpModules.find((x) =>
-                wpModule.ext
-                  ? x.ext === dep.ext && x.id === dep.id
-                  : x.id === dep.id
-              )
+              dep.ext != null
+                ? injectedWpModules.find(
+                    (x) => x.ext === dep.ext && x.id === dep.id
+                  )
+                : injectedWpModules.find((x) => x.id === dep.id)
             ) {
               deps.delete(dep);
             }
···
     if (!webpackModules.size) break;
   }
 
+  for (const [name, func] of Object.entries(
+    moonlight.moonmap.getWebpackModules("window.moonlight.moonmap")
+  )) {
+    injectedWpModules.push({ id: name, run: func });
+    modules[name] = func;
+    inject = true;
+  }
+
+  if (webpackRequire != null) {
+    for (const id of moonlight.moonmap.getLazyModules()) {
+      webpackRequire.e(id);
+    }
+  }
+
   if (inject) {
     logger.debug("Injecting modules:", modules, entrypoints);
     window.webpackChunkdiscord_app.push([
···
   interface Window {
     webpackChunkdiscord_app: WebpackJsonp;
   }
+}
+
+function moduleSourceGetter(id: string) {
+  return moduleCache[id] ?? null;
 }
 
 /*
···
 */
 export async function installWebpackPatcher() {
   await handleModuleDependencies();
+
+  moonlight.lunast.setModuleSourceGetter(moduleSourceGetter);
+  moonlight.moonmap.setModuleSourceGetter(moduleSourceGetter);
+
+  const wpRequireFetcher: WebpackModuleFunc = (module, exports, require) => {
+    webpackRequire = require;
+  };
+  wpRequireFetcher.__moonlight = true;
+  webpackModules.add({
+    id: "moonlight",
+    entrypoint: true,
+    run: wpRequireFetcher
+  });
 
   let realWebpackJsonp: WebpackJsonp | null = null;
   Object.defineProperty(window, "webpackChunkdiscord_app", {

packages/core/src/persist.ts

···
 const logger = new Logger("core/persist");
 
 export default function persist(asarPath: string) {
+  try {
+    if (process.platform === "win32") {
+      persistWin32(asarPath);
+    }
+  } catch (e) {
+    logger.error(`Failed to persist moonlight: ${e}`);
+  }
+}
+
+function persistWin32(asarPath: string) {
   const updaterModule = require(join(asarPath, "common", "updater"));
   const updater = updaterModule.Updater;
 

packages/types/package.json

···
     "./*": "./src/*.ts"
   },
   "dependencies": {
-    "@types/flux": "^3.1.12",
-    "@types/react": "^18.2.22",
+    "@moonlight-mod/lunast": "^1.0.0",
+    "@moonlight-mod/mappings": "^1.0.0",
+    "@moonlight-mod/moonmap": "^1.0.2",
+    "@types/react": "^18.3.10",
     "csstype": "^3.1.2",
     "standalone-electron-types": "^1.0.0"
   }

packages/types/src/constants.ts

···
 export const ipcGetIsMoonlightDesktop = "_moonlight_getIsMoonlightDesktop";
 export const ipcMessageBox = "_moonlight_messageBox";
 export const ipcSetCorsList = "_moonlight_setCorsList";
+
+export const apiLevel = 2;

packages/types/src/coreExtensions.ts

···
-import { FluxDefault, Store } from "./discord/common/Flux";
-import { CommonComponents as CommonComponents_ } from "./coreExtensions/components";
-import { Dispatcher } from "flux";
-import React, { ReactElement } from "react";
-import {
-  WebpackModule,
-  WebpackModuleFunc,
-  WebpackRequireType
-} from "./discord";
-
-export type Spacepack = {
-  inspect: (module: number | string) => WebpackModuleFunc | null;
-  findByCode: (...args: (string | RegExp)[]) => any[];
-  findByExports: (...args: string[]) => any[];
-  require: WebpackRequireType;
-  modules: Record<string, WebpackModuleFunc>;
-  cache: Record<string, any>;
-  findObjectFromKey: (exports: Record<string, any>, key: string) => any | null;
-  findObjectFromValue: (exports: Record<string, any>, value: any) => any | null;
-  findObjectFromKeyValuePair: (
-    exports: Record<string, any>,
-    key: string,
-    value: any
-  ) => any | null;
-  findFunctionByStrings: (
-    exports: Record<string, any>,
-    ...strings: (string | RegExp)[]
-    // eslint-disable-next-line @typescript-eslint/ban-types
-  ) => Function | null;
-  lazyLoad: (
-    find: string | RegExp | (string | RegExp)[],
-    chunk: RegExp,
-    module: RegExp
-  ) => Promise<any>;
-  filterReal: (modules: WebpackModule[]) => WebpackModule[];
-};
-
-export type NoticeProps = {
-  stores: Store<any>[];
-  element: React.FunctionComponent;
-};
-
-export type SettingsSection =
-  | { section: "DIVIDER"; pos: number }
-  | { section: "HEADER"; label: string; pos: number }
-  | {
-      section: string;
-      label: string;
-      color: string | null;
-      element: React.FunctionComponent;
-      pos: number;
-      notice?: NoticeProps;
-      _moonlight_submenu?: () => ReactElement | ReactElement[];
-    };
-
-export type Settings = {
-  ourSections: SettingsSection[];
-  sectionNames: string[];
-  sectionMenuItems: Record<string, ReactElement[]>;
-
-  addSection: (
-    section: string,
-    label: string,
-    element: React.FunctionComponent,
-    color?: string | null,
-    pos?: number,
-    notice?: NoticeProps
-  ) => void;
-  addSectionMenuItems: (section: string, ...items: ReactElement[]) => void;
-
-  addDivider: (pos: number | null) => void;
-  addHeader: (label: string, pos: number | null) => void;
-  _mutateSections: (sections: SettingsSection[]) => SettingsSection[];
-};
-
-export type CommonReact = typeof import("react");
-export type CommonFlux = FluxDefault;
-export type CommonComponents = CommonComponents_; // lol
-export type CommonFluxDispatcher = Dispatcher<any> & {
-  dispatch: (payload: any) => void;
-  isDispatching: () => boolean;
-
-  addInterceptor: (interceptor: (event: any) => boolean | undefined) => void;
-
-  flushWaitQueue: () => void;
-  wait: (callback: () => void) => void;
-
-  subscribe: (eventType: string, callback: (event: any) => void) => void;
-  unsubscribe: (eventType: string, callback: (event: any) => void) => void;
-
-  register: (
-    name: string,
-    actionHandlers: Record<string, (event: any) => void>,
-    storeDidChange: (event: any) => void,
-    band: number,
-    token: string
-  ) => number;
-
-  createToken: () => string;
-  addDependencies: (id: string, deps: string[]) => void;
-};
-
+export * as Spacepack from "./coreExtensions/spacepack";
+export * as Settings from "./coreExtensions/settings";
 export * as Markdown from "./coreExtensions/markdown";
 export * as ContextMenu from "./coreExtensions/contextMenu";

packages/types/src/coreExtensions/components.ts

···
-import type {
-  Component,
-  Ref,
-  PropsWithChildren,
-  PropsWithoutRef,
-  CSSProperties,
-  ReactNode,
-  ReactElement,
-  ComponentClass,
-  ComponentType,
-  MouseEventHandler,
-  KeyboardEventHandler
-} from "react";
-import * as CSS from "csstype";
-
-export enum TextInputSizes {
-  DEFAULT = "inputDefault",
-  MINI = "inputMini"
-}
-
-interface TextInput
-  extends ComponentClass<
-    PropsWithoutRef<{
-      value?: string;
-      name?: string;
-      className?: string;
-      inputClassName?: string;
-      inputPrefix?: string;
-      disabled?: boolean;
-      size?: TextInputSizes;
-      editable?: boolean;
-      inputRef?: Ref<any>;
-      prefixElement?: Component;
-      focusProps?: PropsWithoutRef<any>;
-      error?: string;
-      minLength?: number;
-      maxLength?: number;
-      onChange?: (value: string, name: string) => void;
-      onFocus?: (event: any, name: string) => void;
-      onBlur?: (event: any, name: string) => void;
-    }>
-  > {
-  Sizes: typeof TextInputSizes;
-}
-
-export enum TextAreaAutoComplete {
-  ON = "on",
-  OFF = "off"
-}
-
-export enum TextAreaWrap {
-  HARD = "hard",
-  SOFT = "soft",
-  OFF = "off"
-}
-
-interface TextArea
-  extends ComponentClass<
-    PropsWithoutRef<{
-      value?: string;
-      defaultValue?: string;
-      autoComplete?: TextAreaAutoComplete;
-      autoFocus?: boolean;
-      cols?: number;
-      disabled?: boolean;
-      form?: string;
-      maxLength?: number;
-      minLength?: number;
-      name?: string;
-      onChange?: (value: string, name: string) => void;
-      onChangeCapture?: (value: string, name: string) => void;
-      onInput?: (value: string, name: string) => void;
-      onInputCapture?: (value: string, name: string) => void;
-      onInvalid?: (value: string, name: string) => void;
-      onInvalidCapture?: (value: string, name: string) => void;
-      onSelect?: (value: string, name: string) => void;
-      onSelectCapture?: (value: string, name: string) => void;
-      placeholder?: string;
-      readOnly?: boolean;
-      required?: boolean;
-      rows?: number;
-      wrap?: TextAreaWrap;
-      className?: string;
-    }>
-  > {
-  AutoCompletes: typeof TextAreaAutoComplete;
-  Wraps: typeof TextAreaWrap;
-}
-
-export enum FormTextTypes {
-  DEFAULT = "default",
-  DESCRIPTION = "description",
-  ERROR = "error",
-  INPUT_PLACEHOLDER = "placeholder",
-  LABEL_BOLD = "labelBold",
-  LABEL_DESCRIPTOR = "labelDescriptor",
-  LABEL_SELECTED = "labelSelected",
-  SUCCESS = "success"
-}
-
-interface FormText
-  extends ComponentClass<
-    PropsWithChildren<{
-      type?: FormTextTypes;
-      className?: string;
-      disabled?: boolean;
-      selectable?: boolean;
-      style?: CSSProperties;
-    }>
-  > {
-  Types: FormTextTypes;
-}
-
-declare enum SliderMarkerPosition {
-  ABOVE,
-  BELOW
-}
-
-declare enum ButtonLooks {
-  FILLED = "lookFilled",
-  INVERTED = "lookInverted",
-  OUTLINED = "lookOutlined",
-  LINK = "lookLink",
-  BLANK = "lookBlank"
-}
-declare enum ButtonColors {
-  BRAND = "colorBrand",
-  RED = "colorRed",
-  GREEN = "colorGreen",
-  YELLOW = "colorYellow",
-  PRIMARY = "colorPrimary",
-  LINK = "colorLink",
-  WHITE = "colorWhite",
-  BLACK = "colorBlack",
-  TRANSPARENT = "colorTransparent",
-  BRAND_NEW = "colorBrandNew",
-  CUSTOM = ""
-}
-declare enum ButtonBorderColors {
-  BRAND = "borderBrand",
-  RED = "borderRed",
-  GREEN = "borderGreen",
-  YELLOW = "borderYellow",
-  PRIMARY = "borderPrimary",
-  LINK = "borderLink",
-  WHITE = "borderWhite",
-  BLACK = "borderBlack",
-  TRANSPARENT = "borderTransparent",
-  BRAND_NEW = "borderBrandNew"
-}
-declare enum ButtonHovers {
-  DEFAULT = "",
-  BRAND = "hoverBrand",
-  RED = "hoverRed",
-  GREEN = "hoverGreen",
-  YELLOW = "hoverYellow",
-  PRIMARY = "hoverPrimary",
-  LINK = "hoverLink",
-  WHITE = "hoverWhite",
-  BLACK = "hoverBlack",
-  TRANSPARENT = "hoverTransparent"
-}
-declare enum ButtonSizes {
-  NONE = "",
-  TINY = "sizeTiny",
-  SMALL = "sizeSmall",
-  MEDIUM = "sizeMedium",
-  LARGE = "sizeLarge",
-  XLARGE = "sizeXlarge",
-  MIN = "sizeMin",
-  MAX = "sizeMax",
-  ICON = "sizeIcon"
-}
-
-type Button = ComponentType<
-  PropsWithChildren<{
-    look?: ButtonLooks;
-    color?: ButtonColors;
-    borderColor?: ButtonBorderColors;
-    hover?: ButtonHovers;
-    size?: ButtonSizes;
-    fullWidth?: boolean;
-    grow?: boolean;
-    disabled?: boolean;
-    submitting?: boolean;
-    type?: string;
-    style?: CSSProperties;
-    wrapperClassName?: string;
-    className?: string;
-    innerClassName?: string;
-    onClick?: MouseEventHandler;
-    onDoubleClick?: MouseEventHandler;
-    onMouseDown?: MouseEventHandler;
-    onMouseUp?: MouseEventHandler;
-    onMouseEnter?: MouseEventHandler;
-    onMouseLeave?: MouseEventHandler;
-    onKeyDown?: KeyboardEventHandler;
-    rel?: any;
-    buttonRef?: Ref<any>;
-    focusProps?: PropsWithChildren<any>;
-    "aria-label"?: string;
-    submittingStartedLabel?: string;
-    submittingFinishedLabel?: string;
-  }>
-> & {
-  Looks: typeof ButtonLooks;
-  Colors: typeof ButtonColors;
-  BorderColors: typeof ButtonBorderColors;
-  Hovers: typeof ButtonHovers;
-  Sizes: typeof ButtonSizes;
-};
-
-export enum FlexDirection {
-  VERTICAL = "vertical",
-  HORIZONTAL = "horizontal",
-  HORIZONTAL_REVERSE = "horizontalReverse"
-}
-
-declare enum FlexAlign {
-  START = "alignStart",
-  END = "alignEnd",
-  CENTER = "alignCenter",
-  STRETCH = "alignStretch",
-  BASELINE = "alignBaseline"
-}
-declare enum FlexJustify {
-  START = "justifyStart",
-  END = "justifyEnd",
-  CENTER = "justifyCenter",
-  BETWEEN = "justifyBetween",
-  AROUND = "justifyAround"
-}
-declare enum FlexWrap {
-  NO_WRAP = "noWrap",
-  WRAP = "wrap",
-  WRAP_REVERSE = "wrapReverse"
-}
-interface Flex
-  extends ComponentClass<
-    PropsWithChildren<{
-      className?: string;
-      direction?: FlexDirection;
-      justify?: FlexJustify;
-      align?: FlexAlign;
-      wrap?: FlexWrap;
-      shrink?: CSS.Property.FlexShrink;
-      grow?: CSS.Property.FlexGrow;
-      basis?: CSS.Property.FlexBasis;
-      style?: CSSProperties;
-    }>
-  > {
-  Direction: typeof FlexDirection;
-  Align: typeof FlexAlign;
-  Justify: typeof FlexJustify;
-  Wrap: typeof FlexWrap;
-  Child: Component<
-    PropsWithChildren<{
-      className?: string;
-      shrink?: CSS.Property.FlexShrink;
-      grow?: CSS.Property.FlexGrow;
-      basis?: CSS.Property.FlexBasis;
-      style?: CSSProperties;
-      wrap?: boolean;
-    }>
-  >;
-}
-
-// TODO: wtaf is up with react types not working in jsx
-export type CommonComponents = {
-  [index: string]: any;
-  Clickable: ComponentClass<
-    PropsWithChildren<{
-      onClick?: () => void;
-      href?: any;
-      onKeyPress?: () => void;
-      ignoreKeyPress?: boolean;
-      innerRef?: Ref<any>;
-      focusProps?: any;
-      tag?: string | Component;
-      role?: any;
-      tabIndex?: any;
-      className?: string;
-    }>
-  >;
-  TextInput: TextInput;
-  TextArea: TextArea;
-  FormDivider: ComponentClass<any>;
-  FormSection: ComponentClass<
-    PropsWithChildren<{
-      className?: string;
-      titleClassName?: string;
-      title?: ReactNode;
-      icon?: ReactNode;
-      disabled?: boolean;
-      htmlFor?: any;
-      tag?: string;
-    }>
-  >;
-  FormText: FormText;
-  FormTitle: ComponentClass<
-    PropsWithChildren<{
-      tag?: string;
-      className?: string;
-      faded?: boolean;
-      disabled?: boolean;
-      required?: boolean;
-      error?: string;
-    }>
-  >;
-  FormSwitch: ComponentClass<PropsWithChildren<any>>;
-  FormItem: ComponentClass<PropsWithChildren<any>>;
-  Slider: ComponentClass<
-    PropsWithChildren<{
-      disabled?: boolean;
-      stickToMarkers?: boolean;
-      className?: string;
-      barStyles?: CSSProperties;
-      fillStyles?: CSSProperties;
-      mini?: boolean;
-      hideBubble?: boolean;
-      initialValue?: number;
-      orientation?: "horizontal" | "vertical";
-      onValueRender?: (value: number) => string;
-      renderMarker?: (marker: number) => ReactNode;
-      getAriaValueText?: (value: number) => string;
-      barClassName?: string;
-      grabberClassName?: string;
-      grabberStyles?: CSSProperties;
-      markerPosition?: SliderMarkerPosition;
-      "aria-hidden"?: "true" | "false";
-      "aria-label"?: string;
-      "aria-labelledby"?: string;
-      "aria-describedby"?: string;
-      minValue?: number;
-      maxValue?: number;
-      asValueChanges?: (value: number) => void;
-      onValueChange?: (value: number) => void;
-      keyboardStep?: number;
-    }>
-  >;
-  Switch: ComponentClass<PropsWithChildren<any>>;
-  Button: Button;
-  Tooltip: ComponentClass<PropsWithChildren<any>>;
-  SmallSlider: Component;
-  Avatar: Component;
-  Scroller: Component;
-  Text: ComponentClass<PropsWithChildren<any>>;
-  Heading: ComponentClass<PropsWithChildren<any>>;
-  LegacyText: Component;
-  Flex: Flex;
-  Card: ComponentClass<PropsWithChildren<any>>;
-  Popout: ComponentClass<PropsWithChildren<any>>;
-  Dialog: ComponentClass<PropsWithChildren<any>>;
-  Menu: ComponentClass<PropsWithChildren<any>>;
-  MenuItem: ComponentClass<PropsWithChildren<any>>;
-  MenuGroup: ComponentClass<PropsWithChildren<any>>;
-  MenuCheckboxItem: ComponentClass<PropsWithChildren<any>>;
-  CardClasses: {
-    card: string;
-    cardHeader: string;
-  };
-  ControlClasses: {
-    container: string;
-    control: string;
-    disabled: string;
-    dividerDefault: string;
-    labelRow: string;
-    note: string;
-    title: string;
-    titleDefault: string;
-    titleMini: string;
-  };
-  MarkdownParser: {
-    parse: (text: string) => ReactElement;
-  };
-  SettingsNotice: React.ComponentType<{
-    submitting: boolean;
-    onReset: () => void;
-    onSave: () => void;
-  }>;
-  TabBar: React.ComponentType<any> & {
-    Item: React.ComponentType<any>;
-  };
-  SingleSelect: React.ComponentType<{
-    autofocus?: boolean;
-    clearable?: boolean;
-    value?: string;
-    options?: {
-      value: string;
-      label: string;
-    }[];
-    onChange?: (value: string) => void;
-  }>;
-  Select: React.ComponentType<{
-    autofocus?: boolean;
-    clearable?: boolean;
-    value?: string[];
-    options?: {
-      value: string;
-      label: string;
-    }[];
-    onChange?: (value: string[]) => void;
-  }>;
-
-  // TODO
-  useVariableSelect: any;
-  multiSelect: any;
-  tokens: any;
-};

packages/types/src/coreExtensions/settings.ts

···
+import React, { ReactElement } from "react";
+import type { Store } from "@moonlight-mod/mappings/discord/packages/flux";
+
+export type NoticeProps = {
+  stores: Store<any>[];
+  element: React.FunctionComponent;
+};
+
+export type SettingsSection =
+  | { section: "DIVIDER"; pos: number }
+  | { section: "HEADER"; label: string; pos: number }
+  | {
+      section: string;
+      label: string;
+      color: string | null;
+      element: React.FunctionComponent;
+      pos: number;
+      notice?: NoticeProps;
+      _moonlight_submenu?: () => ReactElement | ReactElement[];
+    };
+
+export type Settings = {
+  ourSections: SettingsSection[];
+  sectionNames: string[];
+  sectionMenuItems: Record<string, ReactElement[]>;
+
+  addSection: (
+    section: string,
+    label: string,
+    element: React.FunctionComponent,
+    color?: string | null,
+    pos?: number,
+    notice?: NoticeProps
+  ) => void;
+  addSectionMenuItems: (section: string, ...items: ReactElement[]) => void;
+
+  addDivider: (pos: number | null) => void;
+  addHeader: (label: string, pos: number | null) => void;
+  _mutateSections: (sections: SettingsSection[]) => SettingsSection[];
+};

packages/types/src/coreExtensions/spacepack.ts

···
+import {
+  WebpackModule,
+  WebpackModuleFunc,
+  WebpackRequireType
+} from "../discord";
+
+export type Spacepack = {
+  inspect: (module: number | string) => WebpackModuleFunc | null;
+  findByCode: (...args: (string | RegExp)[]) => any[];
+  findByExports: (...args: string[]) => any[];
+  require: WebpackRequireType;
+  modules: Record<string, WebpackModuleFunc>;
+  cache: Record<string, any>;
+  findObjectFromKey: (exports: Record<string, any>, key: string) => any | null;
+  findObjectFromValue: (exports: Record<string, any>, value: any) => any | null;
+  findObjectFromKeyValuePair: (
+    exports: Record<string, any>,
+    key: string,
+    value: any
+  ) => any | null;
+  findFunctionByStrings: (
+    exports: Record<string, any>,
+    ...strings: (string | RegExp)[]
+    // eslint-disable-next-line @typescript-eslint/ban-types
+  ) => Function | null;
+  lazyLoad: (
+    find: string | RegExp | (string | RegExp)[],
+    chunk: RegExp,
+    module: RegExp
+  ) => Promise<any>;
+  filterReal: (modules: WebpackModule[]) => WebpackModule[];
+};

packages/types/src/discord/common/Flux.ts

···
-/*
-  It seems like Discord maintains their own version of Flux that doesn't match
-  the types on NPM. This is a heavy work in progress - if you encounter rough
-  edges, please contribute!
-*/
-
-import { DependencyList } from "react";
-import { Store as FluxStore } from "flux/utils";
-import { Dispatcher as FluxDispatcher } from "flux";
-import { ComponentConstructor } from "flux/lib/FluxContainer";
-
-export declare abstract class Store<T> extends FluxStore<T> {
-  static getAll: () => Store<any>[];
-  getName: () => string;
-  emitChange: () => void;
-}
-
-interface ConnectStores {
-  <T>(
-    stores: Store<any>[],
-    callback: T,
-    context?: any
-  ): ComponentConstructor<T>;
-}
-
-export type FluxDefault = {
-  DeviceSettingsStore: any; // TODO
-  Emitter: any; // @types/fbemitter
-  OfflineCacheStore: any; // TODO
-  PersistedStore: any; // TODO
-  Store: typeof Store;
-  Dispatcher: typeof FluxDispatcher;
-  connectStores: ConnectStores;
-  initialize: () => void;
-  initialized: Promise<boolean>;
-  destroy: () => void;
-  useStateFromStores: UseStateFromStores;
-  useStateFromStoresArray: UseStateFromStoresArray;
-  useStateFromStoresObject: UseStateFromStoresObject;
-};
-
-interface UseStateFromStores {
-  <T>(
-    stores: Store<any>[],
-    callback: () => T,
-    deps?: DependencyList,
-    shouldUpdate?: (oldState: T, newState: T) => boolean
-  ): T;
-}
-
-interface UseStateFromStoresArray {
-  <T>(stores: Store<any>[], callback: () => T, deps?: DependencyList): T;
-}
-
-interface UseStateFromStoresObject {
-  <T>(stores: Store<any>[], callback: () => T, deps?: DependencyList): T;
-}

packages/types/src/discord/require.ts

···
-import {
-  Spacepack,
-  CommonReact,
-  CommonFlux,
-  Settings,
-  CommonComponents,
-  CommonFluxDispatcher
-} from "../coreExtensions";
 import { ContextMenu, EvilItemParser } from "../coreExtensions/contextMenu";
 import { Markdown } from "../coreExtensions/markdown";
+import { Settings } from "../coreExtensions/settings";
+import { Spacepack } from "../coreExtensions/spacepack";
 
 declare function WebpackRequire(id: string): any;
-declare function WebpackRequire(id: "spacepack_spacepack"): {
-  default: Spacepack;
-  spacepack: Spacepack;
-};
 
-declare function WebpackRequire(id: "common_components"): CommonComponents;
-declare function WebpackRequire(id: "common_flux"): CommonFlux;
-declare function WebpackRequire(
-  id: "common_fluxDispatcher"
-): CommonFluxDispatcher;
-declare function WebpackRequire(id: "common_react"): CommonReact;
+declare function WebpackRequire(id: "contextMenu_evilMenu"): EvilItemParser;
+declare function WebpackRequire(id: "contextMenu_contextMenu"): ContextMenu;
+
+declare function WebpackRequire(id: "markdown_markdown"): Markdown;
 
 declare function WebpackRequire(id: "settings_settings"): {
   Settings: Settings;
   default: Settings;
 };
 
-declare function WebpackRequire(id: "markdown_markdown"): Markdown;
-
-declare function WebpackRequire(id: "contextMenu_evilMenu"): EvilItemParser;
-declare function WebpackRequire(id: "contextMenu_contextMenu"): ContextMenu;
+declare function WebpackRequire(id: "spacepack_spacepack"): {
+  default: Spacepack;
+  spacepack: Spacepack;
+};
 
 export default WebpackRequire;

packages/types/src/extension.ts

···
 export type ExtensionManifest = {
   id: string;
   version?: string;
+  apiLevel?: number;
 
   meta?: {
     name?: string;

packages/types/src/globals.ts

···
-import { Logger } from "./logger";
-import { Config, ConfigExtension } from "./config";
-import {
+import type { Logger } from "./logger";
+import type { Config, ConfigExtension } from "./config";
+import type {
   DetectedExtension,
   IdentifiedPatch,
   IdentifiedWebpackModule,
   ProcessedExtensions
 } from "./extension";
-import EventEmitter from "events";
+import type EventEmitter from "events";
+import type LunAST from "@moonlight-mod/lunast";
+import type Moonmap from "@moonlight-mod/moonmap";
 import { EventPayloads, EventType, MoonlightEventEmitter } from "./core/event";
 
 export type MoonlightHost = {
···
   unpatched: Set<IdentifiedPatch>;
   pendingModules: Set<IdentifiedWebpackModule>;
   enabledExtensions: Set<string>;
+  apiLevel: number;
   events: MoonlightEventEmitter<EventType, EventPayloads>;
   patchingInternals: {
     onModuleLoad: (
···
   getConfigOption: <T>(ext: string, name: string) => T | undefined;
   getNatives: (ext: string) => any | undefined;
   getLogger: (id: string) => Logger;
+  lunast: LunAST;
+  moonmap: Moonmap;
 };
 
 export enum MoonlightEnv {

packages/types/src/import.d.ts

···
-declare module "@moonlight-mod/wp/spacepack_spacepack" {
-  import { CoreExtensions } from "@moonlight-mod/types";
-  export const spacepack: CoreExtensions.Spacepack;
-  export default spacepack;
-}
+declare module "@moonlight-mod/wp/common_stores";
 
-declare module "@moonlight-mod/wp/common_components" {
-  import { CoreExtensions } from "@moonlight-mod/types";
-  const CommonComponent: CoreExtensions.CommonComponents;
-  export = CommonComponent;
-}
-
-declare module "@moonlight-mod/wp/common_flux" {
+declare module "@moonlight-mod/wp/contextMenu_evilMenu" {
   import { CoreExtensions } from "@moonlight-mod/types";
-  const Flux: CoreExtensions.CommonFlux;
-  // FIXME: This is wrong, the default export differs from the named exports.
-  export = Flux;
+  const EvilParser: CoreExtensions.ContextMenu.EvilItemParser;
+  export = EvilParser;
 }
-
-declare module "@moonlight-mod/wp/common_fluxDispatcher" {
+declare module "@moonlight-mod/wp/contextMenu_contextMenu" {
   import { CoreExtensions } from "@moonlight-mod/types";
-  const Dispatcher: CoreExtensions.CommonFluxDispatcher;
-  export default Dispatcher;
-}
-
-declare module "@moonlight-mod/wp/common_stores";
-
-declare module "@moonlight-mod/wp/common_react" {
-  import React from "react";
-  export = React;
-}
-
-declare module "@moonlight-mod/wp/settings_settings" {
-  import { CoreExtensions } from "@moonlight-mod/types";
-  export const Settings: CoreExtensions.Settings;
-  export default Settings;
+  const ContextMenu: CoreExtensions.ContextMenu.ContextMenu;
+  export = ContextMenu;
 }
 
 declare module "@moonlight-mod/wp/markdown_markdown" {
···
   export = Markdown;
 }
 
-declare module "@moonlight-mod/wp/contextMenu_evilMenu" {
+declare module "@moonlight-mod/wp/settings_settings" {
   import { CoreExtensions } from "@moonlight-mod/types";
-  const EvilParser: CoreExtensions.ContextMenu.EvilItemParser;
-  export = EvilParser;
+  export const Settings: CoreExtensions.Settings.Settings;
+  export default Settings;
 }
 
-declare module "@moonlight-mod/wp/contextMenu_contextMenu" {
+declare module "@moonlight-mod/wp/spacepack_spacepack" {
   import { CoreExtensions } from "@moonlight-mod/types";
-  const ContextMenu: CoreExtensions.ContextMenu.ContextMenu;
-  export = ContextMenu;
+  export const spacepack: CoreExtensions.Spacepack.Spacepack;
+  export default spacepack;
 }

packages/types/src/index.ts

···
 /// <reference types="standalone-electron-types" />
 /// <reference types="react" />
-/// <reference types="flux" />
 /// <reference types="./import" />
+/// <reference types="./mappings" />
 /* eslint-disable no-var */
 
 import {
···
 export * from "./globals";
 export * from "./logger";
 export * as constants from "./constants";
+
+export type { AST } from "@moonlight-mod/lunast";
+export { ModuleExport, ModuleExportType } from "@moonlight-mod/moonmap";
 
 declare global {
   const MOONLIGHT_ENV: MoonlightEnv;

packages/types/src/mappings.d.ts

···
+// auto-generated
+declare module "@moonlight-mod/wp/discord/Dispatcher" {
+  import { MappedModules } from "@moonlight-mod/mappings";
+  const _: MappedModules["discord/Dispatcher"];
+  export = _;
+}
+
+declare module "@moonlight-mod/wp/discord/components/common/index" {
+  import { MappedModules } from "@moonlight-mod/mappings";
+  const _: MappedModules["discord/components/common/index"];
+  export = _;
+}
+
+declare module "@moonlight-mod/wp/discord/modules/guild_settings/IntegrationCard.css" {
+  import { MappedModules } from "@moonlight-mod/mappings";
+  const _: MappedModules["discord/modules/guild_settings/IntegrationCard.css"];
+  export = _;
+}
+
+declare module "@moonlight-mod/wp/discord/modules/markup/MarkupUtils" {
+  import { MappedModules } from "@moonlight-mod/mappings";
+  const _: MappedModules["discord/modules/markup/MarkupUtils"];
+  export = _;
+}
+
+declare module "@moonlight-mod/wp/discord/packages/flux" {
+  import { MappedModules } from "@moonlight-mod/mappings";
+  const _: MappedModules["discord/packages/flux"];
+  export = _;
+}
+
+declare module "@moonlight-mod/wp/discord/uikit/Flex" {
+  import { MappedModules } from "@moonlight-mod/mappings";
+  const _: MappedModules["discord/uikit/Flex"];
+  export = _;
+}
+
+declare module "@moonlight-mod/wp/react" {
+  import { MappedModules } from "@moonlight-mod/mappings";
+  const _: MappedModules["react"];
+  export = _;
+}

packages/web-preload/package.json

···
   "private": true,
   "dependencies": {
     "@moonlight-mod/core": "workspace:*",
+    "@moonlight-mod/lunast": "^1.0.0",
+    "@moonlight-mod/mappings": "^1.0.0",
+    "@moonlight-mod/moonmap": "^1.0.2",
     "@moonlight-mod/types": "workspace:*"
   }
 }

packages/web-preload/src/index.ts

···
   registerPatch,
   registerWebpackModule
 } from "@moonlight-mod/core/patch";
+import { constants } from "@moonlight-mod/types";
 import { installStyles } from "@moonlight-mod/core/styles";
 import Logger from "@moonlight-mod/core/util/logger";
+import LunAST from "@moonlight-mod/lunast";
+import Moonmap from "@moonlight-mod/moonmap";
+import loadMappings from "@moonlight-mod/mappings";
 import { createEventEmitter } from "@moonlight-mod/core/util/event";
 import { EventPayloads, EventType } from "@moonlight-mod/types/core/event";
 
···
   const logger = new Logger("web-preload");
 
   window.moonlight = {
+    apiLevel: constants.apiLevel,
     unpatched: new Set(),
     pendingModules: new Set(),
     enabledExtensions: new Set(),
···
     getConfig: moonlightNode.getConfig.bind(moonlightNode),
     getConfigOption: moonlightNode.getConfigOption.bind(moonlightNode),
     getNatives: moonlightNode.getNatives.bind(moonlightNode),
-    getLogger: (id: string) => {
+    getLogger(id) {
       return new Logger(id);
-    }
+    },
+    lunast: new LunAST(),
+    moonmap: new Moonmap()
   };
 
   try {
+    loadMappings(window.moonlight.moonmap, window.moonlight.lunast);
     await loadProcessedExtensions(moonlightNode.processedExtensions);
     await installWebpackPatcher();
   } catch (e) {

pnpm-lock.yaml

···
 
   packages/types:
     dependencies:
-      '@types/flux':
-        specifier: ^3.1.12
-        version: 3.1.12
+      '@moonlight-mod/lunast':
+        specifier: ^1.0.0
+        version: 1.0.0
+      '@moonlight-mod/mappings':
+        specifier: ^1.0.0
+        version: 1.0.0(@moonlight-mod/lunast@1.0.0)(@moonlight-mod/moonmap@1.0.2)
+      '@moonlight-mod/moonmap':
+        specifier: ^1.0.2
+        version: 1.0.2
       '@types/react':
-        specifier: ^18.2.22
-        version: 18.2.22
+        specifier: ^18.3.10
+        version: 18.3.10
       csstype:
         specifier: ^3.1.2
         version: 3.1.2
···
       '@moonlight-mod/core':
         specifier: workspace:*
         version: link:../core
+      '@moonlight-mod/lunast':
+        specifier: ^1.0.0
+        version: 1.0.0
+      '@moonlight-mod/mappings':
+        specifier: ^1.0.0
+        version: 1.0.0(@moonlight-mod/lunast@1.0.0)(@moonlight-mod/moonmap@1.0.2)
+      '@moonlight-mod/moonmap':
+        specifier: ^1.0.2
+        version: 1.0.2
       '@moonlight-mod/types':
         specifier: workspace:*
         version: link:../types
···
   '@humanwhocodes/config-array@0.11.13':
     resolution: {integrity: sha512-JSBDMiDKSzQVngfRjOdFXgFfklaXI4K9nLF49Auh21lmBWRLIK3+xTErTWD4KU54pb6coM6ESE7Awz/FNU3zgQ==}
     engines: {node: '>=10.10.0'}
+    deprecated: Use @eslint/config-array instead
 
   '@humanwhocodes/module-importer@1.0.1':
     resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==}
···
 
   '@humanwhocodes/object-schema@2.0.1':
     resolution: {integrity: sha512-dvuCeX5fC9dXgJn9t+X5atfmgQAzUOWqS1254Gh0m6i8wKd10ebXkfNKiRK+1GWi/yTvvLDHpoxLr0xxxeslWw==}
+    deprecated: Use @eslint/object-schema instead
+
+  '@moonlight-mod/lunast@1.0.0':
+    resolution: {integrity: sha512-kJgf41K12i6/2LbXK97CNO+pNO7ADGh9N4bCQcOPwosocKMcwKHDEZUgPqeihNshY3c3AEW1LiyXjlsl24PdDw==}
+
+  '@moonlight-mod/mappings@1.0.0':
+    resolution: {integrity: sha512-n6ybbTqFxXVKvTHcIGEtCS9208an6BFnTojK56giWE/bjuqq6DvFrk/0+C3ZRDEjgohGf/DuUKc9f0qe9UH6Rg==}
+    peerDependencies:
+      '@moonlight-mod/lunast': ^1.0.0
+      '@moonlight-mod/moonmap': ^1.0.0
+
+  '@moonlight-mod/moonmap@1.0.2':
+    resolution: {integrity: sha512-dqMFwk8o0duRfvBNYo6EwalEUWWR3bNF5V2N04ogHp4gYON6/5+XOUrTlQ9BFBDj9anZwGgVwGqnxV42Qs9pPw==}
 
   '@nodelib/fs.scandir@2.1.5':
     resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
···
     resolution: {integrity: sha512-POgTXhjrTfbTV63DiFXav4lBHiICLKKwDeaKn9Nphwj7WH6m0hMMCaJkMyRWjgtPFyRKRVoMXXjczsTQRDEhYw==}
     engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
 
-  '@types/fbemitter@2.0.33':
-    resolution: {integrity: sha512-KcSilwdl0D8YgXGL6l9d+rTBm2W7pDyTZrDEw0+IzqQ724676KJtMeO+xHodJewKFWZT+GFWaJubA5mpMxSkcg==}
+  '@types/estree-jsx@1.0.5':
+    resolution: {integrity: sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==}
+
+  '@types/estree@1.0.6':
+    resolution: {integrity: sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==}
+
+  '@types/fbemitter@2.0.35':
+    resolution: {integrity: sha512-Xem6d7qUfmouCHntCrRYgDBwbf+WWRd6G+7WEFlEZFZ67LZXiYRvT2LV8wcZa6mIaAil95+ABQdKgB6hPIsnng==}
 
-  '@types/flux@3.1.12':
-    resolution: {integrity: sha512-HZ8o/DTVNgcgnXoDyn0ZnjqEZMT4Chr4w5ktMQSbQAnqVDklasmRqNGd2agZDsk5i0jYHQLgQQuM782bWG7fUA==}
+  '@types/flux@3.1.14':
+    resolution: {integrity: sha512-WRXN0kQPCnqxN0/PgNgc7WBF6c8rbSHsEep3/qBLpsQ824RONdOmTs0TV7XhIW2GDNRAHO2CqCgAFLR5PChosw==}
 
   '@types/json-schema@7.0.15':
     resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
···
   '@types/node@18.17.17':
     resolution: {integrity: sha512-cOxcXsQ2sxiwkykdJqvyFS+MLQPLvIdwh5l6gNg8qF6s+C7XSkEWOZjK+XhUZd+mYvHV/180g2cnCcIl4l06Pw==}
 
-  '@types/prop-types@15.7.6':
-    resolution: {integrity: sha512-RK/kBbYOQQHLYj9Z95eh7S6t7gq4Ojt/NT8HTk8bWVhA5DaF+5SMnxHKkP4gPNN3wAZkKP+VjAf0ebtYzf+fxg==}
+  '@types/prop-types@15.7.13':
+    resolution: {integrity: sha512-hCZTSvwbzWGvhqxp/RqVqwU999pBf2vp7hzIjiYOsl8wqOmUxkQ6ddw1cV3l8811+kdUFus/q4d1Y3E3SyEifA==}
 
-  '@types/react@18.2.22':
-    resolution: {integrity: sha512-60fLTOLqzarLED2O3UQImc/lsNRgG0jE/a1mPW9KjMemY0LMITWEsbS4VvZ4p6rorEHd5YKxxmMKSDK505GHpA==}
-
-  '@types/scheduler@0.16.3':
-    resolution: {integrity: sha512-5cJ8CB4yAx7BH1oMvdU0Jh9lrEXyPkar6F9G/ERswkCuvP4KQZfZkSjcMbAICCpQTN4OuZn8tz0HiKv9TGZgrQ==}
+  '@types/react@18.3.10':
+    resolution: {integrity: sha512-02sAAlBnP39JgXwkAq3PeU9DVaaGpZyF3MGcC0MKgQVkZor5IiiDAipVaxQHtDJAmO4GIy/rVBy/LzVj76Cyqg==}
 
   '@types/semver@7.5.6':
     resolution: {integrity: sha512-dn1l8LaMea/IjDoHNd9J52uBbInB796CDffS6VdIxvqYCPSG0V0DzHp76GpaWnlhg88uYyPbXCDIowa86ybd5A==}
···
     peerDependencies:
       acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
 
-  acorn@8.11.2:
-    resolution: {integrity: sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==}
+  acorn@8.12.1:
+    resolution: {integrity: sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==}
     engines: {node: '>=0.4.0'}
     hasBin: true
 
···
     resolution: {integrity: sha512-yMBKppFur/fbHu9/6USUe03bZ4knMYiwFBcyiaXB8Go0qNehwX6inYPzK9U0NeQvGxKthcmHcaR8P5MStSRBAw==}
     engines: {node: '>= 0.4'}
 
+  astring@1.9.0:
+    resolution: {integrity: sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==}
+    hasBin: true
+
   asynciterator.prototype@1.0.0:
     resolution: {integrity: sha512-wwHYEIS0Q80f5mosx3L/dfG5t5rjEa9Ft51GTaNt862EnpyGHpgz2RkZvLPp1oF5TnAiTohkEKVEu8pQPJI7Vg==}
 
···
     engines: {node: '>= 6'}
 
   concat-map@0.0.1:
-    resolution: {integrity: sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=}
+    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
 
   cross-spawn@7.0.3:
     resolution: {integrity: sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==}
···
   csstype@3.1.2:
     resolution: {integrity: sha512-I7K1Uu0MBPzaFKg4nI5Q7Vs2t+3gWWW648spaF+Rg7pI9ds18Ugn+lvg4SHczUdKlHI5LWBXyqfS8+DufyBsgQ==}
 
+  csstype@3.1.3:
+    resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==}
+
   debug@4.3.4:
     resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
     engines: {node: '>=6.0'}
···
   estraverse@5.3.0:
     resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
     engines: {node: '>=4.0'}
+
+  estree-toolkit@1.7.8:
+    resolution: {integrity: sha512-v0Q0L+0agSDFe3x9Sj7aAzrI9afvsfr5r7AM2SNk/8bKYRQ3tUf4PQEUWe99LkWysmT1PsuSpW+W1w/xZmCKeg==}
 
   esutils@2.0.3:
     resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
···
 
   glob@7.2.3:
     resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
+    deprecated: Glob versions prior to v9 are no longer supported
 
   globals@13.23.0:
     resolution: {integrity: sha512-XAmF0RjlrjY23MA51q3HltdlGxUpXPvg0GioKiD9X6HD28iMjo2dKC8Vqwm7lne4GNr78+RHTfliktR6ZH09wA==}
···
 
   inflight@1.0.6:
     resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==}
+    deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.
 
   inherits@2.0.4:
     resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
···
     resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
     engines: {node: '>= 8'}
 
+  meriyah@6.0.1:
+    resolution: {integrity: sha512-OyvYIOgpzXREySYJ1cqEb2pOKdeQMTfF9M8dRU6nC4hi/GXMmNpe9ssZCrSoTHazu05BSAoRBN/uYeco+ymfOg==}
+    engines: {node: '>=18.0.0'}
+
   micromatch@4.0.5:
     resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==}
     engines: {node: '>=8.6'}
···
 
   rimraf@3.0.2:
     resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==}
+    deprecated: Rimraf versions prior to v4 are no longer supported
     hasBin: true
 
   run-applescript@5.0.0:
···
 
   '@humanwhocodes/object-schema@2.0.1': {}
 
+  '@moonlight-mod/lunast@1.0.0':
+    dependencies:
+      astring: 1.9.0
+      estree-toolkit: 1.7.8
+      meriyah: 6.0.1
+
+  '@moonlight-mod/mappings@1.0.0(@moonlight-mod/lunast@1.0.0)(@moonlight-mod/moonmap@1.0.2)':
+    dependencies:
+      '@moonlight-mod/lunast': 1.0.0
+      '@moonlight-mod/moonmap': 1.0.2
+      '@types/flux': 3.1.14
+      '@types/react': 18.3.10
+      csstype: 3.1.3
+
+  '@moonlight-mod/moonmap@1.0.2': {}
+
   '@nodelib/fs.scandir@2.1.5':
     dependencies:
       '@nodelib/fs.stat': 2.0.5
···
       picocolors: 1.0.0
       tslib: 2.6.2
 
-  '@types/fbemitter@2.0.33': {}
+  '@types/estree-jsx@1.0.5':
+    dependencies:
+      '@types/estree': 1.0.6
+
+  '@types/estree@1.0.6': {}
 
-  '@types/flux@3.1.12':
+  '@types/fbemitter@2.0.35': {}
+
+  '@types/flux@3.1.14':
     dependencies:
-      '@types/fbemitter': 2.0.33
-      '@types/react': 18.2.22
+      '@types/fbemitter': 2.0.35
+      '@types/react': 18.3.10
 
   '@types/json-schema@7.0.15': {}
 
   '@types/node@18.17.17': {}
 
-  '@types/prop-types@15.7.6': {}
+  '@types/prop-types@15.7.13': {}
 
-  '@types/react@18.2.22':
+  '@types/react@18.3.10':
     dependencies:
-      '@types/prop-types': 15.7.6
-      '@types/scheduler': 0.16.3
-      csstype: 3.1.2
-
-  '@types/scheduler@0.16.3': {}
+      '@types/prop-types': 15.7.13
+      csstype: 3.1.3
 
   '@types/semver@7.5.6': {}
 
···
 
   '@ungap/structured-clone@1.2.0': {}
 
-  acorn-jsx@5.3.2(acorn@8.11.2):
+  acorn-jsx@5.3.2(acorn@8.12.1):
     dependencies:
-      acorn: 8.11.2
+      acorn: 8.12.1
 
-  acorn@8.11.2: {}
+  acorn@8.12.1: {}
 
   ajv@6.12.6:
     dependencies:
···
       is-array-buffer: 3.0.2
       is-shared-array-buffer: 1.0.2
 
+  astring@1.9.0: {}
+
   asynciterator.prototype@1.0.0:
     dependencies:
       has-symbols: 1.0.3
···
       which: 2.0.2
 
   csstype@3.1.2: {}
+
+  csstype@3.1.3: {}
 
   debug@4.3.4:
     dependencies:
···
 
   espree@9.6.1:
     dependencies:
-      acorn: 8.11.2
-      acorn-jsx: 5.3.2(acorn@8.11.2)
+      acorn: 8.12.1
+      acorn-jsx: 5.3.2(acorn@8.12.1)
       eslint-visitor-keys: 3.4.3
 
   esquery@1.5.0:
···
       estraverse: 5.3.0
 
   estraverse@5.3.0: {}
+
+  estree-toolkit@1.7.8:
+    dependencies:
+      '@types/estree': 1.0.6
+      '@types/estree-jsx': 1.0.5
 
   esutils@2.0.3: {}
 
···
   merge-stream@2.0.0: {}
 
   merge2@1.4.1: {}
+
+  meriyah@6.0.1: {}
 
   micromatch@4.0.5:
     dependencies:

tsconfig.json

···
 {
   "compilerOptions": {
-    "target": "es2016",
+    "target": "es2022",
     "module": "es6",
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
···
     "baseUrl": "./packages/",
     "jsx": "react",
     "noEmit": true,
+
+    // meriyah has a broken import lol
+    "skipLibCheck": true,
 
     // disable unreachable code detection because it breaks with esbuild labels
     "allowUnreachableCode": true