@synnaxlabs/pluto 0.12.0

package/dist/Video-Vpwp5ao1.js

@@ -0,0 +1,12 @@
+import { j as jsxRuntimeExports } from "./jsx-runtime-rX5tAIG2.js";
+import { C as CSS } from "./css-NTD4Xm8x.js";
+import "./Video-w40geAFS.js";
+const Video = ({ href, className, ...props }) => /* @__PURE__ */ jsxRuntimeExports.jsx("video", { className: CSS(CSS.B("video"), className), ...props, children: /* @__PURE__ */ jsxRuntimeExports.jsx("source", { src: href, type: "video/mp4" }) });
+const Video$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Video
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Video$1 as V
+};
+//# sourceMappingURL=Video-Vpwp5ao1.js.map

package/dist/Video-Vpwp5ao1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Video-Vpwp5ao1.js","sources":["../src/video/Video.tsx"],"sourcesContent":["// Copyright 2023 Synnax Labs, Inc.\n//\n// Use of this software is governed by the Business Source License included in the file\n// licenses/BSL.txt.\n//\n// As of the Change Date specified in that file, in accordance with the Business Source\n// License, use of this software will be governed by the Apache License, Version 2.0,\n// included in the file licenses/APL.txt.\n\nimport { type ComponentPropsWithoutRef, type ReactElement } from \"react\";\n\nimport { CSS } from \"@/css\";\n\nimport \"@/video/Video.css\";\n\nexport interface VideoProps extends ComponentPropsWithoutRef<\"video\"> {\n  href: string;\n}\n\nexport const Video = ({ href, className, ...props }: VideoProps): ReactElement => (\n  <video className={CSS(CSS.B(\"video\"), className)} {...props}>\n    <source src={href} type=\"video/mp4\" />\n  </video>\n);\n"],"names":["jsx"],"mappings":";;;AAmBa,MAAA,QAAQ,CAAC,EAAE,MAAM,WAAW,GAAG,MAAA,MAC1CA,kCAAA,IAAC,SAAM,EAAA,WAAW,IAAI,IAAI,EAAE,OAAO,GAAG,SAAS,GAAI,GAAG,OACpD,UAACA,kCAAAA,IAAA,UAAA,EAAO,KAAK,MAAM,MAAK,YAAA,CAAY,EACtC,CAAA;;;;;"}

package/dist/Video-a7BUKvzF.cjs

@@ -0,0 +1,11 @@
+"use strict";
+const jsxRuntime = require("./jsx-runtime-N1ikfypN.cjs");
+const css = require("./css-V3VUT_Js.cjs");
+require("./Video-k52RqIHf.cjs");
+const Video = ({ href, className, ...props }) => /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx("video", { className: css.CSS(css.CSS.B("video"), className), ...props, children: /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx("source", { src: href, type: "video/mp4" }) });
+const Video$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Video
+}, Symbol.toStringTag, { value: "Module" }));
+exports.Video = Video$1;
+//# sourceMappingURL=Video-a7BUKvzF.cjs.map

package/dist/Video-a7BUKvzF.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Video-a7BUKvzF.cjs","sources":["../src/video/Video.tsx"],"sourcesContent":["// Copyright 2023 Synnax Labs, Inc.\n//\n// Use of this software is governed by the Business Source License included in the file\n// licenses/BSL.txt.\n//\n// As of the Change Date specified in that file, in accordance with the Business Source\n// License, use of this software will be governed by the Apache License, Version 2.0,\n// included in the file licenses/APL.txt.\n\nimport { type ComponentPropsWithoutRef, type ReactElement } from \"react\";\n\nimport { CSS } from \"@/css\";\n\nimport \"@/video/Video.css\";\n\nexport interface VideoProps extends ComponentPropsWithoutRef<\"video\"> {\n  href: string;\n}\n\nexport const Video = ({ href, className, ...props }: VideoProps): ReactElement => (\n  <video className={CSS(CSS.B(\"video\"), className)} {...props}>\n    <source src={href} type=\"video/mp4\" />\n  </video>\n);\n"],"names":["jsx","CSS"],"mappings":";;;;AAmBa,MAAA,QAAQ,CAAC,EAAE,MAAM,WAAW,GAAG,MAAA,MAC1CA,2BAAA,kBAAA,IAAC,SAAM,EAAA,WAAWC,IAAI,IAAAA,IAAA,IAAI,EAAE,OAAO,GAAG,SAAS,GAAI,GAAG,OACpD,UAACD,2BAAAA,kBAAAA,IAAA,UAAA,EAAO,KAAK,MAAM,MAAK,YAAA,CAAY,EACtC,CAAA;;;;;;"}

