@lushly-dev/fast-element 3.0.1-preview.0 → 3.0.1-preview.2

package/dist/dts/dom-policy.d.ts

@@ -0,0 +1,101 @@
+import { DOMAspect, type DOMSink } from "./dom.js";
+import { type TrustedTypesPolicy } from "./interfaces.js";
+/**
+ * A policy that controls whether values can be written to DOM sinks.
+ * @public
+ */
+export interface DOMPolicy {
+    /**
+     * Creates safe HTML from the provided value.
+     * @param value - The source to convert to safe HTML.
+     */
+    createHTML(value: string): string;
+    /**
+     * Protects a DOM sink that intends to write to the DOM.
+     * @param tagName - The tag name for the element to write to.
+     * @param aspect - The aspect of the DOM to write to.
+     * @param aspectName - The name of the aspect to write to.
+     * @param sink - The sink that is used to write to the DOM.
+     */
+    protect(tagName: string | null, aspect: DOMAspect, aspectName: string, sink: DOMSink): DOMSink;
+}
+/**
+ * A specific DOM sink guard for a node aspect.
+ * @public
+ */
+export type DOMSinkGuards = Record<string, (tagName: string | null, aspect: DOMAspect, aspectName: string, sink: DOMSink) => DOMSink>;
+/**
+ * Aspect-specific guards for a DOM Policy.
+ * @public
+ */
+export type DOMAspectGuards = {
+    /**
+     * Guards for attributes.
+     */
+    [DOMAspect.attribute]?: DOMSinkGuards;
+    /**
+     * Guards for boolean attributes.
+     */
+    [DOMAspect.booleanAttribute]?: DOMSinkGuards;
+    /**
+     * Guards for properties.
+     */
+    [DOMAspect.property]?: DOMSinkGuards;
+    /**
+     * Guards for content.
+     */
+    [DOMAspect.content]?: DOMSinkGuards;
+    /**
+     * Guards for token list manipulation.
+     */
+    [DOMAspect.tokenList]?: DOMSinkGuards;
+    /**
+     * Guards for events.
+     */
+    [DOMAspect.event]?: DOMSinkGuards;
+};
+/**
+ * Element-specific guards for a DOM Policy.
+ * @public
+ */
+export type DOMElementGuards = Record<string, DOMAspectGuards>;
+/**
+ * Guard configuration for a DOM Policy.
+ * @public
+ */
+export type DOMGuards = {
+    /**
+     * Guards for specific elements.
+     */
+    elements: DOMElementGuards;
+    /**
+     * General aspect guards independent of the element type.
+     */
+    aspects: DOMAspectGuards;
+};
+/**
+ * Options for creating a DOM Policy.
+ * @public
+ */
+export type DOMPolicyOptions = {
+    /**
+     * The trusted type to use for HTML creation.
+     */
+    trustedType?: TrustedTypesPolicy;
+    /**
+     * The DOM guards used to override or extend the defaults.
+     */
+    guards?: Partial<DOMGuards>;
+};
+/**
+ * A helper for creating DOM policies.
+ * @public
+ */
+export declare const DOMPolicy: Readonly<{
+    /**
+     * Creates a new DOM Policy object.
+     * @param options - The options to use in creating the policy.
+     * @returns The newly created DOMPolicy.
+     */
+    create(options?: DOMPolicyOptions): Readonly<DOMPolicy>;
+}>;

package/dist/dts/dom.d.ts

