@hyperfixi/behaviors 2.0.0 → 2.2.0

package/src/index.ts

@@ -71,6 +71,43 @@ export {
   default as Resizable,
 } from './behaviors/resizable';
 
+export {
+  clipboardSource,
+  clipboardMetadata,
+  registerClipboard,
+  default as Clipboard,
+} from './behaviors/clipboard';
+
+export {
+  autoDismissSource,
+  autoDismissMetadata,
+  registerAutoDismiss,
+  default as AutoDismiss,
+} from './behaviors/autodismiss';
+
+export {
+  clickOutsideSource,
+  clickOutsideMetadata,
+  registerClickOutside,
+  default as ClickOutside,
+} from './behaviors/clickoutside';
+
+export {
+  focusTrapSource,
+  focusTrapMetadata,
+  registerFocusTrap,
+  default as FocusTrap,
+} from './behaviors/focustrap';
+
+export {
+  scrollRevealSource,
+  scrollRevealMetadata,
+  registerScrollReveal,
+  default as ScrollReveal,
+} from './behaviors/scrollreveal';
+
+export { tabsSource, tabsMetadata, registerTabs, default as Tabs } from './behaviors/tabs';
+
 // =============================================================================
 // Types
 // =============================================================================
@@ -157,7 +194,15 @@ import { registerRemovable } from './behaviors/removable';
 import { registerToggleable } from './behaviors/toggleable';
 import { registerSortable } from './behaviors/sortable';
 import { registerResizable } from './behaviors/resizable';
