@microsoft/fast-element 3.0.0-rc.1 → 3.0.0-rc.2

package/dist/di/di.api.json

@@ -1530,7 +1530,7 @@
             },
             {
               "kind": "Content",
-              "text": "<T>;\n    singleton<T_1 extends "
+              "text": "<T>;\n    singleton<T extends "
             },
             {
               "kind": "Reference",
@@ -1539,7 +1539,7 @@
             },
             {
               "kind": "Content",
-              "text": ">(target: T_1 & "
+              "text": ">(target: T & "
             },
             {
               "kind": "Reference",
@@ -1557,7 +1557,7 @@
             },
             {
               "kind": "Content",
-              "text": "<T_1>>, options?: "
+              "text": "<T>>, options?: "
             },
             {
               "kind": "Reference",
@@ -1566,7 +1566,7 @@
             },
             {
               "kind": "Content",
-              "text": "): T_1 & "
+              "text": "): T & "
             },
             {
               "kind": "Reference",
@@ -1575,7 +1575,7 @@
             },
             {
               "kind": "Content",
-              "text": "<T_1>;\n}>"
+              "text": "<T>;\n}>"
             }
           ],
           "fileUrlPath": "dist/dts/di/di.d.ts",
@@ -2702,7 +2702,7 @@
             },
             {
               "kind": "Content",
-              "text": "<T>;\n    singleton<T_1 extends "
+              "text": "<T>;\n    singleton<T extends "
             },
             {
               "kind": "Reference",
@@ -2720,7 +2720,7 @@
             },
             {
               "kind": "Content",
-              "text": ", value: T_1): "
+              "text": ", value: T): "
             },
             {
               "kind": "Reference",
@@ -2738,7 +2738,7 @@
             },
             {
               "kind": "Content",
-              "text": "<T_1>>;\n    transient<T_2 extends "
+              "text": "<T>>;\n    transient<T extends "
             },
             {
               "kind": "Reference",
@@ -2756,7 +2756,7 @@
             },
             {
               "kind": "Content",
-              "text": ", value: T_2): "
+              "text": ", value: T): "
             },
             {
               "kind": "Reference",
@@ -2774,7 +2774,7 @@
             },
             {
               "kind": "Content",
-              "text": "<T_2>>;\n    callback<T_3>(key: "
+              "text": "<T>>;\n    callback<T>(key: "
             },
             {
               "kind": "Reference",
@@ -2792,7 +2792,7 @@
             },
             {
               "kind": "Content",
-              "text": "<T_3>): "
+              "text": "<T>): "
             },
             {
               "kind": "Reference",
@@ -2810,7 +2810,7 @@
             },
             {
               "kind": "Content",
-              "text": "<T_3>>;\n    cachedCallback<T_4>(key: "
+              "text": "<T>>;\n    cachedCallback<T>(key: "
             },
             {
               "kind": "Reference",
@@ -2828,7 +2828,7 @@
             },
             {
               "kind": "Content",
-              "text": "<T_4>): "
+              "text": "<T>): "
             },
             {
               "kind": "Reference",
@@ -2846,7 +2846,7 @@
             },
             {
               "kind": "Content",
-              "text": "<T_4>>;\n    aliasTo<T_5>(originalKey: T_5, aliasKey: "
+              "text": "<T>>;\n    aliasTo<T>(originalKey: T, aliasKey: "
             },
             {
               "kind": "Reference",
@@ -2873,7 +2873,7 @@
             },
             {
               "kind": "Content",
-              "text": "<T_5>>;\n}>"
+              "text": "<T>>;\n}>"
             }
           ],
           "fileUrlPath": "dist/dts/di/di.d.ts",

package/dist/dts/__test__/helpers.d.ts

@@ -0,0 +1,6 @@
+export declare function toHTML(node: Node, preserveCommentMarkup?: boolean): string;
+export declare function createTrackableDOMPolicy(): {
+    used: boolean;
+    createHTML: (html: string) => string;
+    protect(tagName: any, aspect: any, aspectName: any, sink: any): (node: any, aspectName: any, value: any, ...args: any[]) => void;
+};

