@burtson-labs/ui 0.13.1 → 0.14.1

package/dist/primitives/vendor/radix/react-collection/ordered-dictionary.d.ts

@@ -0,0 +1,51 @@
+export declare class OrderedDict<K, V> extends Map<K, V> {
+    #private;
+    constructor(iterable?: Iterable<readonly [K, V]> | null | undefined);
+    set(key: K, value: V): this;
+    insert(index: number, key: K, value: V): this;
+    with(index: number, key: K, value: V): OrderedDict<K, V>;
+    before(key: K): [K, V] | undefined;
+    /**
+     * Sets a new key-value pair at the position before the given key.
+     */
+    setBefore(key: K, newKey: K, value: V): this;
+    after(key: K): [K, V] | undefined;
+    /**
+     * Sets a new key-value pair at the position after the given key.
+     */
+    setAfter(key: K, newKey: K, value: V): this;
+    first(): [K, V] | undefined;
+    last(): [K, V] | undefined;
+    clear(): void;
+    delete(key: K): boolean;
+    deleteAt(index: number): boolean;
+    at(index: number): V | undefined;
+    entryAt(index: number): [K, V] | undefined;
+    indexOf(key: K): number;
+    keyAt(index: number): K | undefined;
+    from(key: K, offset: number): V | undefined;
+    keyFrom(key: K, offset: number): K | undefined;
+    find(predicate: (entry: [K, V], index: number, dictionary: OrderedDict<K, V>) => boolean, thisArg?: any): [K, V] | undefined;
+    findIndex(predicate: (entry: [K, V], index: number, dictionary: OrderedDict<K, V>) => boolean, thisArg?: any): number;
+    filter<KK extends K, VV extends V>(predicate: (entry: [K, V], index: number, dict: OrderedDict<K, V>) => entry is [KK, VV], thisArg?: any): OrderedDict<KK, VV>;
+    filter(predicate: (entry: [K, V], index: number, dictionary: OrderedDict<K, V>) => unknown, thisArg?: any): OrderedDict<K, V>;
+    map<U>(callbackfn: (entry: [K, V], index: number, dictionary: OrderedDict<K, V>) => U, thisArg?: any): OrderedDict<K, U>;
+    reduce(callbackfn: (previousValue: [K, V], currentEntry: [K, V], currentIndex: number, dictionary: OrderedDict<K, V>) => [K, V]): [K, V];
+    reduce(callbackfn: (previousValue: [K, V], currentEntry: [K, V], currentIndex: number, dictionary: OrderedDict<K, V>) => [K, V], initialValue: [K, V]): [K, V];
+    reduce<U>(callbackfn: (previousValue: U, currentEntry: [K, V], currentIndex: number, dictionary: OrderedDict<K, V>) => U, initialValue: U): U;
+    reduceRight(callbackfn: (previousValue: [K, V], currentEntry: [K, V], currentIndex: number, dictionary: OrderedDict<K, V>) => [K, V]): [K, V];
+    reduceRight(callbackfn: (previousValue: [K, V], currentEntry: [K, V], currentIndex: number, dictionary: OrderedDict<K, V>) => [K, V], initialValue: [K, V]): [K, V];
+    reduceRight<U>(callbackfn: (previousValue: [K, V], currentValue: U, currentIndex: number, dictionary: OrderedDict<K, V>) => U, initialValue: U): U;
+    toSorted(compareFn?: (a: [K, V], b: [K, V]) => number): OrderedDict<K, V>;
+    toReversed(): OrderedDict<K, V>;
+    toSpliced(start: number, deleteCount?: number): OrderedDict<K, V>;
+    toSpliced(start: number, deleteCount: number, ...items: [K, V][]): OrderedDict<K, V>;
+    slice(start?: number, end?: number): OrderedDict<K, V>;
+    every(predicate: (entry: [K, V], index: number, dictionary: OrderedDict<K, V>) => unknown, thisArg?: any): boolean;
+    some(predicate: (entry: [K, V], index: number, dictionary: OrderedDict<K, V>) => unknown, thisArg?: any): boolean;
+}
+export type KeyOf<D extends OrderedDict<any, any>> = D extends OrderedDict<infer K, any> ? K : never;
+export type ValueOf<D extends OrderedDict<any, any>> = D extends OrderedDict<any, infer V> ? V : never;
+export type EntryOf<D extends OrderedDict<any, any>> = [KeyOf<D>, ValueOf<D>];
+export type KeyFrom<E extends EntryOf<any>> = E[0];
+export type ValueFrom<E extends EntryOf<any>> = E[1];

package/dist/primitives/vendor/radix/react-compose-refs/compose-refs.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+type PossibleRef<T> = React.Ref<T> | undefined;
+/**
+ * A utility to compose multiple refs together
+ * Accepts callback refs and RefObject(s)
+ */
+declare function composeRefs<T>(...refs: PossibleRef<T>[]): React.RefCallback<T>;
+/**
+ * A custom hook that composes multiple refs
+ * Accepts callback refs and RefObject(s)
+ */
+declare function useComposedRefs<T>(...refs: PossibleRef<T>[]): React.RefCallback<T>;
+export { composeRefs, useComposedRefs };

package/dist/primitives/vendor/radix/react-compose-refs/compose-refs.js

@@ -0,0 +1,43 @@
+"use client";
+import * as React from "react";
+//#region src/primitives/vendor/radix/react-compose-refs/compose-refs.tsx
+/**
+* Set a given ref to a given value
+* This utility takes care of different types of refs: callback refs and RefObject(s)
+*/
+function setRef(ref, value) {
+	if (typeof ref === "function") return ref(value);
+	else if (ref !== null && ref !== void 0) ref.current = value;
+}
+/**
+* A utility to compose multiple refs together
+* Accepts callback refs and RefObject(s)
+*/
+function composeRefs(...refs) {
+	return (node) => {
+		let hasCleanup = false;
+		const cleanups = refs.map((ref) => {
+			const cleanup = setRef(ref, node);
+			if (!hasCleanup && typeof cleanup == "function") hasCleanup = true;
+			return cleanup;
+		});
+		if (hasCleanup) return () => {
+			for (let i = 0; i < cleanups.length; i++) {
+				const cleanup = cleanups[i];
+				if (typeof cleanup == "function") cleanup();
+				else setRef(refs[i], null);
+			}
+		};
+	};
+}
+/**
+* A custom hook that composes multiple refs
+* Accepts callback refs and RefObject(s)
+*/
+function useComposedRefs(...refs) {
+	return React.useCallback(composeRefs(...refs), refs);
+}
+//#endregion
+export { composeRefs, useComposedRefs };
+
+//# sourceMappingURL=compose-refs.js.map