-import type { LokaScriptInstance, LokaScriptWindow } from './schemas/types';
+import { registerClipboard } from './behaviors/clipboard';
+import { registerAutoDismiss } from './behaviors/autodismiss';
+import { registerClickOutside } from './behaviors/clickoutside';
+import { registerFocusTrap } from './behaviors/focustrap';
+import { registerScrollReveal } from './behaviors/scrollreveal';
+import { registerTabs } from './behaviors/tabs';
+import type { LokaScriptInstance } from './schemas/types';
+import { resolveRuntime } from './schemas/types';
+import type { LokaScriptWindow } from './schemas/types';
 
 /**
  * Register all behaviors with HyperFixi.
@@ -178,6 +223,12 @@ export async function registerAll(hyperfixi?: LokaScriptInstance): Promise<void>
     registerToggleable(hyperfixi),
     registerSortable(hyperfixi),
     registerResizable(hyperfixi),
+    registerClipboard(hyperfixi),
+    registerAutoDismiss(hyperfixi),
+    registerClickOutside(hyperfixi),
+    registerFocusTrap(hyperfixi),
+    registerScrollReveal(hyperfixi),
+    registerTabs(hyperfixi),
   ]);
 }
 
@@ -192,28 +243,29 @@ export async function registerAll(hyperfixi?: LokaScriptInstance): Promise<void>
 export let ready: Promise<void> | null = null;
 
 // Auto-register all behaviors when loaded in browser with hyperfixi available
-if (typeof window !== 'undefined' && (window as unknown as LokaScriptWindow).lokascript) {
+const _runtime = resolveRuntime();
+if (_runtime) {
   const lsWin = window as unknown as LokaScriptWindow;
-  ready = registerAll();
+  ready = registerAll(_runtime);
 
-  lsWin.__lokascript_behaviors_ready = ready;
+  lsWin.__hyperfixi_behaviors_ready = ready;
 
   ready
     .then(() => {
-      const hyperfixi = lsWin.lokascript as LokaScriptInstance & {
+      const hf = _runtime as LokaScriptInstance & {
         attributeProcessor?: { scanAndProcessAll: () => Promise<void> };
         processNode?: (node: Document) => void;
       };
-      const savedPromise = lsWin.__lokascript_behaviors_ready;
-      delete lsWin.__lokascript_behaviors_ready;
+      const savedPromise = lsWin.__hyperfixi_behaviors_ready;
+      delete lsWin.__hyperfixi_behaviors_ready;
 
-      if (hyperfixi.attributeProcessor?.scanAndProcessAll) {
-        hyperfixi.attributeProcessor.scanAndProcessAll().finally(() => {
-          lsWin.__lokascript_behaviors_ready = savedPromise;
+      if (hf.attributeProcessor?.scanAndProcessAll) {
+        hf.attributeProcessor.scanAndProcessAll().finally(() => {
+          lsWin.__hyperfixi_behaviors_ready = savedPromise;
         });
-      } else if (hyperfixi.processNode) {
-        hyperfixi.processNode(document);
-        lsWin.__lokascript_behaviors_ready = savedPromise;
+      } else if (hf.processNode) {
+        hf.processNode(document);
+        lsWin.__hyperfixi_behaviors_ready = savedPromise;
       }
     })
     .catch(err => {

package/src/loaders.ts

@@ -23,6 +23,12 @@ import { sortableSchema } from './schemas/sortable.schema';
 import { resizableSchema } from './schemas/resizable.schema';
 import { removableSchema } from './schemas/removable.schema';
 import { toggleableSchema } from './schemas/toggleable.schema';
+import { clipboardSchema } from './schemas/clipboard.schema';
+import { autoDismissSchema } from './schemas/autodismiss.schema';
+import { clickOutsideSchema } from './schemas/clickoutside.schema';
+import { focusTrapSchema } from './schemas/focustrap.schema';
+import { scrollRevealSchema } from './schemas/scrollreveal.schema';
+import { tabsSchema } from './schemas/tabs.schema';
 
 // Register all schemas
 registerSchema(draggableSchema);
@@ -30,6 +36,12 @@ registerSchema(sortableSchema);
 registerSchema(resizableSchema);
 registerSchema(removableSchema);
 registerSchema(toggleableSchema);
+registerSchema(clipboardSchema);
+registerSchema(autoDismissSchema);
+registerSchema(clickOutsideSchema);
+registerSchema(focusTrapSchema);
+registerSchema(scrollRevealSchema);
+registerSchema(tabsSchema);
 
 // Register lazy loaders - behaviors are only loaded when requested
 registerLoader('Draggable', () => import('./behaviors/draggable'));
@@ -37,3 +49,9 @@ registerLoader('Sortable', () => import('./behaviors/sortable'));
 registerLoader('Resizable', () => import('./behaviors/resizable'));
 registerLoader('Removable', () => import('./behaviors/removable'));
 registerLoader('Toggleable', () => import('./behaviors/toggleable'));
+registerLoader('Clipboard', () => import('./behaviors/clipboard'));
+registerLoader('AutoDismiss', () => import('./behaviors/autodismiss'));
+registerLoader('ClickOutside', () => import('./behaviors/clickoutside'));
+registerLoader('FocusTrap', () => import('./behaviors/focustrap'));
+registerLoader('ScrollReveal', () => import('./behaviors/scrollreveal'));
+registerLoader('Tabs', () => import('./behaviors/tabs'));

package/src/registry.test.ts

@@ -175,17 +175,38 @@ describe('registry', () => {
   });
 
   describe('registerWithRuntime', () => {
-    it('should load and call module.register', async () => {
+    it('should load and call module.register (imperative behavior)', async () => {
       const mockInstance = {
         compileSync: vi.fn().mockReturnValue({ ok: true, ast: {} }),
         execute: vi.fn().mockResolvedValue(undefined),
         createContext: vi.fn().mockReturnValue({ locals: new Map(), globals: new Map() }),
       };
 
-      // Load first so module is available
       await loadBehavior('Draggable');
-
       await registerWithRuntime('Draggable', mockInstance);
+
+      // Imperative behaviors use execute with synthetic node, not compileSync
+      expect(mockInstance.execute).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'behavior',
+          name: 'Draggable',
+          imperativeInstaller: expect.any(Function),
+        }),
+        expect.objectContaining({ locals: expect.any(Map), globals: expect.any(Map) })
+      );
+    });
+
+    it('should load and call module.register (compiled behavior)', async () => {
+      const mockInstance = {
+        compileSync: vi.fn().mockReturnValue({ ok: true, ast: {} }),
+        execute: vi.fn().mockResolvedValue(undefined),
+        createContext: vi.fn().mockReturnValue({ locals: new Map(), globals: new Map() }),
+      };
+
+      await loadBehavior('Removable');
+      await registerWithRuntime('Removable', mockInstance);
+
+      // Source-compiled behaviors use compileSync
       expect(mockInstance.compileSync).toHaveBeenCalled();
     });
   });
@@ -200,8 +221,8 @@ describe('registry', () => {
 
       await loadAll();
       await registerAllWithRuntime(mockInstance);
-      // Each behavior calls compileSync once
-      expect(mockInstance.compileSync.mock.calls.length).toBeGreaterThanOrEqual(5);
+      // execute called for each behavior (imperative + compiled)
+      expect(mockInstance.execute.mock.calls.length).toBeGreaterThanOrEqual(10);
     });
   });
 });

package/src/schemas/autodismiss.schema.ts

@@ -0,0 +1,66 @@
+import type { BehaviorSchema } from './types';
+
+/**
+ * AutoDismiss Behavior Schema
+ *
+ * Auto-removes flash messages and toasts after a configurable delay.
+ * Supports pause-on-hover and fade effect.
+ */
+export const autoDismissSchema: BehaviorSchema = {
+  name: 'AutoDismiss',
+  category: 'ui',
+  tier: 'core',
+  version: '1.0.0',
+  description: 'Auto-removes elements after a delay with optional pause-on-hover',
+  parameters: [
+    {
+      name: 'delay',
+      type: 'number',
+      optional: true,
+      default: 5000,
+      description: 'Time in ms before the element is removed',
+    },
+    {
+      name: 'pauseOnHover',
+      type: 'boolean',
+      optional: true,
+      default: true,
+      description: 'Pause the countdown when the mouse hovers over the element',
+    },
+    {
+      name: 'effect',
+      type: 'string',
+      optional: true,
+      default: 'none',
+      enum: ['fade', 'none'],
+      description: 'Transition effect before removal: "fade" or "none"',
+    },
+  ],
+  events: [
+    { name: 'autodismiss:start', description: 'Fired when the countdown timer starts' },
+    {
+      name: 'autodismiss:dismissed',
+      description: 'Fired before removal (cancelable via preventDefault)',
+    },
+    { name: 'autodismiss:paused', description: 'Fired when the timer is paused on hover' },
+    { name: 'autodismiss:resumed', description: 'Fired when the timer resumes on mouseleave' },
+  ],
+  source: [
+    'behavior AutoDismiss(delay, pauseOnHover, effect)',
+    '  init',
+    '    if delay is undefined set delay to 5000',
+    '    if pauseOnHover is undefined set pauseOnHover to true',
+    '    if effect is undefined set effect to "none"',
+    '  end',
+    '  on load',
+    '    trigger autodismiss:start',
+    '    wait delay ms',
+    '    trigger autodismiss:dismissed',
+    '    if effect is "fade"',
+    '      transition opacity to 0 over 300ms',
+    '    end',
+    '    remove me',
+    '  end',
+    'end',
+  ].join('\n'),
+};