package/dist/Video-k52RqIHf.cjs

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=Video-k52RqIHf.cjs.map

package/dist/Video-k52RqIHf.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Video-k52RqIHf.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/Video-w40geAFS.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=Video-w40geAFS.js.map

package/dist/Video-w40geAFS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Video-w40geAFS.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/accordion/Accordion.d.ts

@@ -0,0 +1,38 @@
+import { type ReactElement } from "react";
+import { type Button } from '../button';
+import { Resize } from '../resize';
+/** The props for a single entry in the {@link Accordion} component. */
+export interface Entry {
+    /** A unique key for the entry. */
+    key: string;
+    /** The name for the entries header. */
+    name: string;
+    /** The content for the entry. */
+    content: ReactElement;
+    /**
+     * The initial size for the entry. It's recommended to set this to a decimal value
+     * representing the percentage of the overall parent size.
+     */
+    initialSize?: number;
+    /**
+     * A list of actions to display in the entry's header. See the {@link Header.Actions}
+     * component for more details.
+     */
+    actions?: Array<Button.IconProps | ReactElement>;
+}
+/** The props for the {@link Accordion} component. */
+export interface AccordionProps extends Omit<Resize.MultipleProps, "sizeDistribution" | "parentSize" | "onDragHandle" | "direction"> {
+    data: Entry[];
+}
+/**
+ * A resizable accordion component, whose entries can be expanded and collapsed. This
+ * component is intentionally opinionated in its interface in order to provide stylistic
+ * consistency and simplicity. If you need more control, look at building a custom
+ * accordion component using {@link Resize.Multiple}.
+ *
+ * @param props - All unused props are passed to the underyling {@link Resize.Multiple}
+ * component.
+ * @param props.entries - The entries to display in the accordion. See the
+ * {@link Entry} interface for more details.
+ */
+export declare const Accordion: ({ data, ...props }: AccordionProps) => ReactElement;

package/dist/accordion/Accordion.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/accordion/Accordion.stories.d.ts

@@ -0,0 +1,5 @@
+import type { Meta, StoryFn } from "@storybook/react";
+import { Accordion } from '../accordion';
+declare const story: Meta<typeof Accordion.Accordion>;
+export declare const Primary: StoryFn<typeof Accordion>;
+export default story;

package/dist/accordion/index.d.ts

@@ -0,0 +1 @@
+export * as Accordion from '../accordion/Accordion';

package/dist/aether/aether/aether.d.ts