package/dist/primitives/vendor/radix/react-compose-refs/compose-refs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose-refs.js","names":[],"sources":["../../../../../src/primitives/vendor/radix/react-compose-refs/compose-refs.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\n\ntype PossibleRef<T> = React.Ref<T> | undefined;\n\n/**\n * Set a given ref to a given value\n * This utility takes care of different types of refs: callback refs and RefObject(s)\n */\nfunction setRef<T>(ref: PossibleRef<T>, value: T) {\n  if (typeof ref === 'function') {\n    return ref(value);\n  } else if (ref !== null && ref !== undefined) {\n    ref.current = value;\n  }\n}\n\n/**\n * A utility to compose multiple refs together\n * Accepts callback refs and RefObject(s)\n */\nfunction composeRefs<T>(...refs: PossibleRef<T>[]): React.RefCallback<T> {\n  return (node) => {\n    let hasCleanup = false;\n    const cleanups = refs.map((ref) => {\n      const cleanup = setRef(ref, node);\n      if (!hasCleanup && typeof cleanup == 'function') {\n        hasCleanup = true;\n      }\n      return cleanup;\n    });\n\n    // React <19 will log an error to the console if a callback ref returns a\n    // value. We don't use ref cleanups internally so this will only happen if a\n    // user's ref callback returns a value, which we only expect if they are\n    // using the cleanup functionality added in React 19.\n    if (hasCleanup) {\n      return () => {\n        for (let i = 0; i < cleanups.length; i++) {\n          const cleanup = cleanups[i];\n          if (typeof cleanup == 'function') {\n            cleanup();\n          } else {\n            setRef(refs[i], null);\n          }\n        }\n      };\n    }\n  };\n}\n\n/**\n * A custom hook that composes multiple refs\n * Accepts callback refs and RefObject(s)\n */\nfunction useComposedRefs<T>(...refs: PossibleRef<T>[]): React.RefCallback<T> {\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  return React.useCallback(composeRefs(...refs), refs);\n}\n\nexport { composeRefs, useComposedRefs };\n"],"mappings":";;;;;;;AAUA,SAAS,OAAU,KAAqB,OAAU;CAChD,IAAI,OAAO,QAAQ,YACjB,OAAO,IAAI,KAAK;MACX,IAAI,QAAQ,QAAQ,QAAQ,KAAA,GACjC,IAAI,UAAU;AAElB;;;;;AAMA,SAAS,YAAe,GAAG,MAA8C;CACvE,QAAQ,SAAS;EACf,IAAI,aAAa;EACjB,MAAM,WAAW,KAAK,KAAK,QAAQ;GACjC,MAAM,UAAU,OAAO,KAAK,IAAI;GAChC,IAAI,CAAC,cAAc,OAAO,WAAW,YACnC,aAAa;GAEf,OAAO;EACT,CAAC;EAMD,IAAI,YACF,aAAa;GACX,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;IACxC,MAAM,UAAU,SAAS;IACzB,IAAI,OAAO,WAAW,YACpB,QAAQ;SAER,OAAO,KAAK,IAAI,IAAI;GAExB;EACF;CAEJ;AACF;;;;;AAMA,SAAS,gBAAmB,GAAG,MAA8C;CAE3E,OAAO,MAAM,YAAY,YAAY,GAAG,IAAI,GAAG,IAAI;AACrD"}

package/dist/primitives/vendor/radix/react-compose-refs/index.d.ts

@@ -0,0 +1 @@
+export { composeRefs, useComposedRefs } from './compose-refs';

package/dist/primitives/vendor/radix/react-context/create-context.d.ts

@@ -0,0 +1,45 @@
+import * as React from 'react';
+type ContextProvider<ContextValueType extends object | null> = React.FC<ContextValueType & {
+    children: React.ReactNode;
+}>;
+interface UseAssertedContext<ContextValueType extends object | null> {
+    (consumerName: string): ContextValueType;
+}
+interface UseContext<ContextValueType extends object | null> {
+    (consumerName: string): ContextValueType;
+    (consumerName: string, options: {
+        optional: true;
+    }): ContextValueType | undefined;
+}
+declare function createContext<ContextValueType extends object | null>(rootComponentName: string): readonly [ContextProvider<ContextValueType>, UseContext<ContextValueType>];
+declare function createContext<ContextValueType extends object | null>(rootComponentName: string, defaultContext: ContextValueType): readonly [ContextProvider<ContextValueType>, UseAssertedContext<ContextValueType>];
+type Scope<C = any> = {
+    [scopeName: string]: React.Context<C>[];
+} | undefined;
+type ScopeHook = (scope: Scope) => {
+    [__scopeProp: string]: Scope;
+};
+interface CreateScope {
+    scopeName: string;
+    (): ScopeHook;
+}
+type ScopedContextProvider<ContextValueType extends object | null> = React.FC<ContextValueType & {
+    scope: Scope<ContextValueType>;
+    children: React.ReactNode;
+}>;
+interface UseScopedContext<ContextValueType extends object | null> {
+    (consumerName: string, scope: Scope<ContextValueType | undefined>): ContextValueType;
+    (consumerName: string, scope: Scope<ContextValueType | undefined>, options: {
+        optional?: true;
+    }): ContextValueType | undefined;
+}
+interface UseAssertedScopedContext<ContextValueType extends object | null> {
+    (consumerName: string, scope: Scope<ContextValueType | undefined>): ContextValueType;
+}
+interface CreateScopedContext {
+    <ContextValueType extends object | null>(rootComponentName: string): readonly [ScopedContextProvider<ContextValueType>, UseScopedContext<ContextValueType>];
+    <ContextValueType extends object | null>(rootComponentName: string, defaultContext: ContextValueType): readonly [ScopedContextProvider<ContextValueType>, UseAssertedScopedContext<ContextValueType>];
+}
+declare function createContextScope(scopeName: string, createContextScopeDeps?: CreateScope[]): readonly [CreateScopedContext, CreateScope];
+export { createContext, createContextScope };
+export type { CreateScope, CreateScopedContext, Scope, UseAssertedContext, UseAssertedScopedContext, UseContext, UseScopedContext, };

package/dist/primitives/vendor/radix/react-context/create-context.js

@@ -0,0 +1,74 @@
+"use client";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/primitives/vendor/radix/react-context/create-context.tsx
+/* @__NO_SIDE_EFFECTS__ */
+function createContextScope(scopeName, createContextScopeDeps = []) {
+	let defaultContexts = [];
+	function createContext(rootComponentName, defaultContext) {
+		const BaseContext = React.createContext(defaultContext);
+		BaseContext.displayName = rootComponentName + "Context";
+		const index = defaultContexts.length;
+		defaultContexts = [...defaultContexts, defaultContext];
+		const Provider = (props) => {
+			const { scope, children, ...context } = props;
+			const Context = scope?.[scopeName]?.[index] || BaseContext;
+			const value = React.useMemo(() => context, Object.values(context));
+			return /* @__PURE__ */ jsx(Context.Provider, {
+				value,
+				children
+			});
+		};
+		Provider.displayName = rootComponentName + "Provider";
+		function useContext(consumerName, scope, options = {}) {
+			const { optional = false } = options;
+			const Context = scope?.[scopeName]?.[index] || BaseContext;
+			const context = React.useContext(Context);
+			if (context) return context;
+			if (defaultContext !== void 0) return defaultContext;
+			if (optional) return void 0;
+			throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+		}
+		return [Provider, useContext];
+	}
+	const createScope = () => {
+		const scopeContexts = defaultContexts.map((defaultContext) => {
+			return React.createContext(defaultContext);
+		});
+		return function useScope(scope) {
+			const contexts = scope?.[scopeName] || scopeContexts;
+			return React.useMemo(() => ({ [`__scope${scopeName}`]: {
+				...scope,
+				[scopeName]: contexts
+			} }), [scope, contexts]);
+		};
+	};
+	createScope.scopeName = scopeName;
+	return [createContext, composeContextScopes(createScope, ...createContextScopeDeps)];
+}
+function composeContextScopes(...scopes) {
+	const baseScope = scopes[0];
+	if (scopes.length === 1) return baseScope;
+	const createScope = () => {
+		const scopeHooks = scopes.map((createScope) => ({
+			useScope: createScope(),
+			scopeName: createScope.scopeName
+		}));
+		return function useComposedScopes(overrideScopes) {
+			const nextScopes = scopeHooks.reduce((nextScopes, { useScope, scopeName }) => {
+				const currentScope = useScope(overrideScopes)[`__scope${scopeName}`];
+				return {
+					...nextScopes,
+					...currentScope
+				};
+			}, {});
+			return React.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
+		};
+	};
+	createScope.scopeName = baseScope.scopeName;
+	return createScope;
+}
+//#endregion
+export { createContextScope };
+
+//# sourceMappingURL=create-context.js.map

package/dist/primitives/vendor/radix/react-context/create-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-context.js","names":[],"sources":["../../../../../src/primitives/vendor/radix/react-context/create-context.tsx"],"sourcesContent":["// Vendored from Radix Primitives (c) 2022 WorkOS, MIT. See vendor/LICENSE.radix.\n// Local modification: package imports resolve to the pinned local source.\nimport * as React from 'react';\n\ntype ContextProvider<ContextValueType extends object | null> = React.FC<\n  ContextValueType & {\n    children: React.ReactNode;\n  }\n>;\n\ninterface UseAssertedContext<ContextValueType extends object | null> {\n  (consumerName: string): ContextValueType;\n}\n\ninterface UseContext<ContextValueType extends object | null> {\n  (consumerName: string): ContextValueType;\n  (consumerName: string, options: { optional: true }): ContextValueType | undefined;\n}\n\nfunction createContext<ContextValueType extends object | null>(\n  rootComponentName: string,\n): readonly [ContextProvider<ContextValueType>, UseContext<ContextValueType>];\nfunction createContext<ContextValueType extends object | null>(\n  rootComponentName: string,\n  defaultContext: ContextValueType,\n): readonly [ContextProvider<ContextValueType>, UseAssertedContext<ContextValueType>];\n\n/* @__NO_SIDE_EFFECTS__ */ function createContext<ContextValueType extends object | null>(\n  rootComponentName: string,\n  defaultContext?: ContextValueType,\n): readonly [ContextProvider<ContextValueType>, UseContext<ContextValueType>] {\n  const Context = React.createContext<ContextValueType | undefined>(defaultContext);\n  Context.displayName = rootComponentName + 'Context';\n\n  const Provider: ContextProvider<ContextValueType> = (props) => {\n    const { children, ...context } = props;\n    // Only re-memoize when prop values change\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    const value = React.useMemo(() => context, Object.values(context)) as ContextValueType;\n    return <Context.Provider value={value}>{children}</Context.Provider>;\n  };\n\n  Provider.displayName = rootComponentName + 'Provider';\n\n  function useContext(consumerName: string): ContextValueType;\n  function useContext(\n    consumerName: string,\n    options: { optional: true },\n  ): ContextValueType | undefined;\n\n  function useContext(\n    consumerName: string,\n    options: { optional?: boolean } = {},\n  ): ContextValueType | undefined {\n    const { optional = false } = options;\n    const context = React.useContext(Context);\n    if (context) return context;\n    if (defaultContext !== undefined) return defaultContext;\n    if (optional) return undefined;\n    // if a defaultContext wasn't specified, it's a required context.\n    throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n  }\n\n  return [Provider, useContext];\n}\n\n/* -------------------------------------------------------------------------------------------------\n * createContextScope\n * -----------------------------------------------------------------------------------------------*/\n\ntype Scope<C = any> = { [scopeName: string]: React.Context<C>[] } | undefined;\ntype ScopeHook = (scope: Scope) => { [__scopeProp: string]: Scope };\ninterface CreateScope {\n  scopeName: string;\n  (): ScopeHook;\n}\n\ntype ScopedContextProvider<ContextValueType extends object | null> = React.FC<\n  ContextValueType & {\n    scope: Scope<ContextValueType>;\n    children: React.ReactNode;\n  }\n>;\n\ninterface UseScopedContext<ContextValueType extends object | null> {\n  (consumerName: string, scope: Scope<ContextValueType | undefined>): ContextValueType;\n  (\n    consumerName: string,\n    scope: Scope<ContextValueType | undefined>,\n    options: { optional?: true },\n  ): ContextValueType | undefined;\n}\n\ninterface UseAssertedScopedContext<ContextValueType extends object | null> {\n  (consumerName: string, scope: Scope<ContextValueType | undefined>): ContextValueType;\n}\n\ninterface CreateScopedContext {\n  <ContextValueType extends object | null>(\n    rootComponentName: string,\n  ): readonly [ScopedContextProvider<ContextValueType>, UseScopedContext<ContextValueType>];\n  <ContextValueType extends object | null>(\n    rootComponentName: string,\n    defaultContext: ContextValueType,\n  ): readonly [ScopedContextProvider<ContextValueType>, UseAssertedScopedContext<ContextValueType>];\n}\n\n/* @__NO_SIDE_EFFECTS__ */ function createContextScope(\n  scopeName: string,\n  createContextScopeDeps: CreateScope[] = [],\n): readonly [CreateScopedContext, CreateScope] {\n  let defaultContexts: any[] = [];\n\n  /* -----------------------------------------------------------------------------------------------\n   * createContext\n   * ---------------------------------------------------------------------------------------------*/\n\n  function createContext<ContextValueType extends object | null>(\n    rootComponentName: string,\n    defaultContext?: ContextValueType,\n  ) {\n    const BaseContext = React.createContext<ContextValueType | undefined>(defaultContext);\n    BaseContext.displayName = rootComponentName + 'Context';\n    const index = defaultContexts.length;\n    defaultContexts = [...defaultContexts, defaultContext];\n\n    const Provider: ScopedContextProvider<ContextValueType> = (props) => {\n      const { scope, children, ...context } = props;\n      const Context = scope?.[scopeName]?.[index] || BaseContext;\n      // Only re-memoize when prop values change\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      const value = React.useMemo(() => context, Object.values(context)) as ContextValueType;\n      return <Context.Provider value={value}>{children}</Context.Provider>;\n    };\n\n    Provider.displayName = rootComponentName + 'Provider';\n\n    function useContext(\n      consumerName: string,\n      scope: Scope<ContextValueType | undefined>,\n    ): ContextValueType;\n    function useContext(\n      consumerName: string,\n      scope: Scope<ContextValueType | undefined>,\n      options: { optional: true },\n    ): ContextValueType | undefined;\n\n    function useContext(\n      consumerName: string,\n      scope: Scope<ContextValueType | undefined>,\n      options: { optional?: boolean } = {},\n    ): ContextValueType | undefined {\n      const { optional = false } = options;\n      const Context = scope?.[scopeName]?.[index] || BaseContext;\n      const context = React.useContext(Context);\n      if (context) return context;\n      if (defaultContext !== undefined) return defaultContext;\n      if (optional) return undefined;\n      // if a defaultContext wasn't specified, it's a required context.\n      throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n    }\n\n    return [Provider, useContext] as const;\n  }\n\n  /* -----------------------------------------------------------------------------------------------\n   * createScope\n   * ---------------------------------------------------------------------------------------------*/\n\n  const createScope: CreateScope = () => {\n    const scopeContexts = defaultContexts.map((defaultContext) => {\n      return React.createContext(defaultContext);\n    });\n    return function useScope(scope: Scope) {\n      const contexts = scope?.[scopeName] || scopeContexts;\n      return React.useMemo(\n        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),\n        [scope, contexts],\n      );\n    };\n  };\n\n  createScope.scopeName = scopeName;\n  return [createContext, composeContextScopes(createScope, ...createContextScopeDeps)] as const;\n}\n\n/* -------------------------------------------------------------------------------------------------\n * composeContextScopes\n * -----------------------------------------------------------------------------------------------*/\n\nfunction composeContextScopes(...scopes: [CreateScope, ...CreateScope[]]): CreateScope {\n  const baseScope = scopes[0];\n  if (scopes.length === 1) return baseScope;\n\n  const createScope: CreateScope = () => {\n    const scopeHooks = scopes.map((createScope) => ({\n      useScope: createScope(),\n      scopeName: createScope.scopeName,\n    }));\n\n    return function useComposedScopes(overrideScopes) {\n      const nextScopes = scopeHooks.reduce((nextScopes, { useScope, scopeName }) => {\n        // We are calling a hook inside a callback which React warns against to avoid inconsistent\n        // renders, however, scoping doesn't have render side effects so we ignore the rule.\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        const scopeProps = useScope(overrideScopes);\n        const currentScope = scopeProps[`__scope${scopeName}`];\n        return { ...nextScopes, ...currentScope };\n      }, {});\n\n      return React.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);\n    };\n  };\n\n  createScope.scopeName = baseScope.scopeName;\n  return createScope;\n}\n\n/* -----------------------------------------------------------------------------------------------*/\n\nexport { createContext, createContextScope };\nexport type {\n  CreateScope,\n  CreateScopedContext,\n  Scope,\n  UseAssertedContext,\n  UseAssertedScopedContext,\n  UseContext,\n  UseScopedContext,\n};\n"],"mappings":";;;;;AA2G2B,SAAS,mBAClC,WACA,yBAAwC,CAAC,GACI;CAC7C,IAAI,kBAAyB,CAAC;CAM9B,SAAS,cACP,mBACA,gBACA;EACA,MAAM,cAAc,MAAM,cAA4C,cAAc;EACpF,YAAY,cAAc,oBAAoB;EAC9C,MAAM,QAAQ,gBAAgB;EAC9B,kBAAkB,CAAC,GAAG,iBAAiB,cAAc;EAErD,MAAM,YAAqD,UAAU;GACnE,MAAM,EAAE,OAAO,UAAU,GAAG,YAAY;GACxC,MAAM,UAAU,QAAQ,UAAU,GAAG,UAAU;GAG/C,MAAM,QAAQ,MAAM,cAAc,SAAS,OAAO,OAAO,OAAO,CAAC;GACjE,OAAO,oBAAC,QAAQ,UAAT;IAAyB;IAAQ;GAA2B,CAAA;EACrE;EAEA,SAAS,cAAc,oBAAoB;EAY3C,SAAS,WACP,cACA,OACA,UAAkC,CAAC,GACL;GAC9B,MAAM,EAAE,WAAW,UAAU;GAC7B,MAAM,UAAU,QAAQ,UAAU,GAAG,UAAU;GAC/C,MAAM,UAAU,MAAM,WAAW,OAAO;GACxC,IAAI,SAAS,OAAO;GACpB,IAAI,mBAAmB,KAAA,GAAW,OAAO;GACzC,IAAI,UAAU,OAAO,KAAA;GAErB,MAAM,IAAI,MAAM,KAAK,aAAa,2BAA2B,kBAAkB,GAAG;EACpF;EAEA,OAAO,CAAC,UAAU,UAAU;CAC9B;CAMA,MAAM,oBAAiC;EACrC,MAAM,gBAAgB,gBAAgB,KAAK,mBAAmB;GAC5D,OAAO,MAAM,cAAc,cAAc;EAC3C,CAAC;EACD,OAAO,SAAS,SAAS,OAAc;GACrC,MAAM,WAAW,QAAQ,cAAc;GACvC,OAAO,MAAM,eACJ,GAAG,UAAU,cAAc;IAAE,GAAG;KAAQ,YAAY;GAAS,EAAE,IACtE,CAAC,OAAO,QAAQ,CAClB;EACF;CACF;CAEA,YAAY,YAAY;CACxB,OAAO,CAAC,eAAe,qBAAqB,aAAa,GAAG,sBAAsB,CAAC;AACrF;AAMA,SAAS,qBAAqB,GAAG,QAAsD;CACrF,MAAM,YAAY,OAAO;CACzB,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,MAAM,oBAAiC;EACrC,MAAM,aAAa,OAAO,KAAK,iBAAiB;GAC9C,UAAU,YAAY;GACtB,WAAW,YAAY;EACzB,EAAE;EAEF,OAAO,SAAS,kBAAkB,gBAAgB;GAChD,MAAM,aAAa,WAAW,QAAQ,YAAY,EAAE,UAAU,gBAAgB;IAK5E,MAAM,eADa,SAAS,cACP,CAAA,CAAW,UAAU;IAC1C,OAAO;KAAE,GAAG;KAAY,GAAG;IAAa;GAC1C,GAAG,CAAC,CAAC;GAEL,OAAO,MAAM,eAAe,GAAG,UAAU,UAAU,cAAc,WAAW,IAAI,CAAC,UAAU,CAAC;EAC9F;CACF;CAEA,YAAY,YAAY,UAAU;CAClC,OAAO;AACT"}

package/dist/primitives/vendor/radix/react-context/index.d.ts

@@ -0,0 +1,2 @@
+export { createContext, createContextScope } from './create-context';
+export type { CreateScope, Scope } from './create-context';

package/dist/primitives/vendor/radix/react-context-menu/context-menu.d.ts

@@ -0,0 +1,95 @@
+import * as React from 'react';
+import { Primitive } from '../react-primitive';
+import * as MenuPrimitive from '../react-menu';
+type Direction = 'ltr' | 'rtl';
+declare const createContextMenuScope: import("../react-context").CreateScope;
+interface ContextMenuProps {
+    children?: React.ReactNode;
+    open?: boolean;
+    onOpenChange?(open: boolean): void;
+    dir?: Direction;
+    modal?: boolean;
+}
+declare const ContextMenu: React.FC<ContextMenuProps>;
+type PrimitiveSpanProps = React.ComponentPropsWithoutRef<typeof Primitive.span>;
+interface ContextMenuTriggerProps extends PrimitiveSpanProps {
+    disabled?: boolean;
+}
+declare const ContextMenuTrigger: React.ForwardRefExoticComponent<ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
+type MenuPortalProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Portal>;
+interface ContextMenuPortalProps extends MenuPortalProps {
+}
+declare const ContextMenuPortal: React.FC<ContextMenuPortalProps>;
+type MenuContentProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Content>;
+interface ContextMenuContentProps extends Omit<MenuContentProps, 'onEntryFocus' | 'side' | 'sideOffset' | 'align'> {
+}
+declare const ContextMenuContent: React.ForwardRefExoticComponent<ContextMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+type MenuGroupProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Group>;
+interface ContextMenuGroupProps extends MenuGroupProps {
+}
+declare const ContextMenuGroup: React.ForwardRefExoticComponent<ContextMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+type MenuLabelProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Label>;
+interface ContextMenuLabelProps extends MenuLabelProps {
+}
+declare const ContextMenuLabel: React.ForwardRefExoticComponent<ContextMenuLabelProps & React.RefAttributes<HTMLDivElement>>;
+type MenuItemProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Item>;
+interface ContextMenuItemProps extends MenuItemProps {
+}
+declare const ContextMenuItem: React.ForwardRefExoticComponent<ContextMenuItemProps & React.RefAttributes<HTMLDivElement>>;
+type MenuCheckboxItemProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.CheckboxItem>;
+interface ContextMenuCheckboxItemProps extends MenuCheckboxItemProps {
+}
+declare const ContextMenuCheckboxItem: React.ForwardRefExoticComponent<ContextMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+type MenuRadioGroupProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.RadioGroup>;
+interface ContextMenuRadioGroupProps extends MenuRadioGroupProps {
+}
+declare const ContextMenuRadioGroup: React.ForwardRefExoticComponent<ContextMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+type MenuRadioItemProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.RadioItem>;
+interface ContextMenuRadioItemProps extends MenuRadioItemProps {
+}
+declare const ContextMenuRadioItem: React.ForwardRefExoticComponent<ContextMenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+type MenuItemIndicatorProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.ItemIndicator>;
+interface ContextMenuItemIndicatorProps extends MenuItemIndicatorProps {
+}
+declare const ContextMenuItemIndicator: React.ForwardRefExoticComponent<ContextMenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+type MenuSeparatorProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Separator>;
+interface ContextMenuSeparatorProps extends MenuSeparatorProps {
+}
+declare const ContextMenuSeparator: React.ForwardRefExoticComponent<ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+type MenuArrowProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.Arrow>;
+interface ContextMenuArrowProps extends MenuArrowProps {
+}
+declare const ContextMenuArrow: React.ForwardRefExoticComponent<ContextMenuArrowProps & React.RefAttributes<SVGSVGElement>>;
+interface ContextMenuSubProps {
+    children?: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?(open: boolean): void;
+}
+declare const ContextMenuSub: React.FC<ContextMenuSubProps>;
+type MenuSubTriggerProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.SubTrigger>;
+interface ContextMenuSubTriggerProps extends MenuSubTriggerProps {
+}
+declare const ContextMenuSubTrigger: React.ForwardRefExoticComponent<ContextMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
+type MenuSubContentProps = React.ComponentPropsWithoutRef<typeof MenuPrimitive.SubContent>;
+interface ContextMenuSubContentProps extends MenuSubContentProps {
+}
+declare const ContextMenuSubContent: React.ForwardRefExoticComponent<ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Root: React.FC<ContextMenuProps>;
+declare const Trigger: React.ForwardRefExoticComponent<ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Portal: React.FC<ContextMenuPortalProps>;
+declare const Content: React.ForwardRefExoticComponent<ContextMenuContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Group: React.ForwardRefExoticComponent<ContextMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const Label: React.ForwardRefExoticComponent<ContextMenuLabelProps & React.RefAttributes<HTMLDivElement>>;
+declare const Item: React.ForwardRefExoticComponent<ContextMenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const CheckboxItem: React.ForwardRefExoticComponent<ContextMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroup: React.ForwardRefExoticComponent<ContextMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const RadioItem: React.ForwardRefExoticComponent<ContextMenuRadioItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const ItemIndicator: React.ForwardRefExoticComponent<ContextMenuItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Separator: React.ForwardRefExoticComponent<ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Arrow: React.ForwardRefExoticComponent<ContextMenuArrowProps & React.RefAttributes<SVGSVGElement>>;
+declare const Sub: React.FC<ContextMenuSubProps>;
+declare const SubTrigger: React.ForwardRefExoticComponent<ContextMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>>;
+declare const SubContent: React.ForwardRefExoticComponent<ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>>;
+export { createContextMenuScope, ContextMenu, ContextMenuTrigger, ContextMenuPortal, ContextMenuContent, ContextMenuGroup, ContextMenuLabel, ContextMenuItem, ContextMenuCheckboxItem, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuItemIndicator, ContextMenuSeparator, ContextMenuArrow, ContextMenuSub, ContextMenuSubTrigger, ContextMenuSubContent, Root, Trigger, Portal, Content, Group, Label, Item, CheckboxItem, RadioGroup, RadioItem, ItemIndicator, Separator, Arrow, Sub, SubTrigger, SubContent, };
+export type { ContextMenuProps, ContextMenuTriggerProps, ContextMenuPortalProps, ContextMenuContentProps, ContextMenuGroupProps, ContextMenuLabelProps, ContextMenuItemProps, ContextMenuCheckboxItemProps, ContextMenuRadioGroupProps, ContextMenuRadioItemProps, ContextMenuItemIndicatorProps, ContextMenuSeparatorProps, ContextMenuArrowProps, ContextMenuSubProps, ContextMenuSubTriggerProps, ContextMenuSubContentProps, };

package/dist/primitives/vendor/radix/react-context-menu/context-menu.js

@@ -0,0 +1,279 @@
+"use client";
+import { createContextScope } from "../react-context/create-context.js";
+import { composeEventHandlers } from "../primitive/primitive.js";
+import { IS_DEVELOPMENT } from "../primitive/is-development.js";
+import { useControllableState } from "../react-use-controllable-state/use-controllable-state.js";
+import { Primitive } from "../react-primitive/primitive.js";
+import { Anchor, CheckboxItem as CheckboxItem$1, Content as Content$1, Group as Group$1, Item as Item$1, ItemIndicator as ItemIndicator$1, Label as Label$1, Portal as Portal$1, RadioGroup as RadioGroup$1, RadioItem as RadioItem$1, Root as Root$1, Separator as Separator$1, Sub as Sub$1, SubContent as SubContent$1, SubTrigger as SubTrigger$1, createMenuScope } from "../react-menu/menu.js";
+import * as React from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/primitives/vendor/radix/react-context-menu/context-menu.tsx
+var CONTEXT_MENU_NAME = "ContextMenu";
+var [createContextMenuContext, createContextMenuScope] = createContextScope(CONTEXT_MENU_NAME, [createMenuScope]);
+var useMenuScope = createMenuScope();
+var [ContextMenuProvider, useContextMenuContext] = createContextMenuContext(CONTEXT_MENU_NAME);
+var ContextMenu = (props) => {
+	const { __scopeContextMenu, children, onOpenChange, open: openProp, dir, modal = true } = props;
+	const hasInteractedRef = React.useRef(false);
+	if (IS_DEVELOPMENT) {
+		const hasWarnedRef = React.useRef(false);
+		React.useEffect(() => {
+			if (openProp === true && !hasInteractedRef.current && !hasWarnedRef.current) {
+				hasWarnedRef.current = true;
+				console.warn("ContextMenu: The `open` prop has been set to `true` before the user has interacted with the trigger, so its position is indeterminate. This is likely unintended and will result in the menu being anchored to the top-left corner of the viewport.");
+			}
+		}, [openProp]);
+	}
+	const [open, setOpen] = useControllableState({
+		prop: openProp,
+		defaultProp: false,
+		onChange: onOpenChange,
+		caller: CONTEXT_MENU_NAME
+	});
+	const menuScope = useMenuScope(__scopeContextMenu);
+	return /* @__PURE__ */ jsx(ContextMenuProvider, {
+		scope: __scopeContextMenu,
+		open,
+		onOpenChange: setOpen,
+		modal,
+		hasInteractedRef,
+		children: /* @__PURE__ */ jsx(Root$1, {
+			...menuScope,
+			dir,
+			open,
+			onOpenChange: setOpen,
+			modal,
+			children
+		})
+	});
+};
+var TRIGGER_NAME = "ContextMenuTrigger";
+var ContextMenuTrigger = /* @__PURE__ */ React.forwardRef(function ContextMenuTrigger(props, forwardedRef) {
+	const { __scopeContextMenu, disabled = false, ...triggerProps } = props;
+	const context = useContextMenuContext(TRIGGER_NAME, __scopeContextMenu);
+	const menuScope = useMenuScope(__scopeContextMenu);
+	const [point, setPoint] = React.useState({
+		x: 0,
+		y: 0
+	});
+	const virtualRef = React.useMemo(() => ({ current: { getBoundingClientRect: () => DOMRect.fromRect({
+		width: 0,
+		height: 0,
+		...point
+	}) } }), [point]);
+	const longPressTimerRef = React.useRef(0);
+	const clearLongPress = React.useCallback(() => window.clearTimeout(longPressTimerRef.current), []);
+	const handleOpen = (event) => {
+		context.hasInteractedRef.current = true;
+		setPoint({
+			x: event.clientX,
+			y: event.clientY
+		});
+		context.onOpenChange(true);
+	};
+	React.useEffect(() => clearLongPress, [clearLongPress]);
+	React.useEffect(() => void (disabled && clearLongPress()), [disabled, clearLongPress]);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Anchor, {
+		...menuScope,
+		virtualRef
+	}), /* @__PURE__ */ jsx(Primitive.span, {
+		"data-state": context.open ? "open" : "closed",
+		"data-disabled": disabled ? "" : void 0,
+		...triggerProps,
+		ref: forwardedRef,
+		style: {
+			WebkitTouchCallout: "none",
+			...props.style
+		},
+		onContextMenu: disabled ? props.onContextMenu : composeEventHandlers(props.onContextMenu, (event) => {
+			clearLongPress();
+			handleOpen(event);
+			event.preventDefault();
+		}),
+		onPointerDown: disabled ? props.onPointerDown : composeEventHandlers(props.onPointerDown, whenTouchOrPen((event) => {
+			clearLongPress();
+			if (context.open) context.onOpenChange(false);
+			longPressTimerRef.current = window.setTimeout(() => handleOpen(event), 700);
+		})),
+		onPointerMove: disabled ? props.onPointerMove : composeEventHandlers(props.onPointerMove, whenTouchOrPen(clearLongPress)),
+		onPointerCancel: disabled ? props.onPointerCancel : composeEventHandlers(props.onPointerCancel, whenTouchOrPen(clearLongPress)),
+		onPointerUp: disabled ? props.onPointerUp : composeEventHandlers(props.onPointerUp, whenTouchOrPen(clearLongPress))
+	})] });
+});
+var ContextMenuPortal = (props) => {
+	const { __scopeContextMenu, ...portalProps } = props;
+	const menuScope = useMenuScope(__scopeContextMenu);
+	return /* @__PURE__ */ jsx(Portal$1, {
+		...menuScope,
+		...portalProps
+	});
+};
+var CONTENT_NAME = "ContextMenuContent";
+var ContextMenuContent = /* @__PURE__ */ React.forwardRef(function ContextMenuContent(props, forwardedRef) {
+	const { __scopeContextMenu, ...contentProps } = props;
+	const context = useContextMenuContext(CONTENT_NAME, __scopeContextMenu);
+	const menuScope = useMenuScope(__scopeContextMenu);
+	const hasInteractedOutsideRef = React.useRef(false);
+	return /* @__PURE__ */ jsx(Content$1, {
+		...menuScope,
+		...contentProps,
+		ref: forwardedRef,
+		side: "right",
+		sideOffset: 2,
+		align: "start",
+		onCloseAutoFocus: (event) => {
+			props.onCloseAutoFocus?.(event);
+			if (!event.defaultPrevented && hasInteractedOutsideRef.current) event.preventDefault();
+			hasInteractedOutsideRef.current = false;
+		},
+		onInteractOutside: (event) => {
+			props.onInteractOutside?.(event);
+			if (!event.defaultPrevented && !context.modal) hasInteractedOutsideRef.current = true;
+		},
+		style: {
+			...props.style,
+			"--radix-context-menu-content-transform-origin": "var(--radix-popper-transform-origin)",
+			"--radix-context-menu-content-available-width": "var(--radix-popper-available-width)",
+			"--radix-context-menu-content-available-height": "var(--radix-popper-available-height)",
+			"--radix-context-menu-trigger-width": "var(--radix-popper-anchor-width)",
+			"--radix-context-menu-trigger-height": "var(--radix-popper-anchor-height)"
+		}
+	});
+});
+var ContextMenuGroup = /* @__PURE__ */ React.forwardRef(function ContextMenuGroup(props, forwardedRef) {
+	const { __scopeContextMenu, ...groupProps } = props;
+	const menuScope = useMenuScope(__scopeContextMenu);
+	return /* @__PURE__ */ jsx(Group$1, {
+		...menuScope,
+		...groupProps,
+		ref: forwardedRef
+	});
+});
+var ContextMenuLabel = /* @__PURE__ */ React.forwardRef(function ContextMenuLabel(props, forwardedRef) {
+	const { __scopeContextMenu, ...labelProps } = props;
+	const menuScope = useMenuScope(__scopeContextMenu);
+	return /* @__PURE__ */ jsx(Label$1, {
+		...menuScope,
+		...labelProps,
+		ref: forwardedRef
+	});
+});
+var ContextMenuItem = /* @__PURE__ */ React.forwardRef(function ContextMenuItem(props, forwardedRef) {
+	const { __scopeContextMenu, ...itemProps } = props;
+	const menuScope = useMenuScope(__scopeContextMenu);
+	return /* @__PURE__ */ jsx(Item$1, {
+		...menuScope,
+		...itemProps,
+		ref: forwardedRef
+	});
+});
+var ContextMenuCheckboxItem = /* @__PURE__ */ React.forwardRef(function ContextMenuCheckboxItem(props, forwardedRef) {
+	const { __scopeContextMenu, ...checkboxItemProps } = props;
+	const menuScope = useMenuScope(__scopeContextMenu);
+	return /* @__PURE__ */ jsx(CheckboxItem$1, {
+		...menuScope,
+		...checkboxItemProps,
+		ref: forwardedRef
+	});
+});
+var ContextMenuRadioGroup = /* @__PURE__ */ React.forwardRef(function ContextMenuRadioGroup(props, forwardedRef) {
+	const { __scopeContextMenu, ...radioGroupProps } = props;
+	const menuScope = useMenuScope(__scopeContextMenu);
+	return /* @__PURE__ */ jsx(RadioGroup$1, {
+		...menuScope,
+		...radioGroupProps,
+		ref: forwardedRef
+	});
+});
+var ContextMenuRadioItem = /* @__PURE__ */ React.forwardRef(function ContextMenuRadioItem(props, forwardedRef) {
+	const { __scopeContextMenu, ...radioItemProps } = props;
+	const menuScope = useMenuScope(__scopeContextMenu);
+	return /* @__PURE__ */ jsx(RadioItem$1, {
+		...menuScope,
+		...radioItemProps,
+		ref: forwardedRef
+	});
+});
+var ContextMenuItemIndicator = /* @__PURE__ */ React.forwardRef(function ContextMenuItemIndicator(props, forwardedRef) {
+	const { __scopeContextMenu, ...itemIndicatorProps } = props;
+	const menuScope = useMenuScope(__scopeContextMenu);
+	return /* @__PURE__ */ jsx(ItemIndicator$1, {
+		...menuScope,
+		...itemIndicatorProps,
+		ref: forwardedRef
+	});
+});
+var ContextMenuSeparator = /* @__PURE__ */ React.forwardRef(function ContextMenuSeparator(props, forwardedRef) {
+	const { __scopeContextMenu, ...separatorProps } = props;
+	const menuScope = useMenuScope(__scopeContextMenu);
+	return /* @__PURE__ */ jsx(Separator$1, {
+		...menuScope,
+		...separatorProps,
+		ref: forwardedRef
+	});
+});
+var SUB_NAME = "ContextMenuSub";
+var ContextMenuSub = (props) => {
+	const { __scopeContextMenu, children, onOpenChange, open: openProp, defaultOpen } = props;
+	const menuScope = useMenuScope(__scopeContextMenu);
+	const [open, setOpen] = useControllableState({
+		prop: openProp,
+		defaultProp: defaultOpen ?? false,
+		onChange: onOpenChange,
+		caller: SUB_NAME
+	});
+	return /* @__PURE__ */ jsx(Sub$1, {
+		...menuScope,
+		open,
+		onOpenChange: setOpen,
+		children
+	});
+};
+var ContextMenuSubTrigger = /* @__PURE__ */ React.forwardRef(function ContextMenuSubTrigger(props, forwardedRef) {
+	const { __scopeContextMenu, ...triggerItemProps } = props;
+	const menuScope = useMenuScope(__scopeContextMenu);
+	return /* @__PURE__ */ jsx(SubTrigger$1, {
+		...menuScope,
+		...triggerItemProps,
+		ref: forwardedRef
+	});
+});
+var ContextMenuSubContent = /* @__PURE__ */ React.forwardRef(function ContextMenuSubContent(props, forwardedRef) {
+	const { __scopeContextMenu, ...subContentProps } = props;
+	const menuScope = useMenuScope(__scopeContextMenu);
+	return /* @__PURE__ */ jsx(SubContent$1, {
+		...menuScope,
+		...subContentProps,
+		ref: forwardedRef,
+		style: {
+			...props.style,
+			"--radix-context-menu-content-transform-origin": "var(--radix-popper-transform-origin)",
+			"--radix-context-menu-content-available-width": "var(--radix-popper-available-width)",
+			"--radix-context-menu-content-available-height": "var(--radix-popper-available-height)",
+			"--radix-context-menu-trigger-width": "var(--radix-popper-anchor-width)",
+			"--radix-context-menu-trigger-height": "var(--radix-popper-anchor-height)"
+		}
+	});
+});
+function whenTouchOrPen(handler) {
+	return (event) => event.pointerType !== "mouse" ? handler(event) : void 0;
+}
+var Root = ContextMenu;
+var Trigger = ContextMenuTrigger;
+var Portal = ContextMenuPortal;
+var Content = ContextMenuContent;
+var Group = ContextMenuGroup;
+var Label = ContextMenuLabel;
+var Item = ContextMenuItem;
+var CheckboxItem = ContextMenuCheckboxItem;
+var RadioGroup = ContextMenuRadioGroup;
+var RadioItem = ContextMenuRadioItem;
+var ItemIndicator = ContextMenuItemIndicator;
+var Separator = ContextMenuSeparator;
+var Sub = ContextMenuSub;
+var SubTrigger = ContextMenuSubTrigger;
+var SubContent = ContextMenuSubContent;
+//#endregion
+export { CheckboxItem, Content, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuItemIndicator, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, Group, Item, ItemIndicator, Label, Portal, RadioGroup, RadioItem, Root, Separator, Sub, SubContent, SubTrigger, Trigger };
+
+//# sourceMappingURL=context-menu.js.map