package/src/schemas/clickoutside.schema.ts

@@ -0,0 +1,39 @@
+import type { BehaviorSchema } from './types';
+
+/**
+ * ClickOutside Behavior Schema
+ *
+ * Fires an event when the user clicks outside the element.
+ * Uses pointerdown instead of click to avoid timing issues.
+ */
+export const clickOutsideSchema: BehaviorSchema = {
+  name: 'ClickOutside',
+  category: 'ui',
+  tier: 'core',
+  version: '1.0.0',
+  description: 'Fires an event when the user clicks outside the element',
+  parameters: [
+    {
+      name: 'active',
+      type: 'boolean',
+      optional: true,
+      default: true,
+      description: 'Whether the listener is active (can be toggled programmatically)',
+    },
+  ],
+  events: [
+    { name: 'clickoutside', description: 'Fired when a pointer press occurs outside the element' },
+  ],
+  requirements: ['Uses pointerdown instead of click to avoid timing issues with removed elements'],
+  source: `
+behavior ClickOutside(active)
+  init
+    if active is undefined set active to true
+  end
+  on pointerdown from document
+    if active and not me.contains(event.target)
+      trigger clickoutside on me
+    end
+  end
+end`.trim(),
+};

package/src/schemas/clipboard.schema.ts

@@ -0,0 +1,72 @@
+import type { BehaviorSchema } from './types';
+
+/**
+ * Clipboard Behavior Schema
+ *
+ * Copies text to clipboard on click with visual feedback.
+ * Uses the Clipboard API with execCommand fallback.
+ */
+export const clipboardSchema: BehaviorSchema = {
+  name: 'Clipboard',
+  category: 'ui',
+  tier: 'core',
+  version: '1.0.0',
+  description: 'Copies text to clipboard on click with visual feedback',
+  parameters: [
+    {
+      name: 'text',
+      type: 'string',
+      optional: true,
+      description: 'Literal text to copy (takes priority over source)',
+    },
+    {
+      name: 'source',
+      type: 'selector',
+      optional: true,
+      default: 'me',
+      description: 'Element whose textContent or value is copied',
+    },
+    {
+      name: 'feedback',
+      type: 'selector',
+      optional: true,
+      description: 'Element to show .copied feedback on (defaults to the installed element)',
+    },
+    {
+      name: 'feedbackDuration',
+      type: 'number',
+      optional: true,
+      default: 2000,
+      description: 'Duration in ms to show .copied class feedback',
+    },
+  ],
+  events: [
+    { name: 'clipboard:copied', description: 'Fired after text is copied successfully' },
+    { name: 'clipboard:error', description: 'Fired when clipboard write fails' },
+  ],
+  requirements: [
+    'navigator.clipboard.writeText() requires HTTPS or localhost',
+    'Falls back to document.execCommand("copy") for older browsers',
+  ],
+  source: [
+    'behavior Clipboard(text, source, feedback, feedbackDuration)',
+    '  init',
+    '    if feedbackDuration is undefined set feedbackDuration to 2000',
+    '    if source is undefined set source to me',
+    '  end',
+    '  on click',
+    '    if text is not undefined',
+    '      set copyText to text',
+    '    else',
+    "      set copyText to source's value or source's textContent",
+    '    end',
+    '    js(copyText) navigator.clipboard.writeText(copyText) end',
+    '    set feedbackEl to feedback or me',
+    '    add .copied to feedbackEl',
+    '    wait feedbackDuration ms',
+    '    remove .copied from feedbackEl',
+    '    trigger clipboard:copied',
+    '  end',
+    'end',
+  ].join('\n'),
+};

