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

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

@@ -0,0 +1,98 @@
+import type { Schema } from "../components/schema.js";
+import { ViewTemplate } from "../templating/template.js";
+/**
+ * The return type for {@link TemplateParser.parse}.
+ * @public
+ */
+export interface ResolvedStringsAndValues {
+    strings: Array<string>;
+    values: Array<any>;
+}
+/**
+ * Converts declarative HTML template markup into the `strings` and `values`
+ * arrays that `ViewTemplate.create()` consumes.
+ *
+ * This class is intentionally stateless across invocations — all mutable
+ * parsing state lives on the call stack or in the `TemplateResolutionContext`.
+ *
+ * The parsing pipeline is fully synchronous — no promises are allocated
+ * during template resolution.
+ * @public
+ */
+export declare class TemplateParser {
+    /**
+     * Parse declarative HTML into strings and values for ViewTemplate creation.
+     * @param innerHTML - The transformed innerHTML to parse.
+     * @param schema - The Schema instance for property tracking.
+     * @returns The resolved strings and values.
+     */
+    parse(innerHTML: string, schema: Schema): ResolvedStringsAndValues;
+    /**
+     * Create a ViewTemplate from resolved strings and values.
+     * @param strings - The strings array.
+     * @param values - The interpreted values.
+     */
+    createTemplate(strings: Array<string>, values: Array<any>): ViewTemplate<any, any>;
+    /**
+     * Resolve strings and values from an innerHTML string.
+     * @param rootPropertyName - The root property name for schema registration.
+     * @param innerHTML - The innerHTML.
+     * @param context - The template resolution context.
+     */
+    private resolveStringsAndValues;
+    /**
+     * Resolve a template directive (when/repeat).
+     * @param rootPropertyName - The root property name for schema registration.
+     * @param behaviorConfig - The directive behavior configuration object.
+     * @param externalValues - The interpreted values from the parent.
+     * @param innerHTML - The innerHTML.
+     * @param context - The template resolution context.
+     */
+    private resolveTemplateDirective;
+    /**
+     * Resolve an attribute directive (children/slotted/ref).
+     * @param name - The name of the directive.
+     * @param propName - The property name to pass to the directive.
+     * @param externalValues - The interpreted values from the parent.
+     */
+    private resolveAttributeDirective;
+    /**
+     * Resolve an access binding — shared by content bindings, boolean-attribute
+     * fallback, and default attribute bindings.
+     * @returns An object with the resolved binding function and the updated rootPropertyName.
+     */
+    private resolveAccessBinding;
+    /**
+     * Resolve an event binding (the "\@" aspect).
+     * @returns An object with the event binding function and the updated rootPropertyName.
+     */
+    private resolveEventBinding;
+    /**
+     * Resolve a content data binding (`{{expression}}` in text content).
+     */
+    private resolveContentBinding;
+    /**
+     * Resolve an attribute data binding (`{{expression}}` in an HTML attribute).
+     * Dispatches to event, expression, or access binding handlers based on aspect.
+     */
+    private resolveAttributeBinding;
+    /**
+     * Resolve an attribute directive binding (`f-children`, `f-slotted`, `f-ref`).
+     */
+    private resolveAttributeDirectiveBinding;
+    /**
+     * Dispatcher for data binding resolution. Routes to the appropriate handler
+     * based on the binding subtype.
+     */
+    private resolveDataBinding;
+    /**
+     * Resolver of the innerHTML string. Finds the next binding or directive
+     * in the HTML and dispatches to the appropriate handler.
+     * @param rootPropertyName - The root property name for schema registration.
+     * @param innerHTML - The innerHTML to parse.
+     * @param strings - Accumulator for literal HTML segments and running previous-string.
+     * @param values - The values array (accumulates binding functions and directives).
+     * @param context - The template resolution context.
+     */
+    private resolveInnerHTML;
+}

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

