@microsoft/fast-element 2.9.1 → 2.10.0

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;
@@ -902,6 +912,18 @@ const factories = new Map();
  * @internal
  */
 export class ContainerImpl {
+    get parent() {
+        if (this._parent === void 0) {
+            this._parent = this.config.parentLocator(this.owner);
+        }
+        return this._parent;
+    }
+    get depth() {
+        return this.parent === null ? 0 : this.parent.depth + 1;
+    }
+    get responsibleForOwnerRequests() {
+        return this.config.responsibleForOwnerRequests;
+    }
     constructor(owner, config) {
         this.owner = owner;
         this.config = config;
@@ -935,18 +957,6 @@ export class ContainerImpl {
             }
         }
     }
-    get parent() {
-        if (this._parent === void 0) {
-            this._parent = this.config.parentLocator(this.owner);
-        }
-        return this._parent;
-    }
-    get depth() {
-        return this.parent === null ? 0 : this.parent.depth + 1;
-    }
-    get responsibleForOwnerRequests() {
-        return this.config.responsibleForOwnerRequests;
-    }
     handleContextRequests(enable) {
         this.isHandlingContextRequests = enable;
     }
@@ -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;
     },

package/dist/esm/index.js

@@ -1,40 +1,39 @@
-export { FAST, emptyArray } from "./platform.js";
+export { emptyArray, FAST } from "./platform.js";
 // DOM
-export { DOMAspect, DOM } from "./dom.js";
+export { DOM, DOMAspect } from "./dom.js";
 // Observation
-export { ExecutionContext, Observable, observable, SourceLifetime, volatile, } from "./observation/observable.js";
+export { ArrayObserver, lengthOf, Sort, sortedCount, Splice, SpliceStrategy, SpliceStrategySupport, } from "./observation/arrays.js";
 export { PropertyChangeNotifier, SubscriberSet, } from "./observation/notifier.js";
-export { ArrayObserver, lengthOf, Splice, SpliceStrategy, SpliceStrategySupport, Sort, sortedCount, } from "./observation/arrays.js";
+export { ExecutionContext, Observable, observable, SourceLifetime, volatile, } from "./observation/observable.js";
 export { Updates } from "./observation/update-queue.js";
 // Binding
 export { Binding } from "./binding/binding.js";
-export { listener, oneWay } from "./binding/one-way.js";
-export { oneTime } from "./binding/one-time.js";
 export { normalizeBinding } from "./binding/normalize.js";
+export { oneTime } from "./binding/one-time.js";
+export { listener, oneWay } from "./binding/one-way.js";
 // Styles
-export { ElementStyles, } from "./styles/element-styles.js";
-export { css } from "./styles/css.js";
+export { CSSBindingDirective } from "./styles/css-binding-directive.js";
 export { cssDirective, CSSDirective, } from "./styles/css-directive.js";
+export { css } from "./styles/css.js";
+export { ElementStyles, } from "./styles/element-styles.js";
 export {} from "./styles/host.js";
-export {} from "./styles/style-strategy.js";
-export { CSSBindingDirective } from "./styles/css-binding-directive.js";
 // Templating
-export { html, InlineTemplateDirective, ViewTemplate, } from "./templating/template.js";
+export { children, ChildrenDirective } from "./templating/children.js";
 export { Compiler } from "./templating/compiler.js";
-export { Markup, Parser } from "./templating/markup.js";
-export { HTMLBindingDirective, } from "./templating/html-binding-directive.js";
+export { HTMLBindingDirective } from "./templating/html-binding-directive.js";
 export { htmlDirective, HTMLDirective, StatelessAttachedAttributeDirective, } from "./templating/html-directive.js";
+export { Markup, Parser } from "./templating/markup.js";
+export { elements, NodeObservationDirective } from "./templating/node-observation.js";
 export { ref, RefDirective } from "./templating/ref.js";
-export { when } from "./templating/when.js";
-export { repeat, RepeatBehavior, RepeatDirective, } from "./templating/repeat.js";
-export { slotted, SlottedDirective, } from "./templating/slotted.js";
-export { children, ChildrenDirective, } from "./templating/children.js";
-export { HTMLView, HydrationBindingError, } from "./templating/view.js";
-export { elements, NodeObservationDirective, } from "./templating/node-observation.js";
 export { render, RenderBehavior, RenderDirective } from "./templating/render.js";
+export { repeat, RepeatBehavior, RepeatDirective } from "./templating/repeat.js";
+export { slotted, SlottedDirective } from "./templating/slotted.js";
+export { html, InlineTemplateDirective, ViewTemplate } from "./templating/template.js";
+export { HTMLView, HydrationBindingError } from "./templating/view.js";
+export { when } from "./templating/when.js";
 // Components