package/src/schemas/focustrap.schema.ts

@@ -0,0 +1,53 @@
+import type { BehaviorSchema } from './types';
+
+/**
+ * FocusTrap Behavior Schema
+ *
+ * Confines Tab navigation inside an element and restores focus on release.
+ * Manages aria-modal for accessibility compliance.
+ */
+export const focusTrapSchema: BehaviorSchema = {
+  name: 'FocusTrap',
+  category: 'ui',
+  tier: 'core',
+  version: '1.0.0',
+  description: 'Confines Tab navigation inside an element with ARIA support',
+  parameters: [
+    {
+      name: 'active',
+      type: 'boolean',
+      optional: true,
+      default: true,
+      description: 'Whether the trap is active on install',
+    },
+    {
+      name: 'initialFocus',
+      type: 'selector',
+      optional: true,
+      description: 'Element to focus when the trap activates',
+    },
+    {
+      name: 'returnFocus',
+      type: 'boolean',
+      optional: true,
+      default: true,
+      description: 'Restore focus to the previously focused element on deactivation',
+    },
+  ],
+  events: [
+    { name: 'focustrap:activated', description: 'Fired when the trap is activated' },
+    { name: 'focustrap:deactivated', description: 'Fired when the trap is deactivated' },
+  ],
+  requirements: [
+    'Sets aria-modal="true" on the element when active',
+    'Listens for focustrap:activate and focustrap:deactivate custom events for programmatic control',
+  ],
+  source: `
+behavior FocusTrap(active, initialFocus, returnFocus)
+  init
+    if active is undefined set active to true
+    if returnFocus is undefined set returnFocus to true
+  end
+  -- Imperative installer handles Tab key trapping and focus management
+end`.trim(),
+};