@@ -0,0 +1,247 @@
+import { Instrumentation } from "@synnaxlabs/alamos";
+import { type Sender, type SenderHandler } from "@synnaxlabs/x";
+import { z } from "zod";
+import { type MainMessage, type WorkerMessage } from '../../aether/message';
+import { state } from '../../state';
+type UpdateVariant = "state" | "context";
+/** An update to an AetherComponent from the main React tree. */
+export interface Update {
+    /**
+     * The variant of update being performed. State updates are used to update
+     * the state of a particular component, while context updates are used to propagate
+     * context changes to children in the tree.
+     */
+    variant: UpdateVariant;
+    ctx: Context;
+    /**
+     * The path of the component in the tree. This path is shortened as the update is
+     * propagated through the tree
+     */
+    path: string[];
+    /**
+     * The type of the component being updated. This is used to create the component
+     * if it does not already exist.
+     */
+    type: string;
+    /**
+     * The state to udpate on the component . This is only present if the variant is
+     * "state".
+     */
+    state: any;
+}
+/**
+ * A component in the Aether tree. Each component instance has a unique key identifying
+ * it within the tree, and also has a type identifying it's class. Components
+ * implementing different functionality should have different types, and these types
+ * typically correlate to the corresponding name of the component in the react tree.
+ */
+export interface Component {
+    /** The type of component. */
+    type: string;
+    /** A unique key identifying the component within the tree. */
+    key: string;
+    ctx: Context;
+    /**
+     * Propagates an update to the internal tree of the component, updating the component
+     * itself and any children as necessary.
+     *
+     * @param update - The update to propagate.
+     */
+    internalUpdate: (update: Update) => void;
+    /**
+     * Propagates a delete to the internal tree of the component, calling the handleDelete
+     * component on the component itself and any children as necessary. It is up to
+     * the parent component to remove the child from its internal tree.
+     *
+     * @param path - The path of the component to delete.
+     */
+    internalDelete: (path: string[]) => void;
+}
+/** A constructor type for an AetherComponent. */
+export type ComponentConstructor = new (update: Update) => Component;
+/**
+ * AetherContext is used to propagate environment information to components in the
+ * aether tree. It allows components to propagate state changes to the main react
+ * tree, create new components, and set/get values from the environment, passing
+ * them to children as necessary.
+ */
+export declare class Context {
+    readonly providers: Map<string, any>;
+    private readonly registry;
+    private readonly sender;
+    changed: boolean;
+    constructor(sender: Sender<WorkerMessage>, registry: Record<string, ComponentConstructor>, providers?: Map<string, any>);
+    /**
+     * Proapgates the given state for the component with the given key to the main
+     * react tree.
+     *
+     * @param key - The key of the component to propagate the state for.
+     * @param state - The state to propagate.
+     * @param transfer - Any transferable objects to transfer to the main thread.
+     */
+    propagateState(key: string, state: any, transfer?: Transferable[]): void;
+    /**
+     * Copies the context, setting it's 'changed' flag to false, and optionally merging
+     * another set of context values into it.
+     *
+     * @param merge - The context to merge into the copy.
+     * @returns The copied context.
+     */
+    copyAndMerge(merge?: Context): Context;
+    /**
+     * Sets a value on the context and flags the context as changed.
+     *
+     * @param key - The key to set.
+     * @param value - The value to set.
+     */
+    set(key: string, value: any): void;
+    setIfNotHas(key: string, value: any): void;
+    /**
+     * Creates a new component using the given update. It is up to the caller to
+     * validate that the component type is valid.
+     *
+     * @param update - The update to create the component from.
+     * @returns The created component.
+     */
+    create<C extends Component>(update: Update): C;
+    /**
+     * Gets a value from the context, returning null if the value does not exist. It's
+     * imporant to note that the context provides no validation of the type of the
+     * value, so it is up to the caller to ensure that the value is of the correct type.
+     *
+     * @param key - The key to get.
+     * @returns The value, or null if it does not exist.
+     */
+    getOptional<P>(key: string): P | null;
+    /**
+     * Checks if the context has a value for the given key.
+     *
+     * @param key - The key to check.
+     * @returns True if the context has a value for the given key, false otherwise.
+     */
+    has(key: string): boolean;
+    /**
+     * Gets a value from the context, throwing an error if the value does not exist.
+     * It's imporant to note that the context provides no validation of the type of
+     * the value, so it is up to the caller to ensure that the value is of the correct
+     *
+     * @param key - The key to get.
+     * @returns The value.
+     */
+    get<P>(key: string): P;
+}
+/**
+ * Implements an AtherComponent that does not have any children, and servers as the base
+ * class for the AetherComposite type. The corresponding react component should NOT have
+ * any children that use Aether functionality; for those cases, use AetherComposite instead.
+ */
+export declare class Leaf<S extends z.ZodTypeAny, IS extends {} = {}> implements Component {
+    readonly type: string;
+    readonly key: string;
+    _ctx: Context;
+    private readonly _internalState;
+    private _state;
+    private _prevState;
+    private _deleted;
+    schema: S | undefined;
+    constructor(u: Update);
+    private get _schema();
+    /**
+     * Sets the state on the component, communicating the change to the corresponding
+     * React component on the main thread.
+     *
+     * @param next - The new state to set on the component. This can be the state object
+     * or a pure function that takes in the previous state and returns the next state.
+     */
+    setState(next: state.SetArg<z.input<S> | z.output<S>>): void;
+    /** Returns the current context on the component. */
+    get ctx(): Context;
+    /** @returns the current state of the component. */
+    get state(): z.output<S>;
+    get internal(): IS;
+    /** @returns the previous state of the component. */
+    get prevState(): z.output<S>;
+    get deleted(): boolean;
+    /**
+     * @implements AetherComponent, and should NOT be called by a subclass other than
+     * AetherComposite.
+     */
+    internalUpdate({ variant, path, ctx, state }: Update): void;
+    /**
+     * @implements AetherComponent, and should NOT be called by a subclass other than
+     * AetherComposite.
+     */
+    internalDelete(path: string[]): void;
+    /**
+     * afterUpdate is optionally defined by a subclass, allowing the component to
+     * perform some action after the component is updated. At this point, the current
+     * state, previous state, derived state, and current context are all available to
+     * the component.
+     */
+    afterUpdate(): void;
+    /**
+     * Runs after the component has been spliced out of the tree. This is useful for
+     * running cleanup code, such as unsubscribing from an event emitter. At this point,
+     * the current state, previous state, derived state, and current context are all
+     * available to the component, and this.deleted is true.
+     */
+    afterDelete(): void;
+    private validatePath;
+}
+/**
+ * AetherComposite is an implementation of AetherComponent that allows it to maintain
+ * child components. It is the base class for all composite components, and should not
+ * be used directly.
+ */
+export declare class Composite<S extends z.ZodTypeAny, IS extends {} = {}, C extends Component = Component> extends Leaf<S, IS> implements Component {
+    _children: C[];
+    constructor(u: Update);
+    internalMemo: Record<string, any>;
+    /** @returns a readonly array of the children of the component. */
+    get children(): readonly C[];
+    /**
+     * @implements AetherComponent, and should NOT be called by a subclass, except for
+     * AetherRoot.
+     */
+    internalUpdate(u: Update): void;
+    private updateContext;
+    private updateChild;
+    private updateThis;
+    internalDelete(path: string[]): void;
+    getRequiredKey(path: string[], type?: string): [string, string[]];
+    /**
+     * Finds a child component with the given key.
+     *
+     * @param key - the key of the child component to find.
+     * @returns the child component, or null if no child component with the given key
+     */
+    findChild<T extends C = C>(key: string): T | null;
+    /**
+     * Finds all children of the component with the given type
+     *
+     * @param types - the type of the children to find
+     * @returns an array of all children of the component with the given type
+     */
+    childrenOfType<T extends C = C>(...types: Array<T["type"]>): readonly T[];
+}
+export type ComponentRegistry = Record<string, ComponentConstructor>;
+declare const aetherRootState: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export interface RootProps {
+    worker: SenderHandler<WorkerMessage, MainMessage>;
+    registry: ComponentRegistry;
+    instrumentation?: Instrumentation;
+}
+export declare class Root extends Composite<typeof aetherRootState> {
+    wrap: SenderHandler<WorkerMessage, MainMessage>;
+    instrumentation: Instrumentation;
+    private static readonly TYPE;
+    private static readonly KEY;
+    private static readonly ZERO_UPDATE;
+    static readonly schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    static render(props: RootProps): Root;
+    private constructor();
+    handle(msg: MainMessage): void;
+}
+export declare const render: typeof Root.render;
+export {};