@@ -0,0 +1,88 @@
+import type { DOMPolicy as DOMPolicyDefinition } from "./dom-policy.js";
+/**
+ * The type of HTML aspect to target.
+ * @public
+ */
+export declare const DOMAspect: Readonly<{
+    /**
+     * Not aspected.
+     */
+    readonly none: 0;
+    /**
+     * An attribute.
+     */
+    readonly attribute: 1;
+    /**
+     * A boolean attribute.
+     */
+    readonly booleanAttribute: 2;
+    /**
+     * A property.
+     */
+    readonly property: 3;
+    /**
+     * Content
+     */
+    readonly content: 4;
+    /**
+     * A token list.
+     */
+    readonly tokenList: 5;
+    /**
+     * An event.
+     */
+    readonly event: 6;
+}>;
+/**
+ * The type of HTML aspect to target.
+ * @public
+ */
+export type DOMAspect = (typeof DOMAspect)[Exclude<keyof typeof DOMAspect, "none">];
+/**
+ * A function used to send values to a DOM sink.
+ * @public
+ */
+export type DOMSink = (target: Node, aspectName: string, value: any, ...args: any[]) => void;
+/**
+ * A security policy that FAST can use to interact with the DOM.
+ * @public
+ */
+export interface DOMPolicy extends DOMPolicyDefinition {
+}
+/**
+ * Common DOM APIs.
+ * @public
+ */
+export declare const DOM: Readonly<{
+    /**
+     * Gets the dom policy used by the templating system.
+     */
+    readonly policy: DOMPolicyDefinition;
+    /**
+     * Sets the dom policy used by the templating system.
+     * @param policy - The policy to set.
+     * @remarks
+     * This API can only be called once, for security reasons. It should be
+     * called by the application developer at the start of their program.
+     */
+    setPolicy(value: DOMPolicyDefinition): void;
+    /**
+     * Sets an attribute value on an element.
+     * @param element - The element to set the attribute value on.
+     * @param attributeName - The attribute name to set.
+     * @param value - The value of the attribute to set.
+     * @remarks
+     * If the value is `null` or `undefined`, the attribute is removed, otherwise
+     * it is set to the provided value using the standard `setAttribute` API.
+     */
+    setAttribute(element: HTMLElement, attributeName: string, value: any): void;
+    /**
+     * Sets a boolean attribute value.
+     * @param element - The element to set the boolean attribute value on.
+     * @param attributeName - The attribute name to set.
+     * @param value - The value of the attribute to set.
+     * @remarks
+     * If the value is true, the attribute is added; otherwise it is removed.
+     */
+    setBooleanAttribute(element: HTMLElement, attributeName: string, value: boolean): void;
+}>;

package/dist/dts/hydration/diagnostics.d.ts

@@ -0,0 +1,93 @@
+import type { ViewBehaviorFactory } from "../templating/html-directive.js";
+/**
+ * Structured description of the binding hydration was expecting to apply when
+ * a mismatch is detected.
+ * @public
+ */
+export interface HydrationMismatchExpectation {
+    /**
+     * The tag name of the element the binding was expecting (e.g. `"SPAN"`),
+     * or `null` when the binding does not target a specific element (host or
+     * template-level bindings).
+     */
+    tagName: string | null;
+    /**
+     * Human-readable description of the binding aspect, for example
+     * `"content"`, `"property className"`, or `"attribute aria-label"`.
+     */
+    aspect: string;
+}
+/**
+ * Structured description of the DOM hydration actually encountered at the
+ * mismatch point.
+ * @public
+ */
+export interface HydrationMismatchActual {
+    /**
+     * Serialized HTML snippet of the server-rendered DOM where the mismatch
+     * was detected. Truncated with an ellipsis when long.
+     */
+    html: string;
+}
+/**
+ * Result of a hydration-mismatch diagnostic format call.
+ * @public
+ */
+export interface HydrationDiagnosticResult {
+    /**
+     * The error message to attach to the thrown hydration error.
+     */
+    message: string;
+    /**
+     * Structured description of the binding the hydration walk was
+     * attempting to apply. The default diagnostic leaves this `undefined`;
+     * install `hydrationDebugger()` to populate it.
+     */
+    expected?: HydrationMismatchExpectation | string;
+    /**
+     * Structured description of the server-rendered DOM that was
+     * encountered at the mismatch point. The default diagnostic leaves
+     * this `undefined`; install `hydrationDebugger()` to populate it.
+     */
+    received?: HydrationMismatchActual;
+}
+/**
+ * Pluggable formatter for hydration mismatch errors. The default
+ * implementation is a minimal one-line message; install
+ * {@link hydrationDebugger} to swap in the rich "Expected … / Received …"
+ * formatter with an HTML snippet of the SSR DOM.
+ * @public
+ */
+export interface HydrationDiagnostic {
+    /**
+     * Format a binding-resolution mismatch (a factory whose `targetNodeId`
+     * has no entry in the resolved targets after the SSR DOM walk).
+     */
+    formatBindingMismatch(factory: ViewBehaviorFactory, firstChild: Node, lastChild: Node, hostName: string | undefined): HydrationDiagnosticResult;
+    /**
+     * Format a structural error encountered during the SSR DOM walk
+     * (e.g. attribute binding count overflow, missing close marker).
+     */
+    formatStructuralError(node: Node, hostName: string | undefined, expectedDescription: string): HydrationDiagnosticResult;
+}
+/**
+ * Installs a {@link HydrationDiagnostic} as the active formatter for
+ * hydration mismatch errors. Called by `enableHydration()` when an opt-in
+ * debugger configuration is supplied; not exposed as `@public` because
+ * library consumers should always go through `enableHydration` to install
+ * a debugger.
+ * @internal
+ */
+export declare function installHydrationDiagnostic(diagnostic: HydrationDiagnostic): void;
+/**
+ * Returns the currently active {@link HydrationDiagnostic} — either the
+ * minimal default or one installed by an opt-in debugger.
+ * @internal
+ */
+export declare function getHydrationDiagnostic(): HydrationDiagnostic;
+/**
+ * Reads the host element's tag name from any node inside a hydration view.
+ * Returns `undefined` when the node is not inside a shadow root.
+ * @internal
+ */
+export declare function getHostName(node: Node | null | undefined): string | undefined;