package/src/schemas/index.ts

@@ -22,6 +22,12 @@ export { sortableSchema } from './sortable.schema';
 export { resizableSchema } from './resizable.schema';
 export { removableSchema } from './removable.schema';
 export { toggleableSchema } from './toggleable.schema';
+export { clipboardSchema } from './clipboard.schema';
+export { autoDismissSchema } from './autodismiss.schema';
+export { clickOutsideSchema } from './clickoutside.schema';
+export { focusTrapSchema } from './focustrap.schema';
+export { scrollRevealSchema } from './scrollreveal.schema';
+export { tabsSchema } from './tabs.schema';
 
 // All schemas as a collection
 import { draggableSchema } from './draggable.schema';
@@ -29,6 +35,12 @@ import { sortableSchema } from './sortable.schema';
 import { resizableSchema } from './resizable.schema';
 import { removableSchema } from './removable.schema';
 import { toggleableSchema } from './toggleable.schema';
+import { clipboardSchema } from './clipboard.schema';
+import { autoDismissSchema } from './autodismiss.schema';
+import { clickOutsideSchema } from './clickoutside.schema';
+import { focusTrapSchema } from './focustrap.schema';
+import { scrollRevealSchema } from './scrollreveal.schema';
+import { tabsSchema } from './tabs.schema';
 import type { BehaviorSchema } from './types';
 
 /**
@@ -40,6 +52,12 @@ export const ALL_SCHEMAS: Record<string, BehaviorSchema> = {
   Resizable: resizableSchema,
   Removable: removableSchema,
   Toggleable: toggleableSchema,
+  Clipboard: clipboardSchema,
+  AutoDismiss: autoDismissSchema,
+  ClickOutside: clickOutsideSchema,
+  FocusTrap: focusTrapSchema,
+  ScrollReveal: scrollRevealSchema,
+  Tabs: tabsSchema,
 };
 
 /**

package/src/schemas/scrollreveal.schema.ts

@@ -0,0 +1,60 @@
+import type { BehaviorSchema } from './types';
+
+/**
+ * ScrollReveal Behavior Schema
+ *
+ * Adds a class or fires events when the element enters or exits the viewport.
+ * Uses the IntersectionObserver web standard API.
+ */
+export const scrollRevealSchema: BehaviorSchema = {
+  name: 'ScrollReveal',
+  category: 'layout',
+  tier: 'common',
+  version: '1.0.0',
+  description: 'Adds a class when the element enters the viewport via IntersectionObserver',
+  parameters: [
+    {
+      name: 'cls',
+      type: 'string',
+      optional: true,
+      default: 'revealed',
+      description: 'CSS class added when element enters viewport',
+    },
+    {
+      name: 'threshold',
+      type: 'number',
+      optional: true,
+      default: 0.1,
+      description: 'Intersection ratio threshold (0-1) for triggering',
+    },
+    {
+      name: 'once',
+      type: 'boolean',
+      optional: true,
+      default: true,
+      description: 'If true, disconnect observer after first intersection',
+    },
+    {
+      name: 'rootMargin',
+      type: 'string',
+      optional: true,
+      default: '0px',
+      description: 'CSS margin around the viewport for triggering earlier or later',
+    },
+  ],
+  events: [
+    { name: 'scrollreveal:enter', description: 'Fired when the element enters the viewport' },
+    { name: 'scrollreveal:exit', description: 'Fired when the element exits the viewport' },
+  ],
+  requirements: ['Uses IntersectionObserver API (supported in all modern browsers)'],
+  source: `
+behavior ScrollReveal(cls, threshold, once, rootMargin)
+  init
+    if cls is undefined set cls to "revealed"
+    if threshold is undefined set threshold to 0.1
+    if once is undefined set once to true
+    if rootMargin is undefined set rootMargin to "0px"
+  end
+  -- Imperative installer handles IntersectionObserver setup
+end`.trim(),
+};

package/src/schemas/tabs.schema.ts