@@ -0,0 +1,10 @@
+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`.
+ *
+ * @param callbacks - Optional per-element lifecycle callbacks.
+ * @public
+ */
+export declare function declarativeTemplate<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(callbacks?: TemplateLifecycleCallbacks): FASTElementTemplateResolver<TType>;

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

@@ -0,0 +1,358 @@
+import { type JSONSchema, type Schema } from "../components/schema.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.
+ * @public
+ */
+export type BehaviorType = "dataBinding" | "templateDirective";
+/**
+ * Declarative attribute directive names.
+ * @public
+ */
+export type AttributeDirective = "children" | "slotted" | "ref";
+/**
+ * Declarative data binding marker type.
+ * @public
+ */
+export type DataBindingBindingType = "client" | "default" | "unescaped";
+/**
+ * Base behavior configuration.
+ * @public
+ */
+export interface BehaviorConfig {
+    type: BehaviorType;
+}
+/**
+ * Declarative schema path type.
+ * @public
+ */
+export type PathType = "access" | "default" | "event" | "repeat";
+/**
+ * Content binding behavior configuration.
+ * @public
+ */
+export interface ContentDataBindingBehaviorConfig extends BaseDataBindingBehaviorConfig {
+    subtype: "content";
+}
+/**
+ * Attribute binding behavior configuration.
+ * @public
+ */
+export interface AttributeDataBindingBehaviorConfig extends BaseDataBindingBehaviorConfig {
+    subtype: "attribute";
+    aspect: "@" | ":" | "?" | null;
+}
+/**
+ * Attribute directive binding behavior configuration.
+ * @public
+ */
+export interface AttributeDirectiveBindingBehaviorConfig extends BaseDataBindingBehaviorConfig {
+    subtype: "attributeDirective";
+    name: AttributeDirective;
+}
+/**
+ * Declarative data binding behavior configuration.
+ * @public
+ */
+export type DataBindingBehaviorConfig = ContentDataBindingBehaviorConfig | AttributeDataBindingBehaviorConfig | AttributeDirectiveBindingBehaviorConfig;
+/**
+ * Base data binding behavior configuration.
+ * @public
+ */
+export interface BaseDataBindingBehaviorConfig extends BehaviorConfig {
+    type: "dataBinding";
+    bindingType: DataBindingBindingType;
+    openingStartIndex: number;
+    openingEndIndex: number;
+    closingStartIndex: number;
+    closingEndIndex: number;
+}
+/**
+ * Declarative template directive names.
+ * @public
+ */
+export type TemplateDirective = "when" | "repeat";
+/**
+ * Template directive behavior configuration.
+ * @public
+ */
+export interface TemplateDirectiveBehaviorConfig extends BehaviorConfig {
+    type: "templateDirective";
+    name: TemplateDirective;
+    value: string;
+    openingTagStartIndex: number;
+    openingTagEndIndex: number;
+    closingTagStartIndex: number;
+    closingTagEndIndex: number;
+}
+/**
+ * Map between child component attribute references and custom element names.
+ * @public
+ */
+export interface ChildrenMap {
+    customElementName: string;
+    attributeName: string;
+}
+/**
+ * Prefix used for execution context paths.
+ * @public
+ */
+export declare const contextPrefixDot: string;
+export { attributeDirectivePrefix, clientSideCloseExpression, clientSideOpenExpression, closeExpression, eventArgAccessor, executionContextAccessor, openExpression, };
+/**
+ * The type of a parsed event handler argument.
+ * @public
+ */
+export type EventArgType = "event" | "context" | "binding";
+/**
+ * A parsed event handler argument descriptor.
+ * @public
+ */
+export interface ParsedEventArg {
+    type: EventArgType;
+    /** The raw argument string, present only when `type` is `"binding"`. */
+    rawArg?: string;
+}
+/**
+ * Parses the arguments string of an event handler binding into an array of
+ * typed argument descriptors. Unrecognised tokens are returned as `"binding"`
+ * type with their raw string preserved.
+ *
+ * Special arguments:
+ * - `$e` — resolves to the DOM event object
+ * - `$c` — resolves to the full execution context object
+ *
+ * Any other token is treated as a binding path and resolved against the current
+ * data source.
+ *
+ * @param argsString - The raw arguments string from between the parentheses,
+ *   e.g. `""`, `"$e"`, `"$c"`, or `"$e, $c"`.
+ * @returns An array of {@link ParsedEventArg} descriptors.
+ * @public
+ */
+export declare function parseEventArgs(argsString: string): ParsedEventArg[];
+/**
+ * Logical operator tokens.
+ * @public
+ */
+export declare const LogicalOperator: {
+    readonly AND: "&&";
+    readonly OR: "||";
+};
+/**
+ * Logical operator token.
+ * @public
+ */
+export type LogicalOperator = (typeof LogicalOperator)[keyof typeof LogicalOperator];
+/**
+ * Comparison operator tokens.
+ * @public
+ */
+export declare const ComparisonOperator: {
+    readonly ACCESS: "access";
+    readonly EQUALS: "==";
+    readonly GREATER_THAN: ">";
+    readonly GREATER_THAN_OR_EQUALS: ">=";
+    readonly LESS_THAN: "<";
+    readonly LESS_THAN_OR_EQUALS: "<=";
+    readonly NOT: "!";
+    readonly NOT_EQUALS: "!=";
+};
+/**
+ * Comparison operator token.
+ * @public
+ */
+export type ComparisonOperator = (typeof ComparisonOperator)[keyof typeof ComparisonOperator];
+/**
+ * Declarative expression operator tokens.
+ * @public
+ */
+export declare const Operator: {
+    readonly AND: "&&";
+    readonly OR: "||";
+    readonly ACCESS: "access";
+    readonly EQUALS: "==";
+    readonly GREATER_THAN: ">";
+    readonly GREATER_THAN_OR_EQUALS: ">=";
+    readonly LESS_THAN: "<";
+    readonly LESS_THAN_OR_EQUALS: "<=";
+    readonly NOT: "!";
+    readonly NOT_EQUALS: "!=";
+};
+/**
+ * Declarative expression operator token.
+ * @public
+ */
+export type Operator = (typeof Operator)[keyof typeof Operator];
+/**
+ * Get the index of the next matching tag
+ * @param openingTagStartSlice - The slice starting from the opening tag
+ * @param openingTag - The opening tag string
+ * @param closingTag - The closing tag
+ * @param openingTagStartIndex - The opening tag start index derived from the innerHTML
+ * @returns index
+ * @public
+ */
+export declare function getIndexOfNextMatchingTag(openingTagStartSlice: string, openingTag: string, closingTag: string, openingTagStartIndex: number): number;
+/**
+ * Get the next behavior
+ * @param innerHTML - The innerHTML string to evaluate
+ * @param offset - The current offset in the original string.
+ * @returns DataBindingBehaviorConfig | DirectiveBehaviorConfig | null - A configuration object or null
+ * @public
+ */
+export declare function getNextBehavior(innerHTML: string, offset?: number): DataBindingBehaviorConfig | TemplateDirectiveBehaviorConfig | null;
+/**
+ * Create a function to resolve a value from an object using a path with dot syntax.
+ * e.g. "foo.bar"
+ * @param path - The dot syntax path to an objects property.
+ * @param contextPath - The current repeat context path.
+ * @param level - The current repeat nesting level.
+ * @param rootSchema - The root schema for resolving context paths.
+ * @returns A function to access the value from a given path.
+ * @public
+ */
+export declare function pathResolver(path: string, contextPath: string | null, level: number, rootSchema: JSONSchema): (accessibleObject: any, context: any) => any;
+/**
+ * Creates a binding resolver and records the binding path in the schema.
+ * @param previousString - The previous literal string before the binding.
+ * @param rootPropertyName - The current root property name.
+ * @param path - The binding path to resolve.
+ * @param parentContext - The parent repeat context.
+ * @param type - The schema path type.
+ * @param schema - The schema to record paths in.
+ * @param currentContext - The current repeat context.
+ * @param level - The current repeat nesting level.
+ * @returns A function that resolves the binding path.
+ * @public
+ */
+export declare function bindingResolver(previousString: string | null, rootPropertyName: string | null, path: string, parentContext: string | null, type: PathType, schema: Schema, currentContext: string | null, level: number): (accessibleObject: any, context: any) => any;
+/**
+ * Creates a resolver for a chained expression and records its paths in the schema.
+ * @param rootPropertyName - The current root property name.
+ * @param expression - The expression to resolve.
+ * @param parentContext - The parent repeat context.
+ * @param level - The current repeat nesting level.
+ * @param schema - The schema to record paths in.
+ * @returns A function that resolves the expression.
+ * @public
+ */
+export declare function expressionResolver(rootPropertyName: string | null, expression: ChainedExpression, parentContext: string | null, level: number, schema: Schema): (accessibleObject: any, context: any) => any;
+/**
+ * Extracts all paths from a ChainedExpression, including nested expressions
+ * @param chainedExpression - The chained expression to extract paths from
+ * @returns A Set containing all unique paths found in the expression chain
+ * @public
+ */
+export declare function extractPathsFromChainedExpression(chainedExpression: ChainedExpression): Set<string>;
+/**
+ * Declarative expression descriptor.
+ * @public
+ */
+export interface DeclarativeExpression {
+    operator: Operator;
+    left: string;
+    leftIsValue: boolean | null;
+    right: string | boolean | number | null;
+    rightIsValue: boolean | null;
+}
+/**
+ * Declarative chained expression descriptor.
+ * @public
+ */
+export interface ChainedExpression {
+    operator?: LogicalOperator;
+    expression: DeclarativeExpression;
+    next?: ChainedExpression;
+}
+/**
+ * Gets the expression chain as a configuration object
+ * @param value - The binding string value
+ * @returns - A configuration object containing information about the expression
+ * @public
+ */
+export declare function getExpressionChain(value: string): ChainedExpression | void;
+/**
+ * This is the transform utility for rationalizing declarative HTML syntax
+ * with bindings in the ViewTemplate
+ * @param innerHTML - The innerHTML to transform.
+ * @param index - The index to start the current slice of HTML to evaluate.
+ * @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
+ * @param rootPropertyName - The current root property name.
+ * @param expression - The chained expression to resolve.
+ * @param parentContext - The parent repeat context.
+ * @param level - The current repeat nesting level.
+ * @param schema - The schema to record paths in.
+ * @returns - A binding that resolves the chained expression logic
+ * @public
+ */
+export declare function getBooleanBinding(rootPropertyName: string | null, expression: ChainedExpression, parentContext: string | null, level: number, schema: Schema): (x: boolean, c: any) => any;
+/**
+ * Get the root property name
+ * @param rootPropertyName - The root property
+ * @param path - The dot syntax path
+ * @param context - The context created by a repeat
+ * @param type - The type of path binding
+ * @returns
+ * @public
+ */
+export declare function getRootPropertyName(rootPropertyName: string | null, path: string, context: null | string, type: PathType): string | null;
+/**
+ * Get details of bindings to the attributes of child custom elements
+ * @param previousString - The previous string before the binding
+ * @returns null, or a custom element name and attribute name
+ * @public
+ */
+export declare function getChildrenMap(previousString: string | null): ChildrenMap | null;

package/dist/dts/di/di.d.ts

@@ -390,7 +390,7 @@ export interface InterfaceConfiguration {
     friendlyName?: string;
     /**
      * When true, the dependency will be re-resolved when FASTElement connection changes.
-     * If the resolved value changes due to connection change, a {@link @microsoft/fast-element#Observable | notification }
+     * If the resolved value changes due to connection change, an observable notification
      * will be emitted for the property, with the previous and next values provided to any subscriber.
      */
     respectConnection?: boolean;
@@ -537,7 +537,7 @@ export declare const DI: Readonly<{
      *
      * @public
      */
-    singleton<T_1 extends Constructable>(target: T_1 & Partial<RegisterSelf<T_1>>, options?: SingletonOptions): T_1 & RegisterSelf<T_1>;
+    singleton<T extends Constructable>(target: T & Partial<RegisterSelf<T>>, options?: SingletonOptions): T & RegisterSelf<T>;
 }>;
 /**
  * The key that resolves the dependency injection Container itself.
@@ -827,7 +827,7 @@ export declare const Registration: Readonly<{
      * @param key - The key to register the singleton under.
      * @param value - The class to instantiate as a singleton when first requested.
      */
-    singleton<T_1 extends Constructable>(key: Key, value: T_1): Registration<InstanceType<T_1>>;
+    singleton<T extends Constructable>(key: Key, value: T): Registration<InstanceType<T>>;
     /**
      * Creates an instance from a class.
      * Every time you request this {@link Key} you will get a new instance.
@@ -840,7 +840,7 @@ export declare const Registration: Readonly<{
      * @param key - The key to register the instance type under.
      * @param value - The class to instantiate each time the key is requested.
      */
-    transient<T_2 extends Constructable>(key: Key, value: T_2): Registration<InstanceType<T_2>>;
+    transient<T extends Constructable>(key: Key, value: T): Registration<InstanceType<T>>;
     /**
      * Delegates to a callback function to provide the dependency.
      * Every time you request this {@link Key} the callback will be invoked to provide
@@ -855,7 +855,7 @@ export declare const Registration: Readonly<{
      * @param key - The key to register the callback for.
      * @param callback - The function that is expected to return the dependency.
      */
-    callback<T_3>(key: Key, callback: ResolveCallback<T_3>): Registration<Resolved<T_3>>;
+    callback<T>(key: Key, callback: ResolveCallback<T>): Registration<Resolved<T>>;
     /**
      * Delegates to a callback function to provide the dependency and then caches the
      * dependency for future requests.
@@ -872,7 +872,7 @@ export declare const Registration: Readonly<{
      * If you pass the same Registration to another container, the same cached value will be used.
      * Should all references to the resolver returned be removed, the cache will expire.
      */
-    cachedCallback<T_4>(key: Key, callback: ResolveCallback<T_4>): Registration<Resolved<T_4>>;
+    cachedCallback<T>(key: Key, callback: ResolveCallback<T>): Registration<Resolved<T>>;
     /**
      * Creates an alternate {@link Key} to retrieve an instance by.
      *
@@ -887,7 +887,7 @@ export declare const Registration: Readonly<{
      * @param originalKey - The original key that has been registered.
      * @param aliasKey - The alias to the original key.
      */
-    aliasTo<T_5>(originalKey: T_5, aliasKey: Key): Registration<Resolved<T_5>>;
+    aliasTo<T>(originalKey: T, aliasKey: Key): Registration<Resolved<T>>;
 }>;
 /** @internal */
 export declare function validateKey(key: any): void;

package/dist/dts/directives/children.d.ts

@@ -0,0 +1,2 @@
+export { type ChildListDirectiveOptions, ChildrenDirective, type ChildrenDirectiveOptions, children, type SubtreeDirectiveOptions, } from "../templating/children.js";
+export type { CaptureType } from "../templating/template.js";

package/dist/dts/directives/node-observation.d.ts

@@ -0,0 +1,2 @@
+export { type ElementsFilter, elements, type NodeBehaviorOptions, NodeObservationDirective, } from "../templating/node-observation.js";
+export type { CaptureType } from "../templating/template.js";

package/dist/dts/directives/ref.d.ts

@@ -0,0 +1,2 @@
+export { RefDirective, ref } from "../templating/ref.js";
+export type { CaptureType } from "../templating/template.js";

package/dist/dts/directives/repeat.d.ts

@@ -0,0 +1,4 @@
+export type { Binding } from "../binding/binding.js";
+export type { Expression } from "../observation/observable.js";
+export { RepeatBehavior, RepeatDirective, type RepeatOptions, repeat, } from "../templating/repeat.js";
+export type { CaptureType, ViewTemplate } from "../templating/template.js";

package/dist/dts/directives/slotted.d.ts

@@ -0,0 +1,2 @@
+export { SlottedDirective, type SlottedDirectiveOptions, slotted, } from "../templating/slotted.js";
+export type { CaptureType } from "../templating/template.js";

package/dist/dts/directives/when.d.ts

@@ -0,0 +1,3 @@
+export type { ExecutionContext, Expression } from "../observation/observable.js";
+export type { CaptureType, SyntheticViewTemplate } from "../templating/template.js";
+export { when } from "../templating/when.js";

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

@@ -1,5 +1,24 @@
-import { DOMAspect, type DOMSink, type DOMPolicy as IDOMPolicy } from "./dom.js";
+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
@@ -72,12 +91,11 @@ export type DOMPolicyOptions = {
  * A helper for creating DOM policies.
  * @public
  */
-declare const DOMPolicy: Readonly<{
+export declare const DOMPolicy: Readonly<{
     /**
      * Creates a new DOM Policy object.
-     * @param options The options to use in creating the policy.
+     * @param options - The options to use in creating the policy.
      * @returns The newly created DOMPolicy.
      */
-    create(options?: DOMPolicyOptions): Readonly<IDOMPolicy>;
+    create(options?: DOMPolicyOptions): Readonly<DOMPolicy>;
 }>;
-export { DOMPolicy };

package/dist/dts/dom.d.ts

@@ -1,3 +1,4 @@
+import type { DOMPolicy as DOMPolicyDefinition } from "./dom-policy.js";
 /**
  * The type of HTML aspect to target.
  * @public
@@ -46,20 +47,7 @@ export type DOMSink = (target: Node, aspectName: string, value: any, ...args: an
  * A security policy that FAST can use to interact with the DOM.
  * @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;
+export interface DOMPolicy extends DOMPolicyDefinition {
 }
 /**
  * Common DOM APIs.
@@ -69,7 +57,7 @@ export declare const DOM: Readonly<{
     /**
      * Gets the dom policy used by the templating system.
      */
-    readonly policy: DOMPolicy;
+    readonly policy: DOMPolicyDefinition;
     /**
      * Sets the dom policy used by the templating system.
      * @param policy - The policy to set.
@@ -77,7 +65,7 @@ export declare const DOM: Readonly<{
      * 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: DOMPolicy): void;
+    setPolicy(value: DOMPolicyDefinition): void;
     /**
      * Sets an attribute value on an element.
      * @param element - The element to set the attribute value on.

package/dist/dts/html.d.ts

@@ -0,0 +1,5 @@
+export type { Binding } from "./binding/binding.js";
+export type { DOMPolicy } from "./dom.js";
+export type { Expression } from "./observation/observable.js";
+export { type ElementViewTemplate, type HTMLTemplateCompilationResult, type HTMLTemplateTag, html, InlineTemplateDirective, type SyntheticViewTemplate, type TemplateValue, ViewTemplate, } from "./templating/template.js";
+export { type ElementView, HTMLView, type SyntheticView } from "./templating/view.js";