package/dist/dts/binding/binding.d.ts

@@ -1,4 +1,5 @@
-import type { DOMAspect, DOMPolicy } from "../dom.js";
+import type { DOMAspect } from "../dom.js";
+import type { DOMPolicy } from "../dom-policy.js";
 import type { Subscriber } from "../observation/notifier.js";
 import type { Expression, ExpressionObserver } from "../observation/observable.js";
 /**
@@ -26,20 +27,29 @@ export interface BindingDirective {
  * @public
  */
 export declare abstract class Binding<TSource = any, TReturn = any, TParent = any> {
-    evaluate: Expression<TSource, TReturn, TParent>;
-    policy?: DOMPolicy | undefined;
-    isVolatile: boolean;
     /**
      * Options associated with the binding.
      */
     options?: any;
+    /**
+     * Evaluates the binding.
+     */
+    evaluate: Expression<TSource, TReturn, TParent>;
+    /**
+     * The security policy to associate with this binding.
+     */
+    policy?: DOMPolicy;
+    /**
+     * Indicates whether the binding is volatile.
+     */
+    isVolatile: boolean;
     /**
      * Creates a binding.
      * @param evaluate - Evaluates the binding.
      * @param policy - The security policy to associate with this binding.
      * @param isVolatile - Indicates whether the binding is volatile.
      */
-    constructor(evaluate: Expression<TSource, TReturn, TParent>, policy?: DOMPolicy | undefined, isVolatile?: boolean);
+    constructor(evaluate: Expression<TSource, TReturn, TParent>, policy?: DOMPolicy, isVolatile?: boolean);
     /**
      * Creates an observer capable of notifying a subscriber when the output of a binding changes.
      * @param subscriber - The subscriber to changes in the binding.

package/dist/dts/binding/one-time.d.ts

@@ -1,4 +1,4 @@
-import type { DOMPolicy } from "../dom.js";
+import type { DOMPolicy } from "../dom-policy.js";
 import type { Expression } from "../observation/observable.js";
 import { Binding } from "./binding.js";
 /**

package/dist/dts/binding/one-way.d.ts

@@ -1,4 +1,4 @@
-import type { DOMPolicy } from "../dom.js";
+import type { DOMPolicy } from "../dom-policy.js";
 import { type Expression } from "../observation/observable.js";
 import { Binding } from "./binding.js";
 /**

package/dist/dts/binding/signal.d.ts

@@ -1,4 +1,4 @@
-import type { DOMPolicy } from "../dom.js";
+import type { DOMPolicy } from "../dom-policy.js";
 import type { Subscriber } from "../observation/notifier.js";
 import type { Expression } from "../observation/observable.js";
 import { Binding } from "./binding.js";

package/dist/dts/binding/two-way.d.ts

@@ -1,4 +1,4 @@
-import type { DOMPolicy } from "../dom.js";
+import type { DOMPolicy } from "../dom-policy.js";
 import { type Expression } from "../observation/observable.js";
 import { Binding, type BindingDirective } from "./binding.js";
 /**

package/dist/dts/components/attributes.d.ts

@@ -75,7 +75,7 @@ export declare const nullableBooleanConverter: ValueConverter;
  */
 export declare const nullableNumberConverter: ValueConverter;
 /**
- * An implementation of `Accessor` that supports reactivity,
+ * An implementation of {@link Accessor} that supports reactivity,
  * change callbacks, attribute reflection, and type conversion for
  * custom elements.
  * @public

package/dist/dts/components/enable-hydration.d.ts

@@ -1,4 +1,5 @@
 import { type HydrationOptions } from "./hydration-tracker.js";
+export { StopHydration } from "./hydration-tracker.js";
 export type { HydrationOptions };
 /**
  * Enables hydration support for prerendered FAST elements.
@@ -10,19 +11,38 @@ export type { HydrationOptions };
  *
  * Safe to call multiple times — the hydration hook is installed once
  * and subsequent calls merge their options into the shared tracker.
+ * By default, the hook stops hydrating new prerendered elements after
+ * the global `hydrationComplete` callback. Set
+ * `stopHydration` to `StopHydration.never` for streaming scenarios
+ * that append hydratable Declarative Shadow DOM after the initial batch.
+ *
+ * Pass `debugger: hydrationDebugger()` to swap the default minimal
+ * hydration mismatch error message for a rich "Expected / Received"
+ * report including the SSR HTML snippet and structured
+ * `expected`/`received` fields on `HydrationBindingError` /
+ * `HydrationTargetElementError`. The debugger module is tree-shaken
+ * out of production hydration bundles unless explicitly imported.
  *
  * @example
  * ```ts
- * import { enableHydration } from "@microsoft/fast-element/hydration.js";
+ * import { enableHydration, StopHydration } from "@microsoft/fast-element/hydration.js";
  *
  * enableHydration({
+ *     stopHydration: StopHydration.never,
  *     hydrationComplete() {
  *         console.log("hydration complete");
  *     },
  * });
  * ```
  *
- * @param options - Optional callbacks for global hydration events.
+ * @example Rich hydration mismatch diagnostics
+ * ```ts
+ * import { enableHydration, hydrationDebugger } from "@microsoft/fast-element/hydration.js";
+ *
+ * enableHydration({ debugger: hydrationDebugger() });
+ * ```
+ *
+ * @param options - Optional global hydration callbacks and behavior.
  * @public
  */
 export declare function enableHydration(options?: HydrationOptions): void;

package/dist/dts/components/fast-definitions.d.ts

@@ -1,15 +1,18 @@
 import { type Constructable } from "../interfaces.js";
-import { type TypeRegistry } from "../platform.js";
+import { type TypeDefinition, type TypeRegistry } from "../platform.js";
 import { type ComposableStyles, ElementStyles } from "../styles/element-styles.js";
 import type { ElementViewTemplate } from "../templating/template.js";
 import { type AttributeConfiguration, AttributeDefinition } from "./attributes.js";
 import type { Schema } from "./schema.js";
 /**
- * The FAST custom element registry
- * @internal
+ * The FAST custom element registry.
+ * @remarks
+ * This registry stores FAST element definitions by constructor so consumers can
+ * look up the `FASTElementDefinition` associated with an element type or instance.
+ * @public
  */
 export declare const fastElementRegistry: TypeRegistry<FASTElementDefinition>;
-export type { TypeRegistry };
+export type { TypeDefinition, TypeRegistry };
 /**
  * Shadow root initialization options.
  * @public

package/dist/dts/components/fast-element.d.ts

@@ -45,22 +45,53 @@ export interface FASTElement extends HTMLElement {
      */
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
 }