@@ -0,0 +1,66 @@
+import type { BehaviorSchema } from './types';
+
+export const tabsSchema: BehaviorSchema = {
+  name: 'Tabs',
+  category: 'ui',
+  tier: 'core',
+  version: '1.0.0',
+  description:
+    'WAI-ARIA compliant tabs with roving tabindex keyboard navigation. ' +
+    'Auto-wires role, aria-selected, aria-controls, and aria-labelledby attributes.',
+  parameters: [
+    {
+      name: 'orientation',
+      type: 'string',
+      optional: true,
+      default: 'horizontal',
+      enum: ['horizontal', 'vertical'],
+      description: 'Arrow key direction: horizontal (Left/Right) or vertical (Up/Down)',
+    },
+    {
+      name: 'activeTab',
+      type: 'number',
+      optional: true,
+      default: 0,
+      description: 'Initial active tab index (zero-based)',
+    },
+    {
+      name: 'wrap',
+      type: 'boolean',
+      optional: true,
+      default: true,
+      description: 'Wrap to first/last tab when navigating past the end',
+    },
+    {
+      name: 'activeClass',
+      type: 'string',
+      optional: true,
+      default: 'active',
+      description: 'CSS class applied to the active tab and its panel',
+    },
+  ],
+  events: [
+    {
+      name: 'tabs:change',
+      description: 'Fired before tab selection changes (cancelable via preventDefault)',
+    },
+    { name: 'tabs:changed', description: 'Fired after tab selection has changed' },
+  ],
+  requirements: [
+    'Sets role="tablist" on the tab container',
+    'Sets role="tab" on tab buttons and role="tabpanel" on content panels',
+    'Manages aria-selected, aria-controls, aria-labelledby, and tabindex',
+    'Keyboard: Arrow keys navigate, Home/End jump to first/last, Tab exits tablist',
+  ],
+  source: [
+    'behavior Tabs(orientation, activeTab, wrap, activeClass)',
+    '  init',
+    '    if orientation is undefined set orientation to "horizontal"',
+    '    if activeTab is undefined set activeTab to 0',
+    '    if wrap is undefined set wrap to true',
+    '    if activeClass is undefined set activeClass to "active"',
+    '  end',
+    '  -- Imperative installer handles ARIA wiring and keyboard navigation',
+    'end',
+  ].join('\n'),
+};

package/src/schemas/types.ts

