@microsoft/fast-element 2.9.2 → 2.10.1

package/dist/esm/components/element-controller.js

@@ -1,4 +1,4 @@
-import "../interfaces.js";
+import { Message } from "../interfaces.js";
 import { PropertyChangeNotifier } from "../observation/notifier.js";
 import { ExecutionContext, Observable, SourceLifetime, } from "../observation/observable.js";
 import { FAST, makeSerializationNoop } from "../platform.js";
@@ -22,6 +22,21 @@ function getShadowRoot(element) {
     return (_b = (_a = element.shadowRoot) !== null && _a !== void 0 ? _a : shadowRoots.get(element)) !== null && _b !== void 0 ? _b : null;
 }
 let elementControllerStrategy;
+/**
+ * The various lifecycle stages of an ElementController.
+ * @public
+ */
+export var Stages;
+(function (Stages) {
+    /** The element is in the process of connecting. */
+    Stages[Stages["connecting"] = 0] = "connecting";
+    /** The element is connected. */
+    Stages[Stages["connected"] = 1] = "connected";
+    /** The element is in the process of disconnecting. */
+    Stages[Stages["disconnecting"] = 2] = "disconnecting";
+    /** The element is disconnected. */
+    Stages[Stages["disconnected"] = 3] = "disconnected";
+})(Stages || (Stages = {}));
 /**
  * Controls the lifecycle and rendering of a `FASTElement`.
  * @public
@@ -33,7 +48,7 @@ export class ElementController extends PropertyChangeNotifier {
      */
     get isConnected() {
         Observable.track(this, isConnectedPropertyName);
-        return this.stage === 1 /* Stages.connected */;
+        return this.stage === Stages.connected;
     }
     /**
      * The context the expression is evaluated against.
@@ -168,7 +183,7 @@ export class ElementController extends PropertyChangeNotifier {
         /**
          * The current lifecycle stage of the controller.
          */
-        this.stage = 3 /* Stages.disconnected */;
+        this.stage = Stages.disconnected;
         /**
          * A guard against connecting behaviors multiple times
          * during connect in scenarios where a behavior adds
@@ -245,7 +260,7 @@ export class ElementController extends PropertyChangeNotifier {
             behavior.addedCallback && behavior.addedCallback(this);
             if (behavior.connectedCallback &&
                 !this.guardBehaviorConnection &&
-                (this.stage === 1 /* Stages.connected */ || this.stage === 0 /* Stages.connecting */)) {
+                (this.stage === Stages.connected || this.stage === Stages.connecting)) {
                 behavior.connectedCallback(this);
             }
         }