-export { customElement, FASTElement } from "./components/fast-element.js";
-export { FASTElementDefinition, fastElementRegistry, TemplateOptions, } from "./components/fast-definitions.js";
 export { attr, AttributeConfiguration, AttributeDefinition, booleanConverter, nullableBooleanConverter, nullableNumberConverter, } from "./components/attributes.js";
-export { ElementController, HydratableElementController, needsHydrationAttribute, } from "./components/element-controller.js";
+export { ElementController, HydratableElementController, needsHydrationAttribute, Stages, } from "./components/element-controller.js";
+export { FASTElementDefinition, fastElementRegistry, TemplateOptions, } from "./components/fast-definitions.js";
+export { customElement, FASTElement } from "./components/fast-element.js";
 export { deferHydrationAttribute, isHydratable } from "./components/hydration.js";

package/dist/esm/interfaces.js

@@ -43,6 +43,44 @@ switch (kernelMode) {
         break;
 }
 export { KernelServiceId };
+/**
+ * Warning and error messages.
+ * @internal
+ */
+export var Message;
+(function (Message) {
+    // 1000 - 1100 Kernel
+    // 1101 - 1200 Observation
+    Message[Message["needsArrayObservation"] = 1101] = "needsArrayObservation";
+    // 1201 - 1300 Templating
+    Message[Message["onlySetDOMPolicyOnce"] = 1201] = "onlySetDOMPolicyOnce";
+    Message[Message["bindingInnerHTMLRequiresTrustedTypes"] = 1202] = "bindingInnerHTMLRequiresTrustedTypes";
+    Message[Message["twoWayBindingRequiresObservables"] = 1203] = "twoWayBindingRequiresObservables";
+    Message[Message["hostBindingWithoutHost"] = 1204] = "hostBindingWithoutHost";
+    Message[Message["unsupportedBindingBehavior"] = 1205] = "unsupportedBindingBehavior";
+    Message[Message["directCallToHTMLTagNotAllowed"] = 1206] = "directCallToHTMLTagNotAllowed";
+    Message[Message["onlySetTemplatePolicyOnce"] = 1207] = "onlySetTemplatePolicyOnce";
+    Message[Message["cannotSetTemplatePolicyAfterCompilation"] = 1208] = "cannotSetTemplatePolicyAfterCompilation";
+    Message[Message["blockedByDOMPolicy"] = 1209] = "blockedByDOMPolicy";
+    // 1301 - 1400 Styles
+    // 1401 - 1500 Components
+    Message[Message["missingElementDefinition"] = 1401] = "missingElementDefinition";
+    // 1501 - 1600 Context and Dependency Injection
+    Message[Message["noRegistrationForContext"] = 1501] = "noRegistrationForContext";
+    Message[Message["noFactoryForResolver"] = 1502] = "noFactoryForResolver";
+    Message[Message["invalidResolverStrategy"] = 1503] = "invalidResolverStrategy";
+    Message[Message["cannotAutoregisterDependency"] = 1504] = "cannotAutoregisterDependency";
+    Message[Message["cannotResolveKey"] = 1505] = "cannotResolveKey";
+    Message[Message["cannotConstructNativeFunction"] = 1506] = "cannotConstructNativeFunction";
+    Message[Message["cannotJITRegisterNonConstructor"] = 1507] = "cannotJITRegisterNonConstructor";
+    Message[Message["cannotJITRegisterIntrinsic"] = 1508] = "cannotJITRegisterIntrinsic";
+    Message[Message["cannotJITRegisterInterface"] = 1509] = "cannotJITRegisterInterface";
+    Message[Message["invalidResolver"] = 1510] = "invalidResolver";
+    Message[Message["invalidKey"] = 1511] = "invalidKey";
+    Message[Message["noDefaultResolver"] = 1512] = "noDefaultResolver";
+    Message[Message["cyclicDependency"] = 1513] = "cyclicDependency";
+    Message[Message["connectUpdateRequiresController"] = 1514] = "connectUpdateRequiresController";
+})(Message || (Message = {}));
 /**
  * Determines whether or not an object is a function.
  * @public

package/dist/esm/observable.js

@@ -2,4 +2,4 @@
  * Observable exports for easy access to the Observable API
  */
 export { ExecutionContext, Observable, observable, SourceLifetime, volatile, } from "./observation/observable.js";
-export { PropertyChangeNotifier, SubscriberSet, } from "./observation/notifier.js";
+export { PropertyChangeNotifier, SubscriberSet } from "./observation/notifier.js";