@@ -100,8 +100,20 @@ export interface LokaScriptInstance {
 /**
  * Typed window interface for behavior auto-registration.
  * Avoids `(window as any)` casts throughout the codebase.
+ * Checks both `window.lokascript` and `window.hyperfixi` for the runtime instance.
  */
 export interface LokaScriptWindow {
   lokascript?: LokaScriptInstance;
-  __lokascript_behaviors_ready?: Promise<void> | undefined;
+  hyperfixi?: LokaScriptInstance;
+  __hyperfixi_behaviors_ready?: Promise<void> | undefined;
+}
+
+/**
+ * Resolve the LokaScript runtime from window globals.
+ * Checks both `window.lokascript` and `window.hyperfixi`.
+ */
+export function resolveRuntime(): LokaScriptInstance | null {
+  if (typeof window === 'undefined') return null;
+  const win = window as unknown as LokaScriptWindow;
+  return win.lokascript || win.hyperfixi || null;
 }

package/dist/chunk-2NQHIHD5.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/behaviors/removable.ts"],"sourcesContent":["/**\n * Removable Behavior\n *\n * A behavior that removes an element when a trigger is clicked.\n * Supports optional confirmation and transition effects.\n *\n * @example\n * ```html\n * <div _=\"install Removable\">Click to remove</div>\n *\n * <div _=\"install Removable(confirm: true)\">With confirmation</div>\n * ```\n */\n\nimport { removableSchema } from '../schemas/removable.schema';\nimport type { LokaScriptInstance, LokaScriptWindow } from '../schemas/types';\n\n// Re-export schema-derived values for backwards compatibility\nexport const removableSource = removableSchema.source;\nexport const removableMetadata = removableSchema;\n\n/**\n * Register the Removable behavior with LokaScript.\n */\nexport async function registerRemovable(hyperfixi?: LokaScriptInstance): Promise<void> {\n  const hf =\n    hyperfixi ||\n    (typeof window !== 'undefined' ? (window as unknown as LokaScriptWindow).lokascript : null);\n\n  if (!hf) {\n    throw new Error(\n      'LokaScript not found. Make sure @hyperfixi/core is loaded before registering behaviors.'\n    );\n  }\n\n  const result = hf.compileSync(removableSchema.source, { traditional: true });\n\n  if (!result.ok) {\n    throw new Error(`Failed to compile Removable behavior: ${JSON.stringify(result.errors)}`);\n  }\n\n  const ctx = hf.createContext ? hf.createContext() : { locals: new Map(), globals: new Map() };\n  await hf.execute(result.ast, ctx);\n}\n\n// Auto-register when loaded as a script tag\nif (typeof window !== 'undefined' && (window as unknown as LokaScriptWindow).lokascript) {\n  registerRemovable().catch(console.error);\n}\n\nexport default {\n  source: removableSchema.source,\n  metadata: removableSchema,\n  register: registerRemovable,\n};\n"],"mappings":";;;;;AAkBO,IAAM,kBAAkB,gBAAgB;AACxC,IAAM,oBAAoB;AAKjC,eAAsB,kBAAkB,WAA+C;AACrF,QAAM,KACJ,cACC,OAAO,WAAW,cAAe,OAAuC,aAAa;AAExF,MAAI,CAAC,IAAI;AACP,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,QAAM,SAAS,GAAG,YAAY,gBAAgB,QAAQ,EAAE,aAAa,KAAK,CAAC;AAE3E,MAAI,CAAC,OAAO,IAAI;AACd,UAAM,IAAI,MAAM,yCAAyC,KAAK,UAAU,OAAO,MAAM,CAAC,EAAE;AAAA,EAC1F;AAEA,QAAM,MAAM,GAAG,gBAAgB,GAAG,cAAc,IAAI,EAAE,QAAQ,oBAAI,IAAI,GAAG,SAAS,oBAAI,IAAI,EAAE;AAC5F,QAAM,GAAG,QAAQ,OAAO,KAAK,GAAG;AAClC;AAGA,IAAI,OAAO,WAAW,eAAgB,OAAuC,YAAY;AACvF,oBAAkB,EAAE,MAAM,QAAQ,KAAK;AACzC;AAEA,IAAO,oBAAQ;AAAA,EACb,QAAQ,gBAAgB;AAAA,EACxB,UAAU;AAAA,EACV,UAAU;AACZ;","names":[]}

package/dist/chunk-3Q652JQB.js

@@ -1,37 +0,0 @@
-import {
-  toggleableSchema
-} from "./chunk-WUHHMDAA.js";
-
-// src/behaviors/toggleable.ts
-var toggleableSource = toggleableSchema.source;
-var toggleableMetadata = toggleableSchema;
-async function registerToggleable(hyperfixi) {
-  const hf = hyperfixi || (typeof window !== "undefined" ? window.lokascript : null);
-  if (!hf) {
-    throw new Error(
-      "LokaScript not found. Make sure @hyperfixi/core is loaded before registering behaviors."
-    );
-  }
-  const result = hf.compileSync(toggleableSchema.source, { traditional: true });
-  if (!result.ok) {
-    throw new Error(`Failed to compile Toggleable behavior: ${JSON.stringify(result.errors)}`);
-  }
-  const ctx = hf.createContext ? hf.createContext() : { locals: /* @__PURE__ */ new Map(), globals: /* @__PURE__ */ new Map() };
-  await hf.execute(result.ast, ctx);
-}
-if (typeof window !== "undefined" && window.lokascript) {
-  registerToggleable().catch(console.error);
-}
-var toggleable_default = {
-  source: toggleableSchema.source,
-  metadata: toggleableSchema,
-  register: registerToggleable
-};
-
-export {
-  toggleableSource,
-  toggleableMetadata,
-  registerToggleable,
-  toggleable_default
-};
-//# sourceMappingURL=chunk-3Q652JQB.js.map