lwc 2.35.1 → 2.35.2

package/dist/engine-dom/iife/es2017/engine-dom_debug.js

@@ -32,10 +32,10 @@ var LWC = (function (exports) {
 
   var assert = /*#__PURE__*/Object.freeze({
       __proto__: null,
+      fail: fail,
       invariant: invariant,
-      isTrue: isTrue$1,
       isFalse: isFalse$1,
-      fail: fail
+      isTrue: isTrue$1
   });
 
   /*
@@ -321,7 +321,7 @@ var LWC = (function (exports) {
       CACHED_ATTRIBUTE_PROPERTY_MAPPING.set(attrName, propertyName);
       return propertyName;
   }
-  /** version: 2.35.1 */
+  /** version: 2.35.2 */
 
   /**
    * Copyright (C) 2018 salesforce.com, inc.
@@ -389,7 +389,7 @@ var LWC = (function (exports) {
    */
   function setFeatureFlagForTest(name, value) {
   }
-  /** version: 2.35.1 */
+  /** version: 2.35.2 */
 
   /**
    * Copyright (C) 2018 salesforce.com, inc.
@@ -453,7 +453,7 @@ var LWC = (function (exports) {
           }
       }
   }
-  /** version: 2.35.1 */
+  /** version: 2.35.2 */
 
   /*
    * Copyright (c) 2018, salesforce.com, inc.
@@ -5976,7 +5976,7 @@ var LWC = (function (exports) {
   const cachedConstructors = new Map();
   const elementsUpgradedOutsideLWC = new WeakSet();
   let elementBeingUpgradedByLWC = false;
-  // Creates a constructor that is intended to be used as a vanilla custom element, except that the upgradeCallback is
+  // Creates a constructor that is intended to be used directly as a custom element, except that the upgradeCallback is
   // passed in to the constructor so LWC can reuse the same custom element constructor for multiple components.
   // Another benefit is that only LWC can create components that actually do anything – if you do
   // `customElements.define('x-foo')`, then you don't have access to the upgradeCallback, so it's a dummy custom element.
@@ -6021,7 +6021,7 @@ var LWC = (function (exports) {
       }
       return UpgradableConstructor;
   };
-  const createCustomElementVanilla = (tagName, upgradeCallback, connectedCallback, disconnectedCallback) => {
+  const createCustomElementUsingUpgradableConstructor = (tagName, upgradeCallback, connectedCallback, disconnectedCallback) => {
       // use global custom elements registry
       let UpgradableConstructor = cachedConstructors.get(tagName);
       if (isUndefined$1(UpgradableConstructor)) {
@@ -6049,7 +6049,7 @@ var LWC = (function (exports) {
    */
   /**
    * Create a scoped registry, i.e. a function that can create custom elements whose tag names
-   * do not conflict with vanilla custom elements having the same tag name.
+   * do not conflict with third-party custom elements having the same tag name.
    */
   function createScopedRegistry() {
       if (!hasCustomElements) {
@@ -6590,10 +6590,10 @@ var LWC = (function (exports) {
    * We have three modes for creating custom elements:
    *
    * 1. Compat (legacy) browser support (e.g. IE11). Totally custom, doesn't rely on native browser APIs.
-   * 2. "Vanilla" custom elements registry. This system actually still allows us to have two LWC components with the
-   *    same tag name, via a simple trick: every custom element constructor we define in the registry is basically
-   *    the same. It's essentially a dummy `class extends HTMLElement` that accepts an `upgradeCallback` in its
-   *    constructor, which allows us to have completely customized functionality for different components.
+   * 2. "Upgradable constructor" custom element. This allows us to have two LWC components with the same tag name,
+   *    via a trick: every custom element constructor we define in the registry is basically the same. It's essentially
+   *    a dummy `class extends HTMLElement` that accepts an `upgradeCallback` in its constructor ("upgradable
+   *    constructor"), which allows us to have completely customized functionality for different components.
    * 3. "Scoped" (or "pivot") custom elements. This relies on a sophisticated system that emulates the "scoped custom
    *    elements registry" proposal, with support for avoiding conflicts in tag names both between LWC components and
    *    between LWC components and third-party elements. This uses a similar trick to #2, but is much more complex
@@ -6604,8 +6604,8 @@ var LWC = (function (exports) {
     if (lwcRuntimeFlags.ENABLE_SCOPED_CUSTOM_ELEMENT_REGISTRY) {
       createCustomElement = createCustomElementScoped;
     } else {
-      // use global custom elements registry (vanilla)
-      createCustomElement = createCustomElementVanilla;
+      // use the global registry, with an upgradable constructor for the defined custom element
+      createCustomElement = createCustomElementUsingUpgradableConstructor;
     }
   } else {
     // no registry available here
@@ -6661,10 +6661,10 @@ var LWC = (function (exports) {
 
       var assert = /*#__PURE__*/Object.freeze({
           __proto__: null,
+          fail: fail,
           invariant: invariant,
-          isTrue: isTrue$1,
           isFalse: isFalse$1,
-          fail: fail
+          isTrue: isTrue$1
       });
       function isUndefined(obj) {
           return obj === undefined;
@@ -6672,7 +6672,7 @@ var LWC = (function (exports) {
       function isNull(obj) {
           return obj === null;
       }
-      /** version: 2.35.1 */
+      /** version: 2.35.2 */
 
       /*
        * Copyright (c) 2018, salesforce.com, inc.
@@ -7225,7 +7225,7 @@ var LWC = (function (exports) {
   });
   freeze(LightningElement);
   seal(LightningElement.prototype);
-  /* version: 2.35.1 */
+  /* version: 2.35.2 */
 
   exports.LightningElement = LightningElement;
   exports.__unstable__ProfilerControl = profilerControl;