-declare function compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(this: TType, nameOrDef: string | PartialFASTElementDefinition<TType>): Promise<FASTElementDefinition<TType>>;
-declare function compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition<TType>): Promise<FASTElementDefinition<TType>>;
-declare function define<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(this: TType, nameOrDef: string | PartialFASTElementDefinition<TType>, extensions?: FASTElementExtension[]): Promise<TType>;
-declare function define<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition<TType>, extensions?: FASTElementExtension[]): Promise<TType>;
-declare function from<TBase extends typeof HTMLElement>(BaseType: TBase): new () => InstanceType<TBase> & FASTElement;
+/**
+ * The FASTElement constructor and static registration helpers.
+ * @public
+ */
+export interface FASTElementConstructor {
+    /**
+     * Creates a FASTElement instance.
+     */
+    new (): FASTElement;
+    /**
+     * Defines a platform custom element based on the provided type and definition.
+     * @param nameOrDef - The name of the element to define or a definition object.
+     * @param extensions - Optional callbacks to run before registration.
+     */
+    define<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(this: TType, nameOrDef: string | PartialFASTElementDefinition<TType>, extensions?: FASTElementExtension[]): Promise<TType>;
+    /**
+     * Defines a platform custom element based on the provided type and definition.
+     * @param type - The custom element type to define.
+     * @param nameOrDef - The name of the element to define or a definition object.
+     * @param extensions - Optional callbacks to run before registration.
+     */
+    define<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition<TType>, extensions?: FASTElementExtension[]): Promise<TType>;
+    /**
+     * Composes FASTElement metadata without registering the element.
+     * @param nameOrDef - The name of the element to compose or a definition object.
+     */
+    compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(this: TType, nameOrDef: string | PartialFASTElementDefinition<TType>): Promise<FASTElementDefinition<TType>>;
+    /**
+     * Composes FASTElement metadata without registering the element.
+     * @param type - The custom element type to compose.
+     * @param nameOrDef - The name of the element to compose or a definition object.
+     */
+    compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition<TType>): Promise<FASTElementDefinition<TType>>;
+    /**
+     * Creates a new FASTElement base class inherited from the provided base type.
+     * @param BaseType - The base element type to inherit from.
+     */
+    from<TBase extends typeof HTMLElement>(BaseType: TBase): {
+        new (): InstanceType<TBase> & FASTElement;
+    };
+}
 /**
  * A minimal base class for FASTElements that also provides
  * static helpers for working with FASTElements.
  * @public
  */