package/dist/dts/hydration/exports.d.ts

@@ -0,0 +1,18 @@
+export type { HydrationController, HydrationOptions, } from "../components/enable-hydration.js";
+export { deferHydrationAttribute, enableHydration, StopHydration, } from "../components/enable-hydration.js";
+export { isHydratable } from "../components/hydration.js";
+export { HydrationTracker } from "../components/hydration-tracker.js";
+export type { DOMAspect, DOMSink, } from "../dom.js";
+export { type DOMAspectGuards, type DOMElementGuards, type DOMGuards, DOMPolicy, type DOMPolicyOptions, type DOMSinkGuards, } from "../dom-policy.js";
+export type { Disposable, TrustedTypesPolicy } from "../interfaces.js";
+export type { ExecutionContext, ExpressionController, SourceLifetime, } from "../observation/observable.js";
+export type { ContentTemplate, ContentView, HydratableContentTemplate, } from "../templating/html-binding-directive.js";
+export type { ViewBehavior, ViewBehaviorFactory, ViewBehaviorTargets, ViewController, } from "../templating/html-directive.js";
+export type { HydratableView, HydratableViewController, ViewNodes, } from "../templating/hydration-view.js";
+export { HydrationBindingError, HydrationStage, } from "../templating/hydration-view.js";
+export type { CaptureType, ElementViewTemplate, HydratableElementViewTemplate, HydratableSyntheticViewTemplate, SyntheticViewTemplate, } from "../templating/template.js";
+export type { DefaultExecutionContext, ElementView, SyntheticView, View, } from "../templating/view.js";
+export type { HydrationDiagnostic, HydrationDiagnosticResult, HydrationMismatchActual, HydrationMismatchExpectation, } from "./diagnostics.js";
+export type { HydrationDebugger } from "./hydration-debugger.js";
+export { hydrationDebugger } from "./hydration-debugger.js";
+export type { ViewBehaviorBoundaries, ViewBoundaries, } from "./target-builder.js";

package/dist/dts/hydration/hydration-debugger.d.ts

@@ -0,0 +1,35 @@
+import type { HydrationDiagnostic } from "./diagnostics.js";
+/**
+ * Opt-in hydration debugger configuration. Pass to `enableHydration` to
+ * install the rich "Expected / Received" hydration mismatch formatter:
+ *
+ * ```ts
+ * import { enableHydration, hydrationDebugger } from "@lushly-dev/fast-element/hydration.js";
+ *
+ * enableHydration({ debugger: hydrationDebugger() });
+ * ```
+ *
+ * @public
+ */
+export interface HydrationDebugger {
+    /**
+     * The {@link HydrationDiagnostic} the debugger installs when consumed
+     * by `enableHydration`.
+     */
+    readonly diagnostic: HydrationDiagnostic;
+}
+/**
+ * Returns a {@link HydrationDebugger} that, when supplied to
+ * `enableHydration({ debugger })`, installs the rich hydration mismatch
+ * formatter: a single-line "Expected … / Received …" message plus an HTML
+ * snippet of the SSR DOM and structured `expected`/`received` fields on
+ * the thrown error (both `HydrationBindingError` and
+ * `HydrationTargetElementError`).
+ *
+ * Without the debugger, hydration errors emit only a minimal one-line
+ * message pointing at this function — keeping the runtime hydration cost
+ * small for production bundles that do not need rich diagnostics.
+ *
+ * @public
+ */
+export declare function hydrationDebugger(): HydrationDebugger;