package/dist/aether/aether/index.d.ts

@@ -0,0 +1,2 @@
+import * as aether from '../../aether/aether/aether';
+export { aether };

package/dist/aether/aether/worker.spec.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const exampleProps: z.ZodObject<{
+    x: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    x: number;
+}, {
+    x: number;
+}>;

package/dist/aether/index.d.ts

@@ -0,0 +1 @@
+export * as Aether from '../aether/main';

package/dist/aether/main.d.ts

@@ -0,0 +1,96 @@
+import { type ComponentType, type FC, type PropsWithChildren, type ReactElement } from "react";
+import { type SenderHandler } from "@synnaxlabs/x";
+import { type z } from "zod";
+import { type MainMessage, type WorkerMessage } from '../aether/message';
+import { state } from '../state';
+export interface CreateReturn {
+    setState: (state: any, transfer?: Transferable[]) => void;
+    delete: () => void;
+}
+export interface ContextValue {
+    path: string[];
+    create: (type: string, path: string[], onReceive?: StateHandler) => CreateReturn;
+}
+export declare const Context: import("react").Context<ContextValue>;
+export interface ProviderProps extends PropsWithChildren {
+    workerKey: string;
+    worker?: SenderHandler<MainMessage, WorkerMessage>;
+}
+export declare const Provider: ({ workerKey, worker: propsWorker, children, }: ProviderProps) => ReactElement;
+export declare const useAetherContext: () => ContextValue;
+export interface UseLifecycleReturn<S extends z.ZodTypeAny> {
+    path: string[];
+    setState: (state: z.input<S>, transfer?: Transferable[]) => void;
+}
+export interface UseLifecycleProps<S extends z.ZodTypeAny> {
+    type: string;
+    schema: S;
+    aetherKey: string;
+    initialState: z.input<S>;
+    initialTransfer?: Transferable[];
+    onReceive?: StateHandler;
+}
+export interface UseProps<S extends z.ZodTypeAny> extends Omit<UseLifecycleProps<S>, "onReceive"> {
+}
+export type UseReturn<S extends z.ZodTypeAny> = [
+    {
+        path: string[];
+    },
+    z.output<S>,
+    (state: state.SetArg<z.input<S>>, transfer?: Transferable[]) => void
+];
+/**
+ * Use creates a new aether component with a unique key and type.
+ *
+ * @param props.type - The type of the component. Aether will use this to instantiate
+ * the correct component type on the worker thread. A constructor for this type must
+ * exist on the registry passed into aether.render on the worker thread.
+ * @param props.aetherKey - A unique key for the component that is used to identify it
+ * in the aether component tree. We recommend using `Aether.wrap` to generate unique keys.
+ * @param props.schema - The zod schema for the component's state. Used to validate state
+ * changes on transfer to and from the worker thread.
+ * @param props.initialState - The initial state for the component. Note that this state
+ * is only used on the first render, and any changes to this value will not be reflected
+ * in the component's state. To alter the component's state, use the setState function
+ * returned by the hook.
+ * @returns A triplet with the following values:
+ * 1. An object containing metadata about the generated component. This object contains
+ * a path property, which is an array of strings representing the path to the component
+ * in the aether component tree.
+ * 2. The component's current state. This is synchronised with the worker thread, and
+ * can be updated by both the worker and the main thread.
+ * 3. A function that can be used to update the component's state. This function takes
+ * in both the next state and an optional array of transferable objects. The next state
+ * can be either a new state, or a function that takes in the current state and returns
+ * the next state. This function is impure, and will update the component's state on the
+ * worker thread.
+ */
+export declare const use: <S extends z.ZodTypeAny>(props: UseProps<S>) => UseReturn<S>;
+type StateHandler = (state: any) => void;
+export interface CompositeProps extends PropsWithChildren {
+    path: string[];
+}
+/**
+ * Composite establishes all children as child components of the current component. The
+ * provide path should match the path returned by the {@link use} hook. Any children
+ * of this component will be added to the `children` property of the component on the
+ * worker tree.
+ *
+ * Naturally, composites can be nested within each other. Child components that are
+ */
+export declare const Composite: import("react").MemoExoticComponent<({ children, path }: CompositeProps) => JSX.Element>;
+/**
+ * Wrap wraps a component to generate a unique key that persists across re-renders. This
+ * hook is necessary to create an aether enhanced component when using React.StrictMode.
+ *
+ * @param displayName - The display name of the component. Used or react devtools.
+ * @param Component - The component to wrap. This component receives an additional
+ * aetherKey prop along with its normal props.
+ * @returns A wrapped component that is behaviorally identical to the original component.
+ */
+export declare const wrap: <P extends {}>(displayName: string, Component: ComponentType<P & {
+    aetherKey: string;
+}>) => FC<P & {
+    aetherKey?: string | undefined;
+}>;
+export {};

