snice 2.5.4 → 3.2.0

package/dist/method-decorators.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Method decorators for common patterns
+ * @debounce, @throttle, @once, @memoize
+ */
+/**
+ * @debounce decorator - delays function execution until after wait time has elapsed
+ * since the last invocation
+ *
+ * @param wait - Time to wait in milliseconds (default: 300)
+ * @param options - Debounce options
+ * @param options.leading - Invoke on the leading edge (default: false)
+ * @param options.trailing - Invoke on the trailing edge (default: true)
+ * @param options.maxWait - Maximum time to wait before invoking (default: undefined)
+ *
+ * @example
+ * ```typescript
+ * @element('search-input')
+ * class SearchInput extends HTMLElement {
+ *   @debounce(500)
+ *   handleSearch(query: string) {
+ *     // Only called 500ms after last keystroke
+ *     fetch(`/api/search?q=${query}`);
+ *   }
+ * }
+ * ```
+ */
+export declare function debounce(wait?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+}): (originalMethod: any, context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => any;
+/**
+ * @throttle decorator - ensures function is called at most once per specified time period
+ *
+ * @param wait - Time to wait in milliseconds (default: 300)
+ * @param options - Throttle options
+ * @param options.leading - Invoke on the leading edge (default: true)
+ * @param options.trailing - Invoke on the trailing edge (default: true)
+ *
+ * @example
+ * ```typescript
+ * @element('scroll-tracker')
+ * class ScrollTracker extends HTMLElement {
+ *   @throttle(100)
+ *   handleScroll(e: Event) {
+ *     // Called at most once every 100ms
+ *     this.updateScrollPosition();
+ *   }
+ * }
+ * ```
+ */
+export declare function throttle(wait?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+}): (originalMethod: any, context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => void;
+/**
+ * @once decorator - ensures function is only called once
+ * Subsequent calls return the result of the first call
+ *
+ * @param perInstance - If true, function can be called once per instance (default: true)
+ *                      If false, function can only be called once globally across all instances
+ *
+ * @example
+ * ```typescript
+ * @element('data-loader')
+ * class DataLoader extends HTMLElement {
+ *   @once()
+ *   async loadData() {
+ *     // Only loads data once, even if called multiple times
+ *     const data = await fetch('/api/data');
+ *     return data.json();
+ *   }
+ * }
+ * ```
+ */
+export declare function once(perInstance?: boolean): (originalMethod: any, context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => any;
+/**
+ * @memoize decorator - caches function results based on arguments
+ * Uses JSON.stringify for argument comparison by default
+ *
+ * @param options - Memoization options
+ * @param options.keyGenerator - Custom function to generate cache key from arguments
+ * @param options.maxSize - Maximum cache size (default: 100)
+ * @param options.ttl - Time to live in milliseconds (default: undefined - no expiration)
+ *
+ * @example
+ * ```typescript
+ * @element('calculator')
+ * class Calculator extends HTMLElement {
+ *   @memoize({ maxSize: 50 })
+ *   fibonacci(n: number): number {
+ *     // Results are cached, subsequent calls with same n are instant
+ *     if (n <= 1) return n;
+ *     return this.fibonacci(n - 1) + this.fibonacci(n - 2);
+ *   }
+ * }
+ * ```
+ */
+export declare function memoize(options?: {
+    keyGenerator?: (...args: any[]) => string;
+    maxSize?: number;
+    ttl?: number;
+}): (originalMethod: any, context: ClassMethodDecoratorContext) => (this: any, ...args: any[]) => any;
+/**
+ * Clear all debounce timers for an instance
+ * Useful in cleanup/disconnectedCallback
+ */
+export declare function clearDebounceTimers(instance: any): void;
+/**
+ * Clear all throttle timers for an instance
+ * Useful in cleanup/disconnectedCallback
+ */
+export declare function clearThrottleTimers(instance: any): void;
+/**
+ * Clear memoize cache for an instance
+ */
+export declare function clearMemoizeCache(instance: any, methodName?: string): void;
+/**
+ * Reset once-called state for an instance
+ */
+export declare function resetOnce(instance: any, methodName?: string): void;

package/dist/on.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @on decorator for listening to events
+ * Use in elements or controllers to listen to DOM events or custom events
+ */
+import type { OnOptions } from './types/on-options';
+export type { OnOptions } from './types/on-options';
+/**
+ * @on decorator for listening to events
+ *
+ * Works in both elements and controllers with full event delegation support.
+ *
+ * @param eventName - Event name(s) to listen for
+ * @param selector - Optional CSS selector for event delegation
+ * @param options - Event listener options including debounce/throttle
+ *
+ * @example
+ * ```typescript
+ * // In elements
+ * @element('my-button')
+ * class MyButton extends HTMLElement {
+ *   @on('click', 'button')
+ *   handleClick(e: MouseEvent) {
+ *     console.log('Button clicked!', e);
+ *   }
+ *
+ *   @on('input', 'input', { debounce: 300 })
+ *   handleInput(e: Event) {
+ *     console.log('Input changed:', (e.target as HTMLInputElement).value);
+ *   }
+ * }
+ *
+ * // In controllers
+ * @controller('my-controller')
+ * class MyController {
+ *   element!: HTMLElement;
+ *
+ *   @on('count-changed')
+ *   handleCountChanged(e: CustomEvent) {
+ *     console.log('Count changed to:', e.detail.count);
+ *   }
+ *
+ *   @on('click', '.item', { throttle: 100 })
+ *   handleItemClick(e: MouseEvent) {
+ *     console.log('Item clicked');
+ *   }
+ * }
+ * ```
+ */
+export declare function on(eventName: string | string[], selectorOrOptions?: string | OnOptions | null, options?: OnOptions): (originalMethod: any, context: ClassMethodDecoratorContext) => any;
+/**
+ * Setup event listeners for an element or controller instance
+ * Called automatically during element connection or controller attachment
+ */
+export declare function setupEventHandlers(instance: any, targetElement: HTMLElement): void;
+/**
+ * Cleanup event listeners for a controller instance
+ * Called automatically by the controller system during detach
+ */
+export declare function cleanupEventHandlers(instance: any): void;

package/dist/parts.d.ts

@@ -0,0 +1,156 @@
+import { TemplateResult } from './template';
+/**
+ * A prepared template ready for rendering
+ */
+declare class Template {
+    parts: TemplatePart[];
+    element: HTMLTemplateElement;
+    constructor(result: TemplateResult, element: HTMLTemplateElement, attrNamesForParts: string[]);
+}
+interface TemplatePart {
+    type: 'node' | 'attribute' | 'property' | 'boolean-attribute' | 'event' | 'conditional-if' | 'conditional-case';
+    index: number;
+    name?: string;
+    element?: Element;
+    startNode?: Comment;
+    endNode?: Comment;
+    attrStrings?: string[];
+}
+/**
+ * Instance of a rendered template
+ */
+export declare class TemplateInstance {
+    template: Template;
+    parts: Part[];
+    fragment: DocumentFragment | null;
+    private conditionalParts;
+    private regularParts;
+    constructor(result: TemplateResult);
+    renderFragment(): DocumentFragment;
+    render(values: readonly any[]): DocumentFragment;
+    update(values: readonly any[]): void;
+    clear(): void;
+}
+/**
+ * Base class for all parts
+ */
+export declare abstract class Part {
+    abstract commit(value: any): void;
+    abstract clear(): void;
+}
+/**
+ * NodePart handles text content and nested templates
+ */
+export declare class NodePart extends Part {
+    private startNode;
+    private endNode;
+    private value;
+    constructor(startNode: Comment, endNode: Comment);
+    commit(value: any): void;
+    private commitPrimitive;
+    private commitTemplate;
+    private commitArray;
+    private commitUnsafeHTML;
+    private insertBefore;
+    clear(): void;
+}
+/**
+ * AttributePart handles regular attribute updates
+ */
+export declare class AttributePart extends Part {
+    readonly element: Element;
+    readonly name: string;
+    readonly attrStrings?: string[];
+    private value;
+    constructor(element: Element, name: string, attrStrings?: string[]);
+    commit(value: any): void;
+    clear(): void;
+}
+/**
+ * PropertyPart handles property bindings
+ */
+export declare class PropertyPart extends Part {
+    readonly element: Element;
+    readonly name: string;
+    private value;
+    constructor(element: Element, name: string);
+    commit(value: any): void;
+    clear(): void;
+}
+/**
+ * BooleanAttributePart handles boolean attributes
+ */
+export declare class BooleanAttributePart extends Part {
+    readonly element: Element;
+    readonly name: string;
+    private value;
+    constructor(element: Element, name: string);
+    commit(value: any): void;
+    clear(): void;
+}
+/**
+ * EventPart handles event listener bindings with keyboard shortcut support
+ */
+export declare class EventPart extends Part {
+    readonly element: Element;
+    readonly eventName: string;
+    private listener;
+    private value;
+    private keyFilter;
+    private host;
+    constructor(element: Element, eventName: string);
+    commit(value: any): void;
+    clear(): void;
+}
+/**
+ * Keyboard filter for matching specific keys and modifiers
+ */
+export interface KeyboardFilter {
+    key: string;
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+    anyModifiers?: boolean;
+}
+/**
+ * Parse keyboard shortcut specification
+ * Examples:
+ *   "enter" -> { key: "Enter" }
+ *   "ctrl+s" -> { key: "s", ctrl: true }
+ *   "ctrl+shift+s" -> { key: "s", ctrl: true, shift: true }
+ *   "~enter" -> { key: "Enter", anyModifiers: true }
+ */
+export declare function parseKeyboardFilter(spec: string): KeyboardFilter;
+/**
+ * Check if keyboard event matches the filter
+ */
+export declare function matchesKeyboardFilter(event: KeyboardEvent, filter: KeyboardFilter): boolean;
+/**
+ * ConditionalIfPart handles <if> conditional rendering
+ * Removes/inserts DOM nodes based on condition
+ */
+export declare class ConditionalIfPart extends Part {
+    private ifElement;
+    private value;
+    private fragment;
+    constructor(ifElement: Element);
+    commit(value: any): void;
+    clear(): void;
+}
+/**
+ * ConditionalCasePart handles <case>/<when>/<default> conditional rendering
+ * Removes/inserts matching branch based on value
+ */
+export declare class ConditionalCasePart extends Part {
+    private caseElement;
+    private value;
+    private childrenMap;
+    private fragments;
+    private defaultChild;
+    private currentChild;
+    constructor(caseElement: Element);
+    commit(value: any): void;
+    clear(): void;
+}
+export {};

package/dist/render-debug.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Render debugging utilities for Snice v3.0.0
+ * For testing and debugging only - not recommended for production use
+ */
+/**
+ * Track renders of an element using an async generator
+ * Each call to tracker.next() waits for the next render to complete
+ *
+ * @example
+ * ```typescript
+ * const tracker = trackRenders(element);
+ *
+ * element.someProp = 'new value';
+ * await tracker.next(); // Waits for render
+ * // DOM is now updated
+ *
+ * element.someProp = 'another value';
+ * await tracker.next(); // Waits for next render
+ * // DOM is updated again
+ * ```
+ *
+ * WARNING: For testing/debugging only!
+ * - Do not use in production code
+ * - The generator yields indefinitely - use it only in controlled test environments
+ * - Each yield waits for the next render event
+ */
+export declare function trackRenders(element: HTMLElement): AsyncGenerator<void, void, unknown>;

package/dist/render-tracker.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Render tracking for testing/debugging
+ * Uses symbols and generators to "pull" render events from elements
+ */
+export declare const RENDER_TRACKER: unique symbol;
+export declare const TRACK_RENDERS: unique symbol;
+/**
+ * Generator that yields after each render of an element
+ * Usage in tests:
+ *   const tracker = trackRenders(element);
+ *   element.someProp = 'value';
+ *   await tracker.next(); // waits for next render
+ */
+export declare function trackRenders(element: HTMLElement): AsyncGenerator<void, void, unknown>;

package/dist/render.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @render and @styles decorators for Snice v3.0.0
+ * Provides automatic differential rendering on property changes
+ */
+/**
+ * Options for @render decorator
+ */
+export interface RenderOptions {
+    /**
+     * Debounce render calls (ms)
+     * Delays rendering until after this many ms of inactivity
+     */
+    debounce?: number;
+    /**
+     * Throttle render calls (ms)
+     * Limits rendering to once per this many ms
+     */
+    throttle?: number;
+    /**
+     * Render only once, disable auto-rendering
+     * Component must call render() method manually to re-render
+     */
+    once?: boolean;
+    /**
+     * Synchronous rendering (skip microtask batching)
+     * Renders immediately instead of batching multiple property changes
+     */
+    sync?: boolean;
+    /**
+     * Disable differential rendering
+     * When false, clears shadow root and re-renders from scratch each time
+     * Still honors <if> and <switch>/<case> meta elements
+     */
+    differential?: boolean;
+}
+/**
+ * Request a render for an element
+ * Respects debounce/throttle/once/sync options
+ * @param immediate - Force immediate render (used for initial render)
+ */
+export declare function requestRender(element: HTMLElement, immediate?: boolean): void;
+/**
+ * @render decorator for component rendering
+ *
+ * Marks a method as the render method for the component.
+ * The method should return html`...` template.
+ * Automatically re-renders when properties change (unless once: true).
+ *
+ * @example
+ * ```typescript
+ * @render()
+ * renderContent() {
+ *   return html`<div>${this.count}</div>`;
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Debounced rendering
+ * @render({ debounce: 100 })
+ * renderContent() {
+ *   return html`<div>${this.searchTerm}</div>`;
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Render only once (manual re-renders only)
+ * @render({ once: true })
+ * renderContent() {
+ *   return html`<div>Static content</div>`;
+ * }
+ * ```
+ */
+export declare function render(options?: RenderOptions): (originalMethod: any, context: ClassMethodDecoratorContext) => (this: HTMLElement, ...args: any[]) => any;
+/**
+ * @styles decorator for component styles
+ *
+ * Marks a method as the styles method for the component.
+ * The method should return css`...` template.
+ * Styles are applied once when the component is connected.
+ *
+ * @example
+ * ```typescript
+ * @styles()
+ * styles() {
+ *   return css`:host { display: block; }`;
+ * }
+ * ```
+ */
+export declare function styles(): (originalMethod: any, context: ClassMethodDecoratorContext) => any;
+/**
+ * Apply styles to an element
+ * Called during element initialization
+ */
+export declare function applyStyles(element: HTMLElement): void;

package/dist/symbols.cjs

@@ -0,0 +1,163 @@
+/*!
+ * snice v3.1.0
+ * Imperative TypeScript framework for building vanilla web components with decorators, differential rendering, routing, and controllers. No virtual DOM, no build complexity.
+ * (c) 2024
+ * Released under the MIT License.
+ */
+'use strict';
+
+// Global namespace for Snice framework
+// Ensures all registries and symbols are shared across different JS files/modules
+// Initialize or get the global Snice namespace
+function initGlobalNamespace() {
+    if (!globalThis.snice) {
+        globalThis.snice = {
+            controllerRegistry: new Map(),
+            controllerIdCounter: 0,
+            symbols: new Map()
+        };
+    }
+    return globalThis.snice;
+}
+// Export the global namespace
+const snice = initGlobalNamespace();
+// Helper function to get or create a global symbol
+function getSymbol(name) {
+    if (!snice.symbols.has(name)) {
+        snice.symbols.set(name, Symbol(name));
+    }
+    return snice.symbols.get(name);
+}
+
+// Central file for all symbols used in the framework
+// All symbols are stored globally to ensure consistency across modules
+const IS_CONTROLLER_CLASS = getSymbol('is-controller-class');
+const IS_CONTROLLER_INSTANCE = getSymbol('is-controller-instance');
+const IS_ELEMENT_CLASS = getSymbol('is-element-class');
+const CHANNEL_HANDLERS = getSymbol('channel-handlers');
+// Internal element state symbols
+const READY_PROMISE = getSymbol('ready-promise');
+const READY_RESOLVE = getSymbol('ready-resolve');
+const RENDERED_PROMISE = getSymbol('rendered-promise');
+const RENDERED_RESOLVE = getSymbol('rendered-resolve');
+const CONTROLLER = getSymbol('controller');
+const INITIALIZED = getSymbol('initialized');
+// Event handler symbols
+const ON_HANDLERS = getSymbol('on-handlers');
+// Controller symbols
+const CONTROLLER_KEY = getSymbol('controller-key');
+const CONTROLLER_NAME_KEY = getSymbol('controller-name');
+const CONTROLLER_ID = getSymbol('controller-id');
+const CONTROLLER_OPERATIONS = getSymbol('controller-operations');
+const NATIVE_CONTROLLER = getSymbol('native-controller');
+// Cleanup symbol - holds an object with all cleanup arrays
+const CLEANUP = getSymbol('cleanup');
+// Property symbols
+const PROPERTIES = getSymbol('properties');
+const PROPERTY_VALUES = getSymbol('property-values');
+const PRE_INIT_PROPERTY_VALUES = getSymbol('pre-init-property-values');
+const PROPERTIES_INITIALIZED = getSymbol('properties-initialized');
+const PROPERTY_WATCHERS = getSymbol('property-watchers');
+const EXPLICITLY_SET_PROPERTIES = getSymbol('explicitly-set-properties');
+// Router context symbol
+const ROUTER_CONTEXT = getSymbol('router-context');
+const CURRENT_PAGE_MARKER = getSymbol('current-page-marker');
+const CONTEXT_REQUEST_HANDLER = getSymbol('context-request-handler');
+const PAGE_TRANSITION = getSymbol('page-transition');
+const CREATED_AT = getSymbol('created-at');
+// Lifecycle symbols
+const READY_HANDLERS = getSymbol('ready-handlers');
+const DISPOSE_HANDLERS = getSymbol('dispose-handlers');
+const MOVED_HANDLERS = getSymbol('moved-handlers');
+const ADOPTED_HANDLERS = getSymbol('adopted-handlers');
+// Observer symbols
+const OBSERVERS = getSymbol('observers');
+// Part symbols
+const PARTS = getSymbol('parts');
+const PART_TIMERS = getSymbol('part-timers');
+// Lifecycle callback timers
+const MOVED_TIMERS = getSymbol('moved-timers');
+const ADOPTED_TIMERS = getSymbol('adopted-timers');
+// Dispatch timing symbols
+const DISPATCH_TIMERS = getSymbol('dispatch-timers');
+// Render symbols (v3.0.0)
+const RENDER_METHOD = getSymbol('render-method');
+const RENDER_OPTIONS = getSymbol('render-options');
+const RENDER_INSTANCE = getSymbol('render-instance');
+const RENDER_SCHEDULED = getSymbol('render-scheduled');
+const RENDER_TIMERS = getSymbol('render-timers');
+const RENDER_CALLBACKS = getSymbol('render-callbacks');
+const STYLES_METHOD = getSymbol('styles-method');
+const STYLES_APPLIED = getSymbol('styles-applied');
+// Navigation context symbols
+const CONTEXT_HANDLER = getSymbol('context-handler');
+const CONTEXT_METHOD_NAME = getSymbol('context-method-name');
+const NAVIGATION_CONTEXT_INSTANCE = getSymbol('navigation-context-instance');
+const REGISTERED_ELEMENTS = getSymbol('registered-elements');
+const IS_UPDATING = getSymbol('is-updating');
+const CONTEXT_REGISTER = getSymbol('context-register');
+const CONTEXT_UNREGISTER = getSymbol('context-unregister');
+const CONTEXT_NOTIFY_ELEMENT = getSymbol('context-notify-element');
+const CONTEXT_OPTIONS = getSymbol('context-options');
+const CONTEXT_TIMER = getSymbol('context-timer');
+const CONTEXT_CALLED = getSymbol('context-called');
+
+exports.ADOPTED_HANDLERS = ADOPTED_HANDLERS;
+exports.ADOPTED_TIMERS = ADOPTED_TIMERS;
+exports.CHANNEL_HANDLERS = CHANNEL_HANDLERS;
+exports.CLEANUP = CLEANUP;
+exports.CONTEXT_CALLED = CONTEXT_CALLED;
+exports.CONTEXT_HANDLER = CONTEXT_HANDLER;
+exports.CONTEXT_METHOD_NAME = CONTEXT_METHOD_NAME;
+exports.CONTEXT_NOTIFY_ELEMENT = CONTEXT_NOTIFY_ELEMENT;
+exports.CONTEXT_OPTIONS = CONTEXT_OPTIONS;
+exports.CONTEXT_REGISTER = CONTEXT_REGISTER;
+exports.CONTEXT_REQUEST_HANDLER = CONTEXT_REQUEST_HANDLER;
+exports.CONTEXT_TIMER = CONTEXT_TIMER;
+exports.CONTEXT_UNREGISTER = CONTEXT_UNREGISTER;
+exports.CONTROLLER = CONTROLLER;
+exports.CONTROLLER_ID = CONTROLLER_ID;
+exports.CONTROLLER_KEY = CONTROLLER_KEY;
+exports.CONTROLLER_NAME_KEY = CONTROLLER_NAME_KEY;
+exports.CONTROLLER_OPERATIONS = CONTROLLER_OPERATIONS;
+exports.CREATED_AT = CREATED_AT;
+exports.CURRENT_PAGE_MARKER = CURRENT_PAGE_MARKER;
+exports.DISPATCH_TIMERS = DISPATCH_TIMERS;
+exports.DISPOSE_HANDLERS = DISPOSE_HANDLERS;
+exports.EXPLICITLY_SET_PROPERTIES = EXPLICITLY_SET_PROPERTIES;
+exports.INITIALIZED = INITIALIZED;
+exports.IS_CONTROLLER_CLASS = IS_CONTROLLER_CLASS;
+exports.IS_CONTROLLER_INSTANCE = IS_CONTROLLER_INSTANCE;
+exports.IS_ELEMENT_CLASS = IS_ELEMENT_CLASS;
+exports.IS_UPDATING = IS_UPDATING;
+exports.MOVED_HANDLERS = MOVED_HANDLERS;
+exports.MOVED_TIMERS = MOVED_TIMERS;
+exports.NATIVE_CONTROLLER = NATIVE_CONTROLLER;
+exports.NAVIGATION_CONTEXT_INSTANCE = NAVIGATION_CONTEXT_INSTANCE;
+exports.OBSERVERS = OBSERVERS;
+exports.ON_HANDLERS = ON_HANDLERS;
+exports.PAGE_TRANSITION = PAGE_TRANSITION;
+exports.PARTS = PARTS;
+exports.PART_TIMERS = PART_TIMERS;
+exports.PRE_INIT_PROPERTY_VALUES = PRE_INIT_PROPERTY_VALUES;
+exports.PROPERTIES = PROPERTIES;
+exports.PROPERTIES_INITIALIZED = PROPERTIES_INITIALIZED;
+exports.PROPERTY_VALUES = PROPERTY_VALUES;
+exports.PROPERTY_WATCHERS = PROPERTY_WATCHERS;
+exports.READY_HANDLERS = READY_HANDLERS;
+exports.READY_PROMISE = READY_PROMISE;
+exports.READY_RESOLVE = READY_RESOLVE;
+exports.REGISTERED_ELEMENTS = REGISTERED_ELEMENTS;
+exports.RENDERED_PROMISE = RENDERED_PROMISE;
+exports.RENDERED_RESOLVE = RENDERED_RESOLVE;
+exports.RENDER_CALLBACKS = RENDER_CALLBACKS;
+exports.RENDER_INSTANCE = RENDER_INSTANCE;
+exports.RENDER_METHOD = RENDER_METHOD;
+exports.RENDER_OPTIONS = RENDER_OPTIONS;
+exports.RENDER_SCHEDULED = RENDER_SCHEDULED;
+exports.RENDER_TIMERS = RENDER_TIMERS;
+exports.ROUTER_CONTEXT = ROUTER_CONTEXT;
+exports.STYLES_APPLIED = STYLES_APPLIED;
+exports.STYLES_METHOD = STYLES_METHOD;
+exports.getSymbol = getSymbol;
+//# sourceMappingURL=symbols.cjs.map

package/dist/symbols.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"symbols.cjs","sources":["../src/global.ts","../src/symbols.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;;;;;;AAAA;AACA;AAKA;AACA,SAAS,mBAAmB,GAAA;AAC1B,IAAA,IAAI,CAAE,UAAkB,CAAC,KAAK,EAAE;QAC7B,UAAkB,CAAC,KAAK,GAAG;YAC1B,kBAAkB,EAAE,IAAI,GAAG,EAAE;AAC7B,YAAA,mBAAmB,EAAE,CAAC;YACtB,OAAO,EAAE,IAAI,GAAG;SACjB;IACH;IACA,OAAQ,UAAkB,CAAC,KAAK;AAClC;AAEA;AACO,MAAM,KAAK,GAAG,mBAAmB,EAAE;AAE1C;AACM,SAAU,SAAS,CAAC,IAAY,EAAA;IACpC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;AAC5B,QAAA,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IACvC;IACA,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAE;AACjC;;AC3BA;AACA;MAMa,mBAAmB,GAAG,SAAS,CAAC,qBAAqB;MACrD,sBAAsB,GAAG,SAAS,CAAC,wBAAwB;MAC3D,gBAAgB,GAAG,SAAS,CAAC,kBAAkB;MAC/C,gBAAgB,GAAG,SAAS,CAAC,kBAAkB;AAE5D;MACa,aAAa,GAAG,SAAS,CAAC,eAAe;MACzC,aAAa,GAAG,SAAS,CAAC,eAAe;MACzC,UAAU,GAAG,SAAS,CAAC,YAAY;MACnC,WAAW,GAAG,SAAS,CAAC,aAAa;AAElD;MACa,WAAW,GAAG,SAAS,CAAC,aAAa;AAElD;MACa,cAAc,GAAG,SAAS,CAAC,gBAAgB;MAC3C,mBAAmB,GAAG,SAAS,CAAC,iBAAiB;MACjD,aAAa,GAAG,SAAS,CAAC,eAAe;MACzC,qBAAqB,GAAG,SAAS,CAAC,uBAAuB;MACzD,iBAAiB,GAAG,SAAS,CAAC,mBAAmB;AAE9D;MACa,OAAO,GAAG,SAAS,CAAC,SAAS;AAE1C;MACa,UAAU,GAAG,SAAS,CAAC,YAAY;MACnC,eAAe,GAAG,SAAS,CAAC,iBAAiB;MAC7C,sBAAsB,GAAG,SAAS,CAAC,wBAAwB;MAC3D,iBAAiB,GAAG,SAAS,CAAC,mBAAmB;MACjD,yBAAyB,GAAG,SAAS,CAAC,2BAA2B;AAE9E;MACa,cAAc,GAAG,SAAS,CAAC,gBAAgB;MAC3C,mBAAmB,GAAG,SAAS,CAAC,qBAAqB;MACrD,uBAAuB,GAAG,SAAS,CAAC,yBAAyB;MAC7D,eAAe,GAAG,SAAS,CAAC,iBAAiB;MAC7C,UAAU,GAAG,SAAS,CAAC,YAAY;AAEhD;MACa,cAAc,GAAG,SAAS,CAAC,gBAAgB;MAC3C,gBAAgB,GAAG,SAAS,CAAC,kBAAkB;MAC/C,cAAc,GAAG,SAAS,CAAC,gBAAgB;MAC3C,gBAAgB,GAAG,SAAS,CAAC,kBAAkB;AAE5D;MACa,SAAS,GAAG,SAAS,CAAC,WAAW;AAE9C;MACa,KAAK,GAAG,SAAS,CAAC,OAAO;MACzB,WAAW,GAAG,SAAS,CAAC,aAAa;AAElD;MACa,YAAY,GAAG,SAAS,CAAC,cAAc;MACvC,cAAc,GAAG,SAAS,CAAC,gBAAgB;AAExD;MACa,eAAe,GAAG,SAAS,CAAC,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"symbols.cjs","sources":["../src/global.ts","../src/symbols.ts"],"sourcesContent":[null,null],"names":[],"mappings":"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"}

package/dist/{types/symbols.d.ts → symbols.d.ts}

@@ -6,6 +6,8 @@ export declare const IS_ELEMENT_CLASS: symbol;
 export declare const CHANNEL_HANDLERS: symbol;
 export declare const READY_PROMISE: symbol;
 export declare const READY_RESOLVE: symbol;
+export declare const RENDERED_PROMISE: symbol;
+export declare const RENDERED_RESOLVE: symbol;
 export declare const CONTROLLER: symbol;
 export declare const INITIALIZED: symbol;
 export declare const ON_HANDLERS: symbol;
@@ -17,6 +19,7 @@ export declare const NATIVE_CONTROLLER: symbol;
 export declare const CLEANUP: symbol;
 export declare const PROPERTIES: symbol;
 export declare const PROPERTY_VALUES: symbol;
+export declare const PRE_INIT_PROPERTY_VALUES: symbol;
 export declare const PROPERTIES_INITIALIZED: symbol;
 export declare const PROPERTY_WATCHERS: symbol;
 export declare const EXPLICITLY_SET_PROPERTIES: symbol;
@@ -35,3 +38,22 @@ export declare const PART_TIMERS: symbol;
 export declare const MOVED_TIMERS: symbol;
 export declare const ADOPTED_TIMERS: symbol;
 export declare const DISPATCH_TIMERS: symbol;
+export declare const RENDER_METHOD: symbol;
+export declare const RENDER_OPTIONS: symbol;
+export declare const RENDER_INSTANCE: symbol;
+export declare const RENDER_SCHEDULED: symbol;
+export declare const RENDER_TIMERS: symbol;
+export declare const RENDER_CALLBACKS: symbol;
+export declare const STYLES_METHOD: symbol;
+export declare const STYLES_APPLIED: symbol;
+export declare const CONTEXT_HANDLER: symbol;
+export declare const CONTEXT_METHOD_NAME: symbol;
+export declare const NAVIGATION_CONTEXT_INSTANCE: symbol;
+export declare const REGISTERED_ELEMENTS: symbol;
+export declare const IS_UPDATING: symbol;
+export declare const CONTEXT_REGISTER: symbol;
+export declare const CONTEXT_UNREGISTER: symbol;
+export declare const CONTEXT_NOTIFY_ELEMENT: symbol;
+export declare const CONTEXT_OPTIONS: symbol;
+export declare const CONTEXT_TIMER: symbol;
+export declare const CONTEXT_CALLED: symbol;