package/dist/dts/hydration/messages.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Centralized hydration mismatch message strings used by both the default
+ * minimal `HydrationDiagnostic` and the opt-in `hydrationDebugger` rich
+ * formatter, and by the structural-error throw sites in
+ * `target-builder.ts`.
+ *
+ * Static text is exported as a plain `const`; interpolated text is exported
+ * as a small builder function. Plain `export const` declarations tree-shake
+ * better than frozen-object property bags, so unused strings drop out of
+ * bundles cleanly.
+ */
+/**
+ * Fallback host tag name used when a hydration mismatch is detected on a
+ * node that is not inside a shadow root.
+ */
+export declare const unknownHostName = "unknown";
+export declare const aspectLabelAttribute = "attribute";
+export declare const aspectLabelBooleanAttribute = "boolean attribute";
+export declare const aspectLabelProperty = "property";
+export declare const aspectLabelContent = "content";
+export declare const aspectLabelTokenList = "token list";
+export declare const aspectLabelEvent = "event";
+/** Fallback used when the aspectType is missing or unknown. */
+export declare const aspectLabelUnknown = "binding";
+/**
+ * Combines an aspect label with the original source aspect identifier from
+ * markup (e.g. `"property className"`). Returns the bare label when no
+ * source aspect was captured.
+ */
+export declare function formatAspect(label: string, sourceAspect: string | undefined): string;
+/**
+ * Formats the "Expected" half of the rich hydration mismatch message, e.g.
+ * `"<span> with content binding"` or `"content binding"` when no tag is
+ * associated with the binding factory.
+ */
+export declare function formatExpectedTarget(tagName: string | null, aspect: string): string;
+/**
+ * Default minimal hydration mismatch message used when the
+ * `hydrationDebugger` opt-in is not installed. The optional `detail` string
+ * carries the structural expectation surfaced by `target-builder.ts`.
+ */
+export declare function formatDefaultMismatchMessage(hostName: string, detail: string | undefined): string;
+/**
+ * Rich `Expected … / Received …` hydration mismatch message format produced
+ * by the `hydrationDebugger` formatter.
+ */
+export declare function formatRichMismatchMessage(hostName: string, expectedText: string, receivedHtml: string): string;
+export declare const expectedContentAfterStartMarker = "content following `<!--fe:b-->` content binding marker";
+export declare const expectedContentEndMarker = "matching `<!--fe:/b-->` content binding close marker";
+export declare const expectedElementBoundaryEndMarker = "matching `<!--fe:/e-->` element boundary close marker";
+/**
+ * Builds the "no more attribute bindings" structural expectation message
+ * thrown when an element's `data-fe` count claims more attribute bindings
+ * than the compiled template defines.
+ */
+export declare function formatNoMoreAttributeBindings(factoryCount: number): string;
+/**
+ * Builds the "no more content bindings" structural expectation message
+ * thrown when the SSR DOM contains more content binding markers than the
+ * compiled template defines.
+ */
+export declare function formatNoMoreContentBindings(factoryCount: number): string;

package/dist/dts/hydration/runtime.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Installs the hydration runtime on `ViewTemplate.prototype`,
+ * making all templates hydratable. Call this before any hydration
+ * occurs. Safe to call multiple times — subsequent calls are no-ops.
+ * @internal
+ */
+export declare function ensureHydrationRuntime(): void;

package/dist/dts/hydration/target-builder.d.ts