@@ -269,7 +284,7 @@ export class ElementController extends PropertyChangeNotifier {
         }
         if (count === 1 || force) {
             targetBehaviors.delete(behavior);
-            if (behavior.disconnectedCallback && this.stage !== 3 /* Stages.disconnected */) {
+            if (behavior.disconnectedCallback && this.stage !== Stages.disconnected) {
                 behavior.disconnectedCallback(this);
             }
             behavior.removedCallback && behavior.removedCallback(this);
@@ -330,10 +345,10 @@ export class ElementController extends PropertyChangeNotifier {
      * Runs connected lifecycle behavior on the associated element.
      */
     connect() {
-        if (this.stage !== 3 /* Stages.disconnected */) {
+        if (this.stage !== Stages.disconnected) {
             return;
         }
-        this.stage = 0 /* Stages.connecting */;
+        this.stage = Stages.connecting;
         this.bindObservables();
         this.connectBehaviors();
         if (this.needsInitialization) {
@@ -344,7 +359,7 @@ export class ElementController extends PropertyChangeNotifier {
         else if (this.view !== null) {
             this.view.bind(this.source);
         }
-        this.stage = 1 /* Stages.connected */;
+        this.stage = Stages.connected;
         Observable.notify(this, isConnectedPropertyName);
     }
     /**
@@ -396,16 +411,16 @@ export class ElementController extends PropertyChangeNotifier {
      * Runs disconnected lifecycle behavior on the associated element.
      */
     disconnect() {
-        if (this.stage !== 1 /* Stages.connected */) {
+        if (this.stage !== Stages.connected) {
             return;
         }
-        this.stage = 2 /* Stages.disconnecting */;
+        this.stage = Stages.disconnecting;
         Observable.notify(this, isConnectedPropertyName);
         if (this.view !== null) {
             this.view.unbind();
         }
         this.disconnectBehaviors();
-        this.stage = 3 /* Stages.disconnected */;
+        this.stage = Stages.disconnected;
     }
     /**
      * Runs the attribute changed callback for the associated element.
@@ -428,7 +443,7 @@ export class ElementController extends PropertyChangeNotifier {
      * Only emits events if connected.
      */
     emit(type, detail, options) {
-        if (this.stage === 1 /* Stages.connected */) {
+        if (this.stage === Stages.connected) {
             return this.source.dispatchEvent(new CustomEvent(type, Object.assign(Object.assign({ detail }, defaultEventOptions), options)));
         }
         return false;
@@ -482,7 +497,7 @@ export class ElementController extends PropertyChangeNotifier {
         }
         const definition = FASTElementDefinition.getForInstance(element);
         if (definition === void 0) {
-            throw FAST.error(1401 /* Message.missingElementDefinition */);
+            throw FAST.error(Message.missingElementDefinition);
         }
         Observable.getNotifier(definition).subscribe({
             handleChange: () => {
@@ -698,7 +713,12 @@ export class HydratableElementController extends ElementController {
         }
         // If there are no more hydrating instances, invoke the hydrationComplete callback
         if (((_a = HydratableElementController.hydratingInstances) === null || _a === void 0 ? void 0 : _a.size) === 0) {
-            (_c = (_b = HydratableElementController.lifecycleCallbacks) === null || _b === void 0 ? void 0 : _b.hydrationComplete) === null || _c === void 0 ? void 0 : _c.call(_b);
+            try {
+                (_c = (_b = HydratableElementController.lifecycleCallbacks).hydrationComplete) === null || _c === void 0 ? void 0 : _c.call(_b);
+            }
+            catch (_d) {
+                // A lifecycle callback must never prevent post-hydration cleanup.
+            }
             // Reset to the default strategy after hydration is complete
             ElementController.setStrategy(ElementController);
         }
@@ -707,7 +727,7 @@ export class HydratableElementController extends ElementController {
      * Runs connected lifecycle behavior on the associated element.
      */
     connect() {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g;
         // Initialize needsHydration on first connect
         this.needsHydration =
             (_a = this.needsHydration) !== null && _a !== void 0 ? _a : this.source.hasAttribute(needsHydrationAttribute);
@@ -729,17 +749,31 @@ export class HydratableElementController extends ElementController {
             this.removeHydratingInstance();
             return;
         }
-        if (this.stage !== 3 /* Stages.disconnected */) {
+        if (this.stage !== Stages.disconnected) {
             return;
         }
-        (_c = (_b = HydratableElementController.lifecycleCallbacks) === null || _b === void 0 ? void 0 : _b.elementWillHydrate) === null || _c === void 0 ? void 0 : _c.call(_b, this.definition.name);
-        this.stage = 0 /* Stages.connecting */;
+        if (!HydratableElementController.hydrationStarted) {
+            HydratableElementController.hydrationStarted = true;
+            try {
+                (_c = (_b = HydratableElementController.lifecycleCallbacks).hydrationStarted) === null || _c === void 0 ? void 0 : _c.call(_b);
+            }
+            catch (_h) {
+                // A lifecycle callback must never prevent hydration.
+            }
+        }
+        try {
+            (_e = (_d = HydratableElementController.lifecycleCallbacks).elementWillHydrate) === null || _e === void 0 ? void 0 : _e.call(_d, this.source);
+        }
+        catch (_j) {
+            // A lifecycle callback must never prevent hydration.
+        }
+        this.stage = Stages.connecting;
         this.bindObservables();
         this.connectBehaviors();
         if (this.template) {
             if (isHydratable(this.template)) {
                 const element = this.source;
-                const host = (_d = getShadowRoot(element)) !== null && _d !== void 0 ? _d : element;
+                const host = (_f = getShadowRoot(element)) !== null && _f !== void 0 ? _f : element;
                 let firstChild = host.firstChild;
                 let lastChild = host.lastChild;
                 if (element.shadowRoot === null) {
@@ -754,14 +788,14 @@ export class HydratableElementController extends ElementController {
                     }
                 }
                 this.view = this.template.hydrate(firstChild, lastChild, element);
-                (_e = this.view) === null || _e === void 0 ? void 0 : _e.bind(this.source);
+                (_g = this.view) === null || _g === void 0 ? void 0 : _g.bind(this.source);
             }
             else {
                 this.renderTemplate(this.template);
             }
         }
         this.addStyles(this.mainStyles);
-        this.stage = 1 /* Stages.connected */;
+        this.stage = Stages.connected;
         this.source.removeAttribute(needsHydrationAttribute);
         this.needsInitialization = this.needsHydration = false;
         this.removeHydratingInstance();
@@ -775,10 +809,14 @@ export class HydratableElementController extends ElementController {
         if (!HydratableElementController.hydratingInstances) {
             return;
         }
+        try {
+            (_b = (_a = HydratableElementController.lifecycleCallbacks).elementDidHydrate) === null || _b === void 0 ? void 0 : _b.call(_a, this.source);
+        }
+        catch (_c) {
+            // A lifecycle callback must never prevent hydration.
+        }
         const name = this.definition.name;
         const instances = HydratableElementController.hydratingInstances.get(name);
-        // Callback: After hydration has finished
-        (_b = (_a = HydratableElementController.lifecycleCallbacks) === null || _a === void 0 ? void 0 : _a.elementDidHydrate) === null || _b === void 0 ? void 0 : _b.call(_a, this.definition.name);
         if (instances) {
             instances.delete(this.source);
             if (!instances.size) {
@@ -808,6 +846,14 @@ export class HydratableElementController extends ElementController {
     }
 }
 HydratableElementController.hydrationObserver = new UnobservableMutationObserver(HydratableElementController.hydrationObserverHandler);
+/**
+ * Lifecycle callbacks for hydration events
+ */
+HydratableElementController.lifecycleCallbacks = {};
+/**
+ * Whether the hydrationStarted callback has already been invoked.
+ */
+HydratableElementController.hydrationStarted = false;
 /**
  * An idle callback ID used to track hydration completion
  */

package/dist/esm/components/fast-definitions.js

@@ -12,7 +12,7 @@ import { isString, KernelServiceId } from "../interfaces.js";
 import { Observable } from "../observation/observable.js";
 import { createTypeRegistry, FAST } from "../platform.js";
 import { ElementStyles } from "../styles/element-styles.js";
-import { AttributeDefinition } from "./attributes.js";
+import { AttributeConfiguration, AttributeDefinition } from "./attributes.js";
 const defaultShadowOptions = { mode: "open" };
 const defaultElementOptions = {};
 const fastElementBaseTypes = new Set();

package/dist/esm/context.js

@@ -1,4 +1,4 @@
-import "./interfaces.js";
+import { Message } from "./interfaces.js";
 import { Metadata } from "./metadata.js";
 import { FAST } from "./platform.js";
 const contextsByName = new Map();
@@ -37,7 +37,7 @@ export const Context = Object.freeze({
     create(name, initialValue) {
         const Interface = function (target, property, index) {
             if (target == null || new.target !== undefined) {
-                throw FAST.error(1501 /* Message.noRegistrationForContext */, {
+                throw FAST.error(Message.noRegistrationForContext, {
                     name: Interface.name,
                 });
             }

package/dist/esm/di/di.js

@@ -11,8 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
  * Big thanks to https://github.com/fkleuver and the https://github.com/aurelia/aurelia project
  * for the bulk of this code and many of the associated tests.
  */
-import { Context } from "../context.js";
-import "../interfaces.js";
+import { Context, ContextEvent, } from "../context.js";
+import { Message } from "../interfaces.js";
 import { Metadata } from "../metadata.js";
 import { emptyArray, FAST } from "../platform.js";
 /**
@@ -36,7 +36,7 @@ export class ResolverBuilder {
      * @returns The resolver.
      */
     instance(value) {
-        return this.registerResolver(0 /* ResolverStrategy.instance */, value);
+        return this.registerResolver(ResolverStrategy.instance, value);
     }
     /**
      * Creates a resolver that enforces a singleton lifetime.
@@ -44,7 +44,7 @@ export class ResolverBuilder {
      * @returns The resolver.
      */
     singleton(value) {
-        return this.registerResolver(1 /* ResolverStrategy.singleton */, value);
+        return this.registerResolver(ResolverStrategy.singleton, value);
     }
     /**
      * Creates a resolver that creates a new instance for every dependency request.
@@ -52,7 +52,7 @@ export class ResolverBuilder {
      * @returns - The resolver.
      */
     transient(value) {
-        return this.registerResolver(2 /* ResolverStrategy.transient */, value);
+        return this.registerResolver(ResolverStrategy.transient, value);
     }
     /**
      * Creates a resolver that invokes a callback function for every dependency resolution
@@ -61,7 +61,7 @@ export class ResolverBuilder {
      * @returns The resolver.
      */
     callback(value) {
-        return this.registerResolver(3 /* ResolverStrategy.callback */, value);
+        return this.registerResolver(ResolverStrategy.callback, value);
     }
     /**
      * Creates a resolver that invokes a callback function the first time that a dependency
@@ -71,7 +71,7 @@ export class ResolverBuilder {
      * @returns The resolver.
      */
     cachedCallback(value) {
-        return this.registerResolver(3 /* ResolverStrategy.callback */, cacheCallbackResult(value));
+        return this.registerResolver(ResolverStrategy.callback, cacheCallbackResult(value));
     }
     /**
      * Aliases the current key to a different key.
@@ -79,7 +79,7 @@ export class ResolverBuilder {
      * @returns The resolver.
      */
     aliasTo(destinationKey) {
-        return this.registerResolver(5 /* ResolverStrategy.alias */, destinationKey);
+        return this.registerResolver(ResolverStrategy.alias, destinationKey);
     }
     registerResolver(strategy, state) {
         const { container, key } = this;
@@ -111,7 +111,7 @@ export const DefaultResolver = Object.freeze({
      * @param key - The key to create the resolver for.
      */
     none(key) {
-        throw FAST.error(1512 /* Message.noDefaultResolver */, { key });
+        throw FAST.error(Message.noDefaultResolver, { key });
     },
     /**
      * Provides default singleton resolution behavior during auto-registration.
@@ -119,7 +119,7 @@ export const DefaultResolver = Object.freeze({
      * @returns The resolver.
      */
     singleton(key) {
-        return new ResolverImpl(key, 1 /* ResolverStrategy.singleton */, key);
+        return new ResolverImpl(key, ResolverStrategy.singleton, key);
     },
     /**
      * Provides default transient resolution behavior during auto-registration.
@@ -127,7 +127,7 @@ export const DefaultResolver = Object.freeze({
      * @returns The resolver.
      */
     transient(key) {
-        return new ResolverImpl(key, 2 /* ResolverStrategy.transient */, key);
+        return new ResolverImpl(key, ResolverStrategy.transient, key);
     },
 });
 /**
@@ -162,7 +162,7 @@ function createContext(nameConfigOrCallback, configuror) {
             : false;
     const Interface = function (target, property, index) {
         if (target == null || new.target !== undefined) {
-            throw FAST.error(1501 /* Message.noRegistrationForContext */, { name: Interface.name });
+            throw FAST.error(Message.noRegistrationForContext, { name: Interface.name });
         }
         if (property) {
             DI.defineProperty(target, property, Interface, respectConnection);
@@ -385,7 +385,7 @@ export const DI = Object.freeze({
                     if (respectConnection) {
                         const notifier = this.$fastController;
                         if (!notifier) {
-                            throw FAST.error(1514 /* Message.connectUpdateRequiresController */);
+                            throw FAST.error(Message.connectUpdateRequiresController);
                         }
                         const handleChange = () => {
                             const newContainer = DI.findResponsibleContainer(this);
@@ -693,7 +693,7 @@ ignore.resolve = () => undefined;
  */
 export const newInstanceForScope = createResolver((key, handler, requestor) => {
     const instance = createNewInstance(key, handler);
-    const resolver = new ResolverImpl(key, 0 /* ResolverStrategy.instance */, instance);
+    const resolver = new ResolverImpl(key, ResolverStrategy.instance, instance);
     requestor.registerResolver(key, resolver);
     return instance;
 });
@@ -711,6 +711,16 @@ function createNewInstance(key, handler) {
     return handler.getFactory(key).construct(handler);
 }
 /** @internal */
+export var ResolverStrategy;
+(function (ResolverStrategy) {
+    ResolverStrategy[ResolverStrategy["instance"] = 0] = "instance";
+    ResolverStrategy[ResolverStrategy["singleton"] = 1] = "singleton";
+    ResolverStrategy[ResolverStrategy["transient"] = 2] = "transient";
+    ResolverStrategy[ResolverStrategy["callback"] = 3] = "callback";
+    ResolverStrategy[ResolverStrategy["array"] = 4] = "array";
+    ResolverStrategy[ResolverStrategy["alias"] = 5] = "alias";
+})(ResolverStrategy || (ResolverStrategy = {}));
+/** @internal */
 export class ResolverImpl {
     constructor(key, strategy, state) {
         this.key = key;
@@ -726,9 +736,9 @@ export class ResolverImpl {
     }
     resolveAsync(handler, requestor) {
         switch (this.strategy) {
-            case 1 /* ResolverStrategy.singleton */: {
+            case ResolverStrategy.singleton: {
                 if (this.resolving) {
-                    throw FAST.error(1513 /* Message.cyclicDependency */, { name: this.state.name });
+                    throw FAST.error(Message.cyclicDependency, { name: this.state.name });
                 }
                 this.resolving = true;
                 return handler
@@ -736,16 +746,16 @@ export class ResolverImpl {
                     .constructAsync(requestor)
                     .then(instance => {
                     this.state = instance;
-                    this.strategy = 0 /* ResolverStrategy.instance */;
+                    this.strategy = ResolverStrategy.instance;
                     this.resolving = false;
                     return instance;
                 });
             }
-            case 2 /* ResolverStrategy.transient */: {
+            case ResolverStrategy.transient: {
                 // Always create transients from the requesting container
                 const factory = handler.getFactory(this.state);
                 if (factory === null) {
-                    throw FAST.error(1502 /* Message.noFactoryForResolver */, { key: this.key });
+                    throw FAST.error(Message.noFactoryForResolver, { key: this.key });
                 }
                 return factory.constructAsync(requestor);
             }
@@ -755,36 +765,36 @@ export class ResolverImpl {
     }
     resolve(handler, requestor) {
         switch (this.strategy) {
-            case 0 /* ResolverStrategy.instance */:
+            case ResolverStrategy.instance:
                 return this.state;
-            case 1 /* ResolverStrategy.singleton */: {
+            case ResolverStrategy.singleton: {
                 if (this.resolving) {
-                    throw FAST.error(1513 /* Message.cyclicDependency */, { name: this.state.name });
+                    throw FAST.error(Message.cyclicDependency, { name: this.state.name });
                 }
                 this.resolving = true;
                 this.state = handler
                     .getFactory(this.state)
                     .construct(requestor);
-                this.strategy = 0 /* ResolverStrategy.instance */;
+                this.strategy = ResolverStrategy.instance;
                 this.resolving = false;
                 return this.state;
             }
-            case 2 /* ResolverStrategy.transient */: {
+            case ResolverStrategy.transient: {
                 // Always create transients from the requesting container
                 const factory = handler.getFactory(this.state);
                 if (factory === null) {
-                    throw FAST.error(1502 /* Message.noFactoryForResolver */, { key: this.key });
+                    throw FAST.error(Message.noFactoryForResolver, { key: this.key });
                 }
                 return factory.construct(requestor);
             }
-            case 3 /* ResolverStrategy.callback */:
+            case ResolverStrategy.callback:
                 return this.state(handler, requestor, this);
-            case 4 /* ResolverStrategy.array */:
+            case ResolverStrategy.array:
                 return this.state[0].resolve(handler, requestor);
-            case 5 /* ResolverStrategy.alias */:
+            case ResolverStrategy.alias:
                 return requestor.get(this.state);
             default:
-                throw FAST.error(1503 /* Message.invalidResolverStrategy */, {
+                throw FAST.error(Message.invalidResolverStrategy, {
                     strategy: this.strategy,
                 });
         }
@@ -792,10 +802,10 @@ export class ResolverImpl {
     getFactory(container) {
         var _a, _b, _c;
         switch (this.strategy) {
-            case 1 /* ResolverStrategy.singleton */:
-            case 2 /* ResolverStrategy.transient */:
+            case ResolverStrategy.singleton:
+            case ResolverStrategy.transient:
                 return container.getFactory(this.state);
-            case 5 /* ResolverStrategy.alias */:
+            case ResolverStrategy.alias:
                 return (_c = (_b = (_a = container.getResolver(this.state)) === null || _a === void 0 ? void 0 : _a.getFactory) === null || _b === void 0 ? void 0 : _b.call(_a, container)) !== null && _c !== void 0 ? _c : null;
             default:
                 return null;
@@ -954,7 +964,7 @@ export class ContainerImpl {
         if (++this.registerDepth === 100) {
             // Most likely cause is trying to register a plain object that does not have a
             // register method and is not a class constructor
-            throw FAST.error(1504 /* Message.cannotAutoregisterDependency */);
+            throw FAST.error(Message.cannotAutoregisterDependency);
         }
         let current;
         let keys;
@@ -1003,11 +1013,11 @@ export class ContainerImpl {
             resolvers.set(key, resolver);
         }
         else if (result instanceof ResolverImpl &&
-            result.strategy === 4 /* ResolverStrategy.array */) {
+            result.strategy === ResolverStrategy.array) {
             result.state.push(resolver);
         }
         else {
-            resolvers.set(key, new ResolverImpl(key, 4 /* ResolverStrategy.array */, [result, resolver]));
+            resolvers.set(key, new ResolverImpl(key, ResolverStrategy.array, [result, resolver]));
         }
         return resolver;
     }
@@ -1077,7 +1087,7 @@ export class ContainerImpl {
                     if (current.parent == null) {
                         const registration = yield this.config.asyncRegistrationLocator(key);
                         if (!registration) {
-                            throw FAST.error(1505 /* Message.cannotResolveKey */, { key });
+                            throw FAST.error(Message.cannotResolveKey, { key });
                         }
                         const handler = isRegisterInRequester(key)
                             ? this
@@ -1091,7 +1101,7 @@ export class ContainerImpl {
                     return resolver.resolveAsync(current, this);
                 }
             }
-            throw FAST.error(1505 /* Message.cannotResolveKey */, { key });
+            throw FAST.error(Message.cannotResolveKey, { key });
         });
     }
     get(key) {
@@ -1118,7 +1128,7 @@ export class ContainerImpl {
                 return resolver.resolve(current, this);
             }
         }
-        throw FAST.error(1505 /* Message.cannotResolveKey */, { key });
+        throw FAST.error(Message.cannotResolveKey, { key });
     }
     getAll(key, searchAncestors = false) {
         validateKey(key);
@@ -1159,7 +1169,7 @@ export class ContainerImpl {
         let factory = factories.get(Type);
         if (factory === void 0) {
             if (isNativeFunction(Type)) {
-                throw FAST.error(1506 /* Message.cannotConstructNativeFunction */, {
+                throw FAST.error(Message.cannotConstructNativeFunction, {
                     name: Type.name,
                 });
             }
@@ -1175,12 +1185,12 @@ export class ContainerImpl {
     }
     jitRegister(keyAsValue, handler) {
         if (typeof keyAsValue !== "function") {
-            throw FAST.error(1507 /* Message.cannotJITRegisterNonConstructor */, {
+            throw FAST.error(Message.cannotJITRegisterNonConstructor, {
                 value: keyAsValue,
             });
         }
         if (InstrinsicTypeNames.has(keyAsValue.name)) {
-            throw FAST.error(1508 /* Message.cannotJITRegisterIntrinsic */, {
+            throw FAST.error(Message.cannotJITRegisterIntrinsic, {
                 value: keyAsValue.name,
             });
         }
@@ -1192,12 +1202,12 @@ export class ContainerImpl {
                 if (newResolver != void 0) {
                     return newResolver;
                 }
-                throw FAST.error(1510 /* Message.invalidResolver */);
+                throw FAST.error(Message.invalidResolver);
             }
             return registrationResolver;
         }
         else if (keyAsValue.$isInterface) {
-            throw FAST.error(1509 /* Message.cannotJITRegisterInterface */, {
+            throw FAST.error(Message.cannotJITRegisterInterface, {
                 value: keyAsValue.name,
             });
         }
@@ -1247,7 +1257,7 @@ export const Registration = Object.freeze({
      * @param value - The instance to return when the key is requested.
      */
     instance(key, value) {
-        return new ResolverImpl(key, 0 /* ResolverStrategy.instance */, value);
+        return new ResolverImpl(key, ResolverStrategy.instance, value);
     },
     /**
      * Creates an instance from the class.
@@ -1262,7 +1272,7 @@ export const Registration = Object.freeze({
      * @param value - The class to instantiate as a singleton when first requested.
      */
     singleton(key, value) {
-        return new ResolverImpl(key, 1 /* ResolverStrategy.singleton */, value);
+        return new ResolverImpl(key, ResolverStrategy.singleton, value);
     },
     /**
      * Creates an instance from a class.
@@ -1277,7 +1287,7 @@ export const Registration = Object.freeze({
      * @param value - The class to instantiate each time the key is requested.
      */
     transient(key, value) {
-        return new ResolverImpl(key, 2 /* ResolverStrategy.transient */, value);
+        return new ResolverImpl(key, ResolverStrategy.transient, value);
     },
     /**
      * Delegates to a callback function to provide the dependency.
@@ -1294,7 +1304,7 @@ export const Registration = Object.freeze({
      * @param callback - The function that is expected to return the dependency.
      */
     callback(key, callback) {
-        return new ResolverImpl(key, 3 /* ResolverStrategy.callback */, callback);
+        return new ResolverImpl(key, ResolverStrategy.callback, callback);
     },
     /**
      * Delegates to a callback function to provide the dependency and then caches the
@@ -1313,7 +1323,7 @@ export const Registration = Object.freeze({
      * Should all references to the resolver returned be removed, the cache will expire.
      */
     cachedCallback(key, callback) {
-        return new ResolverImpl(key, 3 /* ResolverStrategy.callback */, cacheCallbackResult(callback));
+        return new ResolverImpl(key, ResolverStrategy.callback, cacheCallbackResult(callback));
     },
     /**
      * Creates an alternate {@link Key} to retrieve an instance by.
@@ -1330,18 +1340,18 @@ export const Registration = Object.freeze({
      * @param aliasKey - The alias to the original key.
      */
     aliasTo(originalKey, aliasKey) {
-        return new ResolverImpl(aliasKey, 5 /* ResolverStrategy.alias */, originalKey);
+        return new ResolverImpl(aliasKey, ResolverStrategy.alias, originalKey);
     },
 });
 /** @internal */
 export function validateKey(key) {
     if (key === null || key === void 0) {
-        throw FAST.error(1511 /* Message.invalidKey */);
+        throw FAST.error(Message.invalidKey);
     }
 }
 function buildAllResponse(resolver, handler, requestor) {
     if (resolver instanceof ResolverImpl &&
-        resolver.strategy === 4 /* ResolverStrategy.array */) {
+        resolver.strategy === ResolverStrategy.array) {
         const state = resolver.state;
         let i = state.length;
         const results = new Array(i);

package/dist/esm/dom-policy.js

@@ -1,5 +1,5 @@
 import { DOMAspect } from "./dom.js";
-import { isString } from "./interfaces.js";
+import { isString, Message } from "./interfaces.js";
 import { FAST } from "./platform.js";
 function safeURL(tagName, aspect, aspectName, sink) {
     return (target, name, value, ...rest) => {
@@ -10,7 +10,7 @@ function safeURL(tagName, aspect, aspectName, sink) {
     };
 }
 function block(tagName, aspect, aspectName, sink) {
-    throw FAST.error(1209 /* Message.blockedByDOMPolicy */, {
+    throw FAST.error(Message.blockedByDOMPolicy, {
         aspectName,
         tagName: tagName !== null && tagName !== void 0 ? tagName : "text",
     });

package/dist/esm/dom.js

@@ -1,4 +1,4 @@
-import "./interfaces.js";
+import { Message } from "./interfaces.js";
 import { FAST } from "./platform.js";
 /**
  * The type of HTML aspect to target.
@@ -67,7 +67,7 @@ export const DOM = Object.freeze({
      */
     setPolicy(value) {
         if (defaultPolicy !== fastPolicy) {
-            throw FAST.error(1201 /* Message.onlySetDOMPolicyOnce */);
+            throw FAST.error(Message.onlySetDOMPolicyOnce);
         }
         defaultPolicy = value;
     },