-export declare const FASTElement: {
-    new (): FASTElement;
-    define: typeof define;
-    compose: typeof compose;
-    from: typeof from;
-};
+export declare const FASTElement: FASTElementConstructor;
 /**
  * Decorator: Defines a platform custom element based on `FASTElement`.
  * @param nameOrDef - The name of the element to define or a definition object
@@ -68,4 +99,3 @@ export declare const FASTElement: {
  * @public
  */
 export declare function customElement(nameOrDef: string | PartialFASTElementDefinition): (type: Constructable<HTMLElement>) => void;
-export {};

package/dist/dts/components/hydration-tracker.d.ts

@@ -1,12 +1,48 @@
 /**
- * Options for configuring global hydration lifecycle events.
+ * Describes when FAST should stop hydrating newly connected prerendered elements.
+ * @public
+ */
+export declare const StopHydration: Readonly<{
+    /**
+     * Stop hydrating new prerendered elements after the active hydration batch completes.
+     */
+    readonly hydrationComplete: "hydration-complete";
+    /**
+     * Keep the hydration hook active for later prerendered elements.
+     */
+    readonly never: "never";
+}>;
+/**
+ * Describes when FAST should stop hydrating newly connected prerendered elements.
+ * @public
+ */
+export type StopHydration = (typeof StopHydration)[keyof typeof StopHydration];
+import type { HydrationDebugger } from "../hydration/hydration-debugger.js";
+/**
+ * Options for configuring global hydration lifecycle events and behavior.
  * @public
  */
 export interface HydrationOptions {
-    /** Called once when the first prerendered element begins hydrating. */
+    /** Called when a prerendered hydration batch begins. */
     hydrationStarted?(): void;
-    /** Called after all prerendered elements have completed hydration. */
+    /** Called after all prerendered elements in a hydration batch complete. */
     hydrationComplete?(): void;
+    /**
+     * Indicates when the hydration hook should stop handling new
+     * prerendered elements.
+     *
+     * @defaultValue StopHydration.hydrationComplete
+     */
+    stopHydration?: StopHydration;
+    /**
+     * Optional opt-in debugger that swaps the default minimal hydration
+     * mismatch error message for a rich "Expected … / Received …" report
+     * including an HTML snippet of the SSR DOM and structured
+     * `expected`/`received` fields on `HydrationBindingError` /
+     * `HydrationTargetElementError`. Obtained via
+     * `hydrationDebugger()` from `@microsoft/fast-element/hydration.js`.
+     */
+    debugger?: HydrationDebugger;
 }
 /**
  * Tracks prerendered elements through the hydration lifecycle and
@@ -17,11 +53,18 @@ export interface HydrationOptions {
  * @public
  */
 export declare class HydrationTracker {
-    private options;
     private elements;
     private started;
+    private completed;
     private checkTimer;
+    private callbacks;
+    private stopHydration;
     constructor(options: HydrationOptions);
+    /**
+     * Indicates whether the hydration hook should attempt to hydrate
+     * prerendered elements.
+     */
+    get shouldHydrate(): boolean;
     /**
      * Registers an element as pending hydration.
      * Fires `hydrationStarted` on the first call.

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

@@ -8,6 +8,8 @@ import type { ElementViewTemplate, HydratableElementViewTemplate, HydratableSynt
  */
 export declare const HydrationMarkup: Readonly<{
     attributeMarkerName: "data-fe";
+    legacyAttributeMarkerName: "data-fe-b";
+    legacyCompactAttributeMarkerName: "data-fe-c";
     contentBindingStartMarker(): string;
     contentBindingEndMarker(): string;
     repeatStartMarker(): string;
@@ -28,6 +30,9 @@ export declare const HydrationMarkup: Readonly<{
      * of attribute binding factories targeting this element.
      */
     parseAttributeBindingCount(node: Element): number | null;
+    parseLegacyAttributeBindingIndices(node: Element): number[] | null;
+    removeLegacyAttributeBindingMarkers(node: Element): void;
+    parseLegacyContentBindingStartIndex(data: string): number | null;
 }>;
 /**
  * @internal

package/dist/dts/context.d.ts

@@ -56,7 +56,7 @@ export declare const Context: Readonly<{
      * @param name - The name to use for the connext. Useful in debugging.
      * @param initialValue - An optional initial value to use if a context handler isn't found.
      */
-    create<T_1 = unknown>(name: string, initialValue?: T_1 | undefined): FASTContext<T_1>;
+    create<T = unknown>(name: string, initialValue?: T): FASTContext<T>;
     /**
      * Sets the strategy used by all FAST-specific context requests made through the
      * Context.request, Context.get, Context.defineProperty, and ContextDecorator APIs.
@@ -73,7 +73,7 @@ export declare const Context: Readonly<{
      * Uses the default request strategy to locate the context. If no context is found
      * then the initial value of the context is returned.
      */
-    get<T_2 extends UnknownContext>(target: EventTarget, context: T_2): ContextType<T_2>;
+    get<T extends UnknownContext>(target: EventTarget, context: T): ContextType<T>;
     /**
      * Requests the context value for the target node.
      * @param target - The target to request the context for.
@@ -84,7 +84,7 @@ export declare const Context: Readonly<{
      * @remarks
      * Uses the default request strategy to locate the context.
      */
-    request<T_3 extends UnknownContext>(target: EventTarget, context: T_3, callback: ContextCallback<ContextType<T_3>>, multiple?: boolean): void;
+    request<T extends UnknownContext>(target: EventTarget, context: T, callback: ContextCallback<ContextType<T>>, multiple?: boolean): void;
     /**
      *
      * @param target - The target to dispatch the context event on.
@@ -96,14 +96,14 @@ export declare const Context: Readonly<{
      * This API does NOT use the default request strategy. It always dispatches
      * an event through the DOM.
      */
-    dispatch<T_4 extends UnknownContext>(target: EventTarget, context: T_4, callback: ContextCallback<ContextType<T_4>>, multiple?: boolean): void;
+    dispatch<T extends UnknownContext>(target: EventTarget, context: T, callback: ContextCallback<ContextType<T>>, multiple?: boolean): void;
     /**
      * Enables an event target to provide a context value.
      * @param target - The target to provide the context value for.
      * @param context - The context to provide the value for.
      * @param value - The value to provide for the context.
      */
-    provide<T_5 extends UnknownContext>(target: EventTarget, context: T_5, value: ContextType<T_5>): void;
+    provide<T extends UnknownContext>(target: EventTarget, context: T, value: ContextType<T>): void;
     /**
      *
      * @param target - The target on which to handle context requests.
@@ -113,7 +113,7 @@ export declare const Context: Readonly<{
      * If a context is not provided then the callback will be invoked for all context
      * requests that are received on the target.
      */
-    handle<T_6 extends UnknownContext>(target: EventTarget, callback: (event: ContextEvent<T_6>) => void, context?: T_6 | undefined): void;
+    handle<T extends UnknownContext>(target: EventTarget, callback: (event: ContextEvent<T>) => void, context?: T): void;
     /**
      * Defines a getter-only property on the target that will return the context
      * value for the target.
@@ -124,7 +124,7 @@ export declare const Context: Readonly<{
      * Uses the default request strategy to locate the context and will return the
      * initialValue if the context isn't handled.
      */
-    defineProperty<T_7 extends UnknownContext>(target: Constructable<EventTarget> | EventTarget, propertyName: string, context: T_7): void;
+    defineProperty<T extends UnknownContext>(target: Constructable<EventTarget> | EventTarget, propertyName: string, context: T): void;
 }>;
 /**
  * An unknown context type.

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

@@ -1,5 +1,4 @@
 export declare const debugMessages: {
-    2000: string;
-    2001: string;
-    2002: string;
+    [2000]: string;
+    [2001]: string;
 };

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

@@ -1,8 +1,9 @@
 export type { AttributeConfiguration, AttributeDefinition, AttributeMode, ValueConverter, } from "../components/attributes.js";
 export type { FASTElementDefinition, FASTElementExtension, FASTElementTemplateResolver, PartialFASTElementDefinition, ShadowRootOptions, TemplateLifecycleCallbacks, } from "../components/fast-definitions.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 "../components/schema.js";
-export type { DOMPolicy } from "../dom.js";
-export type { Constructable } from "../interfaces.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 { Constructable, TrustedTypesPolicy } from "../interfaces.js";
 export type { Accessor } from "../observation/observable.js";
 export type { ComposableStyles, ConstructibleStyleStrategy, ElementStyles, } from "../styles/element-styles.js";
 export type { StyleStrategy, StyleTarget } from "../styles/style-strategy.js";

package/dist/dts/declarative/interfaces.d.ts

@@ -4,6 +4,5 @@
  */
 export declare const enum Message {
     noTemplateProvided = 2000,
-    moreThanOneTemplateProvided = 2001,
-    moreThanOneMatchingTemplateProvided = 2002
+    moreThanOneTemplateProvided = 2001
 }

package/dist/dts/declarative/template.d.ts

@@ -1,4 +1,5 @@
 import type { FASTElementTemplateResolver, TemplateLifecycleCallbacks } from "../components/fast-definitions.js";
+import type { Constructable } from "../interfaces.js";
 /**
  * Returns a declarative template resolver that waits for the matching
  * `<f-template>` element and resolves it into a concrete `ViewTemplate`.
@@ -6,4 +7,4 @@ import type { FASTElementTemplateResolver, TemplateLifecycleCallbacks } from "..
  * @param callbacks - Optional per-element lifecycle callbacks.
  * @public
  */
-export declare function declarativeTemplate(callbacks?: TemplateLifecycleCallbacks): FASTElementTemplateResolver;
+export declare function declarativeTemplate<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(callbacks?: TemplateLifecycleCallbacks): FASTElementTemplateResolver<TType>;

package/dist/dts/declarative/utilities.d.ts

@@ -1,5 +1,5 @@
 import { type JSONSchema, type Schema } from "../components/schema.js";
-import { eventArgAccessor, executionContextAccessor } from "./syntax.js";
+import { attributeDirectivePrefix, clientSideCloseExpression, clientSideOpenExpression, closeExpression, eventArgAccessor, executionContextAccessor, openExpression } from "./syntax.js";
 export { assignObservables, assignProxy, deepEqual, deepMerge, findDef, isPlainObject, } from "./observer-map-utilities.js";
 /**
  * Declarative behavior type.
@@ -99,7 +99,7 @@ export interface ChildrenMap {
  * @public
  */
 export declare const contextPrefixDot: string;
-export { eventArgAccessor, executionContextAccessor };
+export { attributeDirectivePrefix, clientSideCloseExpression, clientSideOpenExpression, closeExpression, eventArgAccessor, executionContextAccessor, openExpression, };
 /**
  * The type of a parsed event handler argument.
  * @public
@@ -169,6 +169,8 @@ export type ComparisonOperator = (typeof ComparisonOperator)[keyof typeof Compar
  * @public
  */
 export declare const Operator: {
+    readonly AND: "&&";
+    readonly OR: "||";
     readonly ACCESS: "access";
     readonly EQUALS: "==";
     readonly GREATER_THAN: ">";
@@ -177,8 +179,6 @@ export declare const Operator: {
     readonly LESS_THAN_OR_EQUALS: "<=";
     readonly NOT: "!";
     readonly NOT_EQUALS: "!=";
-    readonly AND: "&&";
-    readonly OR: "||";
 };
 /**
  * Declarative expression operator token.
@@ -281,6 +281,52 @@ export declare function getExpressionChain(value: string): ChainedExpression | v
  * @public
  */
 export declare function transformInnerHTML(innerHTML: string, index?: number): string;
+/**
+ * Tag name of the HTML element whose contents are auto-escaped to render
+ * code samples literally. Inside this element FAST binding delimiters
+ * (`{{...}}`, `{{{...}}}`, `{...}`) are neutralised by replacing each
+ * `{` / `}` with the HTML numeric character reference `&#123;` /
+ * `&#125;` so the literal text is rendered instead of a binding.
+ *
+ * The escape behaviour is split between the server-side renderer
+ * (`escape_code_sample_elements` in `microsoft-fast-build`) and the
+ * client-side `<f-template>` parser (`escapeBracesInCodeElements`
+ * below):
+ *
+ *  - Curly-brace escape runs in **both** server and client because
+ *    `&#123;` / `&#125;` are decoded to literal `{` / `}` in the DOM
+ *    and the `.innerHTML` serializer does not re-encode them — so the
+ *    server-side escape would otherwise be undone on the client.
+ *  - Angle brackets of FAST directive tags (`<f-when>`, `</f-when>`,
+ *    `<f-repeat>`, `</f-repeat>`, case-insensitive) inside this element
+ *    are escaped on the **server only**. The DOM serializer
+ *    re-encodes `<` / `>` in text content automatically, so the client
+ *    never sees raw directive tags inside `<code>` regardless of what
+ *    the page source contained.
+ *  - Real HTML elements (`<button>`) and custom elements (`<my-widget>`)
+ *    inside this element keep their angle brackets and continue to
+ *    render as live DOM elements; only the brace-binding syntax inside
+ *    their text and attribute values is neutralised.
+ * @public
+ */
+export declare const codeElementName = "code";
+/**
+ * Preprocess an HTML string by escaping FAST brace characters inside every
+ * `<code>` element. Mirrors part of the brace/angle-bracket escaping
+ * behaviour of Microsoft WebUI's `webui-press` markdown renderer so that
+ * example template snippets inside `<code>` render literally instead of
+ * being interpreted as bindings.
+ *
+ * Nested `<code>` elements are handled via depth tracking. The pass is
+ * idempotent because `{` / `}` inside an already-processed `<code>` have
+ * been replaced with entities, so a second pass finds nothing to escape.
+ *
+ * This is the client-side half of a two-stage escape — see the JSDoc on
+ * {@link codeElementName} for why only braces are handled here and
+ * `<` / `>` are exclusively handled on the server.
+ * @public
+ */
+export declare function escapeBracesInCodeElements(innerHTML: string): string;
 /**
  * Resolves boolean logic
  * used for f-when and boolean attributes