@@ -0,0 +1,107 @@
+import type { CompiledViewBehaviorFactory, ViewBehaviorFactory, ViewBehaviorTargets } from "../templating/html-directive.js";
+import { type HydrationMismatchActual, type HydrationMismatchExpectation } from "./diagnostics.js";
+export declare class HydrationTargetElementError extends Error {
+    /**
+     * The Compiled View Behavior Factories that belong to the view.
+     */
+    readonly factories: CompiledViewBehaviorFactory[];
+    /**
+     * The node to target factory.
+     */
+    readonly node: Node;
+    /**
+     * Structured description of the binding the hydration walk was
+     * attempting to apply when the mismatch was detected. Free-form
+     * string for structural errors that do not correspond to a single
+     * binding factory.
+     */
+    readonly expected?: HydrationMismatchExpectation | string | undefined;
+    /**
+     * Structured description of the server-rendered DOM that was
+     * encountered at the mismatch point.
+     */
+    readonly received?: HydrationMismatchActual | undefined;
+    /**
+     * String representation of the HTML in the template that
+     * threw the target element error.
+     */
+    templateString?: string;
+    constructor(
+    /**
+     * The error message
+     */
+    message: string | undefined, 
+    /**
+     * The Compiled View Behavior Factories that belong to the view.
+     */
+    factories: CompiledViewBehaviorFactory[], 
+    /**
+     * The node to target factory.
+     */
+    node: Node, 
+    /**
+     * Structured description of the binding the hydration walk was
+     * attempting to apply when the mismatch was detected. Free-form
+     * string for structural errors that do not correspond to a single
+     * binding factory.
+     */
+    expected?: HydrationMismatchExpectation | string | undefined, 
+    /**
+     * Structured description of the server-rendered DOM that was
+     * encountered at the mismatch point.
+     */
+    received?: HydrationMismatchActual | undefined);
+}
+/**
+ * Represents the DOM boundaries controlled by a view
+ * @public
+ */
+export interface ViewBoundaries {
+    first: Node;
+    last: Node;
+}
+/**
+ * Stores relationships between a {@link ViewBehaviorFactory} and
+ * the {@link ViewBoundaries} the factory created.
+ * @public
+ */
+export interface ViewBehaviorBoundaries {
+    [factoryId: string]: ViewBoundaries;
+}
+/**
+ * Returns a range object inclusive of all nodes including and between the
+ * provided first and last node.
+ * @param first - The first node
+ * @param last - This last node
+ * @returns
+ */
+export declare function createRangeForNodes(first: Node, last: Node): Range;
+/**
+ * Maps compiled ViewBehaviorFactory IDs to their corresponding DOM nodes in the
+ * server-rendered shadow root. Uses a TreeWalker to scan the existing DOM between
+ * firstNode and lastNode, processing data-free sequential hydration markers.
+ *
+ * A sequential factory pointer advances through the factories array in DFS order.
+ * Since the template compiler and hydration walker both traverse the DOM in
+ * identical depth-first order, no embedded indices are needed in markers.
+ *
+ * For element nodes: parses `data-fe="N"` to determine the count of attribute
+ * binding factories, then consumes N factories sequentially.
+ *
+ * For comment nodes: `fe:b` markers consume the next factory for content bindings,
+ * using balanced depth counting for nested marker pairing. `fe:e` markers cause
+ * the walker to skip nested custom element subtrees.
+ *
+ * Host bindings (targetNodeId='h') appear at the start of the factories array but
+ * have no SSR markers — getHydrationIndexOffset() computes the initial pointer value.
+ *
+ * @param firstNode - The first node of the view.
+ * @param lastNode -  The last node of the view.
+ * @param factories - The Compiled View Behavior Factories that belong to the view.
+ * @returns - A {@link ViewBehaviorTargets } object for the factories in the view.
+ */
+export declare function buildViewBindingTargets(firstNode: Node, lastNode: Node, factories: CompiledViewBehaviorFactory[]): {
+    targets: ViewBehaviorTargets;
+    boundaries: ViewBehaviorBoundaries;
+};
+export declare function targetFactory(factory: ViewBehaviorFactory, node: Node, targets: ViewBehaviorTargets): void;