package/dist/aether/main.spec.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const exampleProps: z.ZodObject<{
+    x: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    x: number;
+}, {
+    x: number;
+}>;

package/dist/aether/message.d.ts

@@ -0,0 +1,17 @@
+export interface MainUpdate {
+    variant: "update";
+    path: string[];
+    type: string;
+    state: any;
+}
+export interface MainDelete {
+    variant: "delete";
+    type: string;
+    path: string[];
+}
+export interface WorkerUpdate {
+    key: string;
+    state: any;
+}
+export type WorkerMessage = WorkerUpdate;
+export type MainMessage = MainUpdate | MainDelete;

package/dist/aether.cjs

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const css = require("./css-V3VUT_Js.cjs");
+const component = require("./component-joFaJiQW.cjs");
+const table = require("./table-VNkSG_Cj.cjs");
+const fontString = require("./fontString-i24UxKCQ.cjs");
+const external$3 = require("./external-eQU48hM4.cjs");
+require("zod");
+require("react");
+require("react-dom");
+require("./dimensions-Sej0Zly9.cjs");
+const external$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Provider: component.Provider,
+  REGISTRY: component.REGISTRY,
+  fontString: fontString.fontString,
+  synnaxDark: component.synnaxDark,
+  synnaxLight: component.synnaxLight,
+  themeZ: component.themeZ,
+  themes: component.themes,
+  use: component.use
+}, Symbol.toStringTag, { value: "Module" }));
+const external$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Context: table.Context,
+  Controller: table.Controller,
+  Eraser: table.Eraser,
+  GLProgram: table.GLProgram,
+  Loop: table.Loop,
+  REASON_DATA: table.REASON_DATA,
+  REASON_LAYOUT: table.REASON_LAYOUT,
+  REASON_TOOL: table.REASON_TOOL
+}, Symbol.toStringTag, { value: "Module" }));
+const external = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  LinePlot: table.LinePlot,
+  REGISTRY: table.REGISTRY$1,
+  XAxis: table.XAxis,
+  YAxis: table.YAxis,
+  linePlotStateZ: table.linePlotStateZ,
+  xAxisStateZ: table.xAxisStateZ,
+  yAxisStateZ: table.yAxisStateZ
+}, Symbol.toStringTag, { value: "Module" }));
+const render = () => {
+  const w = new css.RoutedWorker((data, transfer) => postMessage(data, transfer));
+  onmessage = w.handle.bind(w);
+  const REGISTRY = {
+    ...table.REGISTRY$1,
+    ...table.REGISTRY$2,
+    ...table.REGISTRY$3,
+    ...table.REGISTRY,
+    ...table.REGISTRY$4,
+    ...table.REGISTRY$5,
+    ...table.REGISTRY$6,
+    ...table.REGISTRY$7,
+    ...table.REGISTRY$8,
+    ...table.REGISTRY$9,
+    ...table.REGISTRY$10,
+    ...table.REGISTRY$11,
+    ...component.REGISTRY,
+    ...component.REGISTRY$1,
+    ...table.REGISTRY$12,
+    ...table.REGISTRY$13,
+    ...table.REGISTRY$14,
+    ...table.REGISTRY$15
+  };
+  component.render({
+    worker: w.route("vis"),
+    registry: REGISTRY
+  });
+};
+const _pluto = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  render
+}, Symbol.toStringTag, { value: "Module" }));
+exports.color = css.color;
+exports.aether = component.aether;
+exports.canvas = table.canvas;
+exports.diagram = table.Diagram;
+exports.measure = table.measure;
+exports.rule = table.aether;
+exports.synnax = table.provider;
+exports.tooltip = table.tooltip;
+exports.value = table.value;
+exports.telem = external$3.external;
+exports.lineplot = external;
+exports.pluto = _pluto;
+exports.render = external$1;
+exports.theming = external$2;
+//# sourceMappingURL=aether.cjs.map

package/dist/aether.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"aether.cjs","sources":["../src/pluto/aether/ pluto.ts"],"sourcesContent":["// Copyright 2023 Synnax Labs, Inc.\n//\n// Use of this software is governed by the Business Source License included in the file\n// licenses/BSL.txt.\n//\n// As of the Change Date specified in that file, in accordance with the Business Source\n// License, use of this software will be governed by the Apache License, Version 2.0,\n// included in the file licenses/APL.txt.\n\nimport { RoutedWorker } from \"@synnaxlabs/x\";\n\nimport { aether } from \"@/aether/aether\";\nimport { alamos } from \"@/alamos/aether\";\nimport { status } from \"@/status/aether\";\nimport { synnax } from \"@/synnax/aether\";\nimport { telem } from \"@/telem/aether\";\nimport { control } from \"@/telem/control/aether\";\nimport { theming } from \"@/theming/aether\";\nimport { button } from \"@/vis/button/aether\";\nimport { canvas } from \"@/vis/canvas/aether\";\nimport { diagram } from \"@/vis/diagram/aether\";\nimport { eraser } from \"@/vis/eraser/aether\";\nimport { line } from \"@/vis/line/aether\";\nimport { lineplot } from \"@/vis/lineplot/aether\";\nimport { tooltip } from \"@/vis/lineplot/tooltip/aether\";\nimport { measure } from \"@/vis/measure/aether\";\nimport { rule } from \"@/vis/rule/aether\";\nimport { table } from \"@/vis/table/aether\";\nimport { toggle } from \"@/vis/toggle/aether\";\nimport { value } from \"@/vis/value/aether\";\n\nexport const render = (): void => {\n  // @ts-expect-error - for some reason post-message can't type transfer correctly\n  const w = new RoutedWorker((data, transfer) => postMessage(data, transfer));\n  onmessage = w.handle.bind(w);\n\n  const REGISTRY: aether.ComponentRegistry = {\n    ...lineplot.REGISTRY,\n    ...canvas.REGISTRY,\n    ...synnax.REGISTRY,\n    ...telem.REGISTRY,\n    ...line.REGISTRY,\n    ...value.REGISTRY,\n    ...toggle.REGISTRY,\n    ...diagram.REGISTRY,\n    ...rule.REGISTRY,\n    ...tooltip.REGISTRY,\n    ...measure.REGISTRY,\n    ...control.REGISTRY,\n    ...theming.REGISTRY,\n    ...status.REGISTRY,\n    ...button.REGISTRY,\n    ...alamos.REGISTRY,\n    ...eraser.REGISTRY,\n    ...table.REGISTRY,\n  };\n\n  aether.render({\n    worker: w.route(\"vis\"),\n    registry: REGISTRY,\n  });\n};\n"],"names":["RoutedWorker","lineplot.REGISTRY","canvas.REGISTRY","synnax.REGISTRY","telem.REGISTRY","line.REGISTRY","value.REGISTRY","toggle.REGISTRY","diagram.REGISTRY","rule.REGISTRY","tooltip.REGISTRY","measure.REGISTRY","control.REGISTRY","theming.REGISTRY","status.REGISTRY","button.REGISTRY","alamos.REGISTRY","eraser.REGISTRY","table.REGISTRY","aether.render"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BO,MAAM,SAAS,MAAY;AAE1B,QAAA,IAAI,IAAIA,IAAa,aAAA,CAAC,MAAM,aAAa,YAAY,MAAM,QAAQ,CAAC;AAC9D,cAAA,EAAE,OAAO,KAAK,CAAC;AAE3B,QAAM,WAAqC;AAAA,IACzC,GAAGC,MAAS;AAAA,IACZ,GAAGC,MAAO;AAAA,IACV,GAAGC,MAAO;AAAA,IACV,GAAGC,MAAM;AAAA,IACT,GAAGC,MAAK;AAAA,IACR,GAAGC,MAAM;AAAA,IACT,GAAGC,MAAO;AAAA,IACV,GAAGC,MAAQ;AAAA,IACX,GAAGC,MAAK;AAAA,IACR,GAAGC,MAAQ;AAAA,IACX,GAAGC,MAAQ;AAAA,IACX,GAAGC,MAAQ;AAAA,IACX,GAAGC,UAAQ;AAAA,IACX,GAAGC,UAAO;AAAA,IACV,GAAGC,MAAO;AAAA,IACV,GAAGC,MAAO;AAAA,IACV,GAAGC,MAAO;AAAA,IACV,GAAGC,MAAM;AAAA,EAAA;AAGXC,mBAAc;AAAA,IACZ,QAAQ,EAAE,MAAM,KAAK;AAAA,IACrB,UAAU;AAAA,EAAA,CACX;AACH;;;;;;;;;;;;;;;;;;;"}