package/dist/dts/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Core APIs for building standards-based Web Components with FAST Element.
+ * @packageDocumentation
+ */
+export { Binding, type BindingDirective } from "./binding/binding.js";
+export { normalizeBinding } from "./binding/normalize.js";
+export { oneTime } from "./binding/one-time.js";
+export { listener, oneWay } from "./binding/one-way.js";
+export { Signal, signal } from "./binding/signal.js";
+export { type TwoWayBindingOptions, TwoWaySettings, twoWay, } from "./binding/two-way.js";
+export { AttributeConfiguration, AttributeDefinition, type AttributeMode, attr, booleanConverter, type DecoratorAttributeConfiguration, nullableBooleanConverter, nullableNumberConverter, type ValueConverter, } from "./components/attributes.js";
+export type { ElementControllerStrategy } from "./components/element-controller.js";
+export { ElementController, Stages, } from "./components/element-controller.js";
+export type { FASTElementExtension, FASTElementTemplateResolver, PartialFASTElementDefinition, ShadowRootOptions, TypeDefinition, TypeRegistry, } from "./components/fast-definitions.js";
+export { FASTElementDefinition } from "./components/fast-definitions.js";
+export { customElement, FASTElement, type FASTElementConstructor, } from "./components/fast-element.js";
+export { type FASTElementRegistry, fastElementRegistry, } from "./components/fast-element-registry.js";
+export { enableDebug } from "./debug.js";
+export { DOM, DOMAspect, type DOMSink } from "./dom.js";
+export { type DOMAspectGuards, type DOMElementGuards, type DOMGuards, DOMPolicy, type DOMPolicyOptions, type DOMSinkGuards, } from "./dom-policy.js";
+export type { Callable, Class, Constructable, Disposable, TrustedTypesPolicy, } from "./interfaces.js";
+export { ArrayObserver, type LengthObserver, lengthOf, Sort, type SortObserver, Splice, SpliceStrategy, SpliceStrategySupport, sortedCount, } from "./observation/arrays.js";
+export { type Notifier, PropertyChangeNotifier, type Subscriber, SubscriberSet, } from "./observation/notifier.js";
+export type { Accessor, Expression, ExpressionController, ExpressionNotifier, ExpressionObserver, ObservationRecord, } from "./observation/observable.js";
+export { ExecutionContext, Observable, observable, SourceLifetime, } from "./observation/observable.js";
+export { type UpdateQueue, Updates } from "./observation/update-queue.js";
+export { volatile } from "./observation/volatile.js";
+export { emptyArray, FAST } from "./platform.js";
+export { type AccessCachedPath, type CachedPath, type CachedPathCommon, type CachedPathMap, type ChildrenMap, type DefaultCachedPath, type EventCachedPath, type JSONSchema, type JSONSchemaCommon, type JSONSchemaDefinition, type RegisterPathConfig, type RepeatCachedPath, Schema, schemaRegistry, } from "./schema.js";
+export * from "./state/exports.js";
+export { type CSSTemplateTag, type CSSValue, css } from "./styles/css.js";
+export { CSSDirective, type CSSDirectiveDefinition, cssDirective, } from "./styles/css-directive.js";
+export type { ComposableStyles, ConstructibleStyleStrategy, } from "./styles/element-styles.js";
+export { ElementStyles } from "./styles/element-styles.js";
+export type { HostBehavior, HostController } from "./styles/host.js";
+export type { StyleStrategy, StyleTarget } from "./styles/style-strategy.js";
+export { type ChildListDirectiveOptions, ChildrenDirective, type ChildrenDirectiveOptions, children, type SubtreeDirectiveOptions, } from "./templating/children.js";
+export { type CompilationStrategy, Compiler } from "./templating/compiler.js";
+export { type ContentTemplate, type ContentView, HTMLBindingDirective, } from "./templating/html-binding-directive.js";
+export { type AddViewBehaviorFactory, type Aspected, type CompiledViewBehaviorFactory, HTMLDirective, type HTMLDirectiveDefinition, htmlDirective, type PartialHTMLDirectiveDefinition, StatelessAttachedAttributeDirective, type ViewBehavior, type ViewBehaviorFactory, type ViewBehaviorTargets, type ViewController, } from "./templating/html-directive.js";
+export { Markup, Parser } from "./templating/markup.js";
+export { type ElementsFilter, elements, type NodeBehaviorOptions, NodeObservationDirective, } from "./templating/node-observation.js";
+export { RefDirective, ref } from "./templating/ref.js";
+export { RenderBehavior, RenderDirective, render } from "./templating/render.js";
+export { RepeatBehavior, RepeatDirective, type RepeatOptions, repeat, } from "./templating/repeat.js";
+export { SlottedDirective, type SlottedDirectiveOptions, slotted, } from "./templating/slotted.js";
+export { type CaptureType, type ElementViewTemplate, type HTMLTemplateCompilationResult, type HTMLTemplateTag, html, InlineTemplateDirective, type SyntheticViewTemplate, type TemplateValue, ViewTemplate, } from "./templating/template.js";
+export { DefaultExecutionContext, type ElementView, HTMLView, type SyntheticView, type View, } from "./templating/view.js";
+export { when } from "./templating/when.js";
+export type { TrustEmitOptions, TrustSignals, Warning, WarningSeverity, } from "./trust/types.js";
+export * from "./utilities.js";

package/dist/dts/index.debug.d.ts

@@ -0,0 +1 @@
+export * from "./index.js";

package/dist/dts/index.rollup.d.ts

@@ -0,0 +1 @@
+export * from "./index.js";

package/dist/dts/index.rollup.debug.d.ts

@@ -0,0 +1 @@
+export * from "./index.js";