ember-source 5.6.0-alpha.2 → 5.6.0-alpha.3

package/dist/dependencies/@glimmer/validator.js

@@ -1,19 +1,12 @@
 import { DEBUG } from '@glimmer/env';
 import { assert, scheduleRevalidate } from '@glimmer/global-context';
+import { getLast, asPresentArray } from '@glimmer/util';
 
-// eslint-disable-next-line @typescript-eslint/ban-types
 function indexable(input) {
   return input;
-} // This is a duplicate utility from @glimmer/util because `@glimmer/validator`
-// should not depend on any other @glimmer packages, in order to avoid pulling
-// in types and prevent regressions in `@glimmer/tracking` (which has public types).
-
-const symbol = typeof Symbol !== 'undefined' ? Symbol : // eslint-disable-next-line @typescript-eslint/no-explicit-any
-key => `__${key}${Math.floor(Math.random() * Date.now())}__`; // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-const symbolFor = typeof Symbol !== 'undefined' ? Symbol.for : key => `__GLIMMER_VALIDATOR_SYMBOL_FOR_${key}`;
+}
 function getGlobal() {
-  // eslint-disable-next-line node/no-unsupported-features/es-builtins
+  // eslint-disable-next-line n/no-unsupported-features/es-builtins
   if (typeof globalThis !== 'undefined') return indexable(globalThis);
   if (typeof self !== 'undefined') return indexable(self);
   if (typeof window !== 'undefined') return indexable(window);
@@ -25,23 +18,16 @@ function unwrap(val) {
   return val;
 }
 
-let beginTrackingTransaction;
-let endTrackingTransaction;
-let runInTrackingTransaction;
-let resetTrackingTransaction;
-let setTrackingTransactionEnv;
-let assertTagNotConsumed;
-let markTagAsConsumed;
-let logTrackingStack;
-
+const debug = {};
 if (DEBUG) {
   let CONSUMED_TAGS = null;
-  let TRANSACTION_STACK = []; /////////
+  const TRANSACTION_STACK = [];
+
+  /////////
 
-  let TRANSACTION_ENV = {
+  const TRANSACTION_ENV = {
     debugMessage(obj, keyName) {
       let objName;
-
       if (typeof obj === 'function') {
         objName = obj.name;
       } else if (typeof obj === 'object' && obj !== null) {
@@ -52,48 +38,39 @@ if (DEBUG) {
       } else {
         objName = String(obj);
       }
-
       let dirtyString = keyName ? `\`${keyName}\` on \`${objName}\`` : `\`${objName}\``;
       return `You attempted to update ${dirtyString}, but it had already been used previously in the same computation.  Attempting to update a value after using it in a computation can cause logical errors, infinite revalidation bugs, and performance issues, and is not supported.`;
     }
-
   };
-
-  setTrackingTransactionEnv = env => Object.assign(TRANSACTION_ENV, env);
-
-  beginTrackingTransaction = _debugLabel => {
+  debug.setTrackingTransactionEnv = env => Object.assign(TRANSACTION_ENV, env);
+  debug.beginTrackingTransaction = _debugLabel => {
     CONSUMED_TAGS = CONSUMED_TAGS || new WeakMap();
     let debugLabel = _debugLabel || undefined;
-    let parent = TRANSACTION_STACK[TRANSACTION_STACK.length - 1] || null;
+    let parent = TRANSACTION_STACK[TRANSACTION_STACK.length - 1] ?? null;
     TRANSACTION_STACK.push({
       parent,
       debugLabel
     });
   };
-
-  endTrackingTransaction = () => {
+  debug.endTrackingTransaction = () => {
     if (TRANSACTION_STACK.length === 0) {
       throw new Error('attempted to close a tracking transaction, but one was not open');
     }
-
     TRANSACTION_STACK.pop();
-
     if (TRANSACTION_STACK.length === 0) {
       CONSUMED_TAGS = null;
     }
   };
-
-  resetTrackingTransaction = () => {
+  debug.resetTrackingTransaction = () => {
     let stack = '';
-
     if (TRANSACTION_STACK.length > 0) {
-      stack = logTrackingStack(TRANSACTION_STACK[TRANSACTION_STACK.length - 1]);
+      stack = debug.logTrackingStack(TRANSACTION_STACK[TRANSACTION_STACK.length - 1]);
     }
-
-    TRANSACTION_STACK = [];
+    TRANSACTION_STACK.splice(0, TRANSACTION_STACK.length);
     CONSUMED_TAGS = null;
     return stack;
   };
+
   /**
    * Creates a global autotracking transaction. This will prevent any backflow
    * in any `track` calls within the transaction, even if they are not
@@ -104,100 +81,99 @@ if (DEBUG) {
    *
    * TODO: Only throw an error if the `track` is consumed.
    */
-
-
-  runInTrackingTransaction = (fn, debugLabel) => {
-    beginTrackingTransaction(debugLabel);
+  debug.runInTrackingTransaction = (fn, debugLabel) => {
+    debug.beginTrackingTransaction(debugLabel);
     let didError = true;
-
     try {
       let value = fn();
       didError = false;
       return value;
     } finally {
       if (didError !== true) {
-        endTrackingTransaction();
+        debug.endTrackingTransaction();
       }
+
+      // if (id !== TRANSACTION_STACK.length) {
+      //   throw new Error(
+      //     `attempted to close a tracking transaction (${id}), but it was not the last transaction (${TRANSACTION_STACK.length})`
+      //   );
+      // }
     }
   };
 
-  let nthIndex = (str, pattern, n, startingPos = -1) => {
+  let nthIndex = function (str, pattern, n) {
+    let startingPos = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
     let i = startingPos;
-
     while (n-- > 0 && i++ < str.length) {
       i = str.indexOf(pattern, i);
       if (i < 0) break;
     }
-
     return i;
   };
-
   let makeTrackingErrorMessage = (transaction, obj, keyName) => {
     let message = [TRANSACTION_ENV.debugMessage(obj, keyName && String(keyName))];
     message.push(`\`${String(keyName)}\` was first used:`);
-    message.push(logTrackingStack(transaction));
+    message.push(debug.logTrackingStack(transaction));
     message.push(`Stack trace for the update:`);
     return message.join('\n\n');
   };
-
-  logTrackingStack = transaction => {
+  debug.logTrackingStack = transaction => {
     let trackingStack = [];
     let current = transaction || TRANSACTION_STACK[TRANSACTION_STACK.length - 1];
     if (current === undefined) return '';
-
     while (current) {
       if (current.debugLabel) {
         trackingStack.unshift(current.debugLabel);
       }
-
       current = current.parent;
-    } // TODO: Use String.prototype.repeat here once we can drop support for IE11
-
+    }
 
+    // TODO: Use String.prototype.repeat here once we can drop support for IE11
     return trackingStack.map((label, index) => Array(2 * index + 1).join(' ') + label).join('\n');
   };
-
-  markTagAsConsumed = _tag => {
+  debug.markTagAsConsumed = _tag => {
     if (!CONSUMED_TAGS || CONSUMED_TAGS.has(_tag)) return;
-    CONSUMED_TAGS.set(_tag, TRANSACTION_STACK[TRANSACTION_STACK.length - 1]); // We need to mark the tag and all of its subtags as consumed, so we need to
+    CONSUMED_TAGS.set(_tag, getLast(asPresentArray(TRANSACTION_STACK)));
+
+    // We need to mark the tag and all of its subtags as consumed, so we need to
     // cast it and access its internals. In the future this shouldn't be necessary,
     // this is only for computed properties.
-
-    let tag = _tag;
-
-    if (tag.subtag) {
-      markTagAsConsumed(tag.subtag);
-    }
-
-    if (tag.subtags) {
-      tag.subtags.forEach(tag => markTagAsConsumed(tag));
+    let subtag = _tag.subtag;
+    if (!subtag || !debug.markTagAsConsumed) return;
+    if (Array.isArray(subtag)) {
+      subtag.forEach(debug.markTagAsConsumed);
+    } else {
+      debug.markTagAsConsumed(subtag);
     }
   };
-
-  assertTagNotConsumed = (tag, obj, keyName) => {
+  debug.assertTagNotConsumed = (tag, obj, keyName) => {
     if (CONSUMED_TAGS === null) return;
     let transaction = CONSUMED_TAGS.get(tag);
-    if (!transaction) return; // This hack makes the assertion message nicer, we can cut off the first
+    if (!transaction) return;
+
+    // This hack makes the assertion message nicer, we can cut off the first
     // few lines of the stack trace and let users know where the actual error
     // occurred.
-
     try {
       assert(false, makeTrackingErrorMessage(transaction, obj, keyName));
     } catch (e) {
-      if (e.stack) {
+      if (hasStack(e)) {
         let updateStackBegin = e.stack.indexOf('Stack trace for the update:');
-
         if (updateStackBegin !== -1) {
           let start = nthIndex(e.stack, '\n', 1, updateStackBegin);
           let end = nthIndex(e.stack, '\n', 4, updateStackBegin);
           e.stack = e.stack.substr(0, start) + e.stack.substr(end);
         }
       }
-
       throw e;
     }
   };
 }
+function hasStack(error) {
+  return typeof error === 'object' && error !== null && 'stack' in error && typeof error.stack === 'string';
+}
+
+//////////
 
 const CONSTANT = 0;
 const INITIAL = 1;
@@ -205,9 +181,20 @@ const VOLATILE = NaN;
 let $REVISION = INITIAL;
 function bump() {
   $REVISION++;
-} //////////
+}
+
+//////////
+
+const DIRYTABLE_TAG_ID = 0;
+const UPDATABLE_TAG_ID = 1;
+const COMBINATOR_TAG_ID = 2;
+const CONSTANT_TAG_ID = 3;
+
+//////////
 
-const COMPUTE = symbol('TAG_COMPUTE'); //////////
+const COMPUTE = Symbol('TAG_COMPUTE');
+
+//////////
 
 /**
  * `value` receives a tag and returns an opaque Revision based on that tag. This
@@ -217,10 +204,10 @@ const COMPUTE = symbol('TAG_COMPUTE'); //////////
  *
  * @param tag
  */
-
 function valueForTag(tag) {
   return tag[COMPUTE]();
 }
+
 /**
  * `validate` receives a tag and a snapshot from a previous call to `value` with
  * the same tag, and determines if the tag is still valid compared to the
@@ -231,19 +218,19 @@ function valueForTag(tag) {
  * @param tag
  * @param snapshot
  */
-
 function validateTag(tag, snapshot) {
   return snapshot >= tag[COMPUTE]();
 }
-const TYPE = symbol('TAG_TYPE'); // this is basically a const
-// eslint-disable-next-line @typescript-eslint/naming-convention
 
-let ALLOW_CYCLES;
+//////////
 
+const TYPE = Symbol('TAG_TYPE');
+
+// this is basically a const
+let ALLOW_CYCLES;
 if (DEBUG) {
   ALLOW_CYCLES = new WeakMap();
 }
-
 function allowsCycles(tag) {
   if (ALLOW_CYCLES === undefined) {
     return true;
@@ -251,65 +238,56 @@ function allowsCycles(tag) {
     return ALLOW_CYCLES.has(tag);
   }
 }
-
 class MonomorphicTagImpl {
-  constructor(type) {
-    this.revision = INITIAL;
-    this.lastChecked = INITIAL;
-    this.lastValue = INITIAL;
-    this.isUpdating = false;
-    this.subtag = null;
-    this.subtagBufferCache = null;
-    this[TYPE] = type;
-  }
-
   static combine(tags) {
     switch (tags.length) {
       case 0:
         return CONSTANT_TAG;
-
       case 1:
         return tags[0];
-
       default:
-        let tag = new MonomorphicTagImpl(2
-        /* Combinator */
-        );
-        tag.subtag = tags;
-        return tag;
+        {
+          let tag = new MonomorphicTagImpl(COMBINATOR_TAG_ID);
+          tag.subtag = tags;
+          return tag;
+        }
     }
   }
-
+  revision = INITIAL;
+  lastChecked = INITIAL;
+  lastValue = INITIAL;
+  isUpdating = false;
+  subtag = null;
+  subtagBufferCache = null;
+  [TYPE];
+  constructor(type) {
+    this[TYPE] = type;
+  }
   [COMPUTE]() {
     let {
       lastChecked
     } = this;
-
     if (this.isUpdating === true) {
       if (DEBUG && !allowsCycles(this)) {
         throw new Error('Cycles in tags are not allowed');
       }
-
       this.lastChecked = ++$REVISION;
     } else if (lastChecked !== $REVISION) {
       this.isUpdating = true;
       this.lastChecked = $REVISION;
-
       try {
         let {
           subtag,
           revision
         } = this;
-
         if (subtag !== null) {
           if (Array.isArray(subtag)) {
-            for (let i = 0; i < subtag.length; i++) {
-              let value = subtag[i][COMPUTE]();
+            for (const tag of subtag) {
+              let value = tag[COMPUTE]();
               revision = Math.max(value, revision);
             }
           } else {
             let subtagValue = subtag[COMPUTE]();
-
             if (subtagValue === this.subtagBufferCache) {
               revision = Math.max(revision, this.lastValue);
             } else {
@@ -319,27 +297,21 @@ class MonomorphicTagImpl {
             }
           }
         }
-
         this.lastValue = revision;
       } finally {
         this.isUpdating = false;
       }
     }
-
     return this.lastValue;
   }
-
   static updateTag(_tag, _subtag) {
-    if (DEBUG && _tag[TYPE] !== 1
-    /* Updatable */
-    ) {
-        throw new Error('Attempted to update a tag that was not updatable');
-      } // TODO: TS 3.7 should allow us to do this via assertion
-
+    if (DEBUG && _tag[TYPE] !== UPDATABLE_TAG_ID) {
+      throw new Error('Attempted to update a tag that was not updatable');
+    }
 
+    // TODO: TS 3.7 should allow us to do this via assertion
     let tag = _tag;
     let subtag = _subtag;
-
     if (subtag === CONSTANT_TAG) {
       tag.subtag = null;
     } else {
@@ -365,66 +337,65 @@ class MonomorphicTagImpl {
       tag.subtag = subtag;
     }
   }
-
   static dirtyTag(tag, disableConsumptionAssertion) {
-    if (DEBUG && !(tag[TYPE] === 1
-    /* Updatable */
-    || tag[TYPE] === 0
-    /* Dirtyable */
-    )) {
+    if (DEBUG && !(tag[TYPE] === UPDATABLE_TAG_ID || tag[TYPE] === DIRYTABLE_TAG_ID)) {
       throw new Error('Attempted to dirty a tag that was not dirtyable');
     }
-
     if (DEBUG && disableConsumptionAssertion !== true) {
       // Usually by this point, we've already asserted with better error information,
       // but this is our last line of defense.
-      unwrap(assertTagNotConsumed)(tag);
+      unwrap(debug.assertTagNotConsumed)(tag);
     }
-
     tag.revision = ++$REVISION;
     scheduleRevalidate();
   }
-
 }
-
 const DIRTY_TAG = MonomorphicTagImpl.dirtyTag;
-const UPDATE_TAG = MonomorphicTagImpl.updateTag; //////////
+const UPDATE_TAG = MonomorphicTagImpl.updateTag;
+
+//////////
 
 function createTag() {
-  return new MonomorphicTagImpl(0
-  /* Dirtyable */
-  );
+  return new MonomorphicTagImpl(DIRYTABLE_TAG_ID);
 }
 function createUpdatableTag() {
-  return new MonomorphicTagImpl(1
-  /* Updatable */
-  );
-} //////////
-
-const CONSTANT_TAG = new MonomorphicTagImpl(3
-/* Constant */
-);
+  return new MonomorphicTagImpl(UPDATABLE_TAG_ID);
+}
+
+//////////
+
+const CONSTANT_TAG = new MonomorphicTagImpl(CONSTANT_TAG_ID);
 function isConstTag(tag) {
   return tag === CONSTANT_TAG;
-} //////////
+}
 
+//////////
+
+const VOLATILE_TAG_ID = 100;
 class VolatileTag {
+  [TYPE] = VOLATILE_TAG_ID;
   [COMPUTE]() {
     return VOLATILE;
   }
-
 }
-const VOLATILE_TAG = new VolatileTag(); //////////
+const VOLATILE_TAG = new VolatileTag();
 
+//////////
+
+const CURRENT_TAG_ID = 101;
 class CurrentTag {
+  [TYPE] = CURRENT_TAG_ID;
   [COMPUTE]() {
     return $REVISION;
   }
-
 }
-const CURRENT_TAG = new CurrentTag(); //////////
+const CURRENT_TAG = new CurrentTag();
+
+//////////
+
+const combine = MonomorphicTagImpl.combine;
 
-const combine = MonomorphicTagImpl.combine; // Warm
+// Warm
 
 let tag1 = createUpdatableTag();
 let tag2 = createUpdatableTag();
@@ -447,74 +418,63 @@ function isObjectLike(u) {
   return typeof u === 'object' && u !== null || typeof u === 'function';
 }
 
+///////////
+
 const TRACKED_TAGS = new WeakMap();
 function dirtyTagFor(obj, key, meta) {
   if (DEBUG && !isObjectLike(obj)) {
     throw new Error(`BUG: Can't update a tag for a primitive`);
   }
+  let tags = meta === undefined ? TRACKED_TAGS.get(obj) : meta;
 
-  let tags = meta === undefined ? TRACKED_TAGS.get(obj) : meta; // No tags have been setup for this object yet, return
-
-  if (tags === undefined) return; // Dirty the tag for the specific property if it exists
+  // No tags have been setup for this object yet, return
+  if (tags === undefined) return;
 
+  // Dirty the tag for the specific property if it exists
   let propertyTag = tags.get(key);
-
   if (propertyTag !== undefined) {
     if (DEBUG) {
-      unwrap(assertTagNotConsumed)(propertyTag, obj, key);
+      unwrap(debug.assertTagNotConsumed)(propertyTag, obj, key);
     }
-
     DIRTY_TAG(propertyTag, true);
   }
 }
 function tagMetaFor(obj) {
   let tags = TRACKED_TAGS.get(obj);
-
   if (tags === undefined) {
     tags = new Map();
     TRACKED_TAGS.set(obj, tags);
   }
-
   return tags;
 }
 function tagFor(obj, key, meta) {
   let tags = meta === undefined ? tagMetaFor(obj) : meta;
   let tag = tags.get(key);
-
   if (tag === undefined) {
     tag = createUpdatableTag();
     tags.set(key, tag);
   }
-
   return tag;
 }
 
 /**
  * An object that that tracks @tracked properties that were consumed.
  */
-
 class Tracker {
-  constructor() {
-    this.tags = new Set();
-    this.last = null;
-  }
-
+  tags = new Set();
+  last = null;
   add(tag) {
     if (tag === CONSTANT_TAG) return;
     this.tags.add(tag);
-
     if (DEBUG) {
-      unwrap(markTagAsConsumed)(tag);
+      unwrap(debug.markTagAsConsumed)(tag);
     }
-
     this.last = tag;
   }
-
   combine() {
     let {
       tags
     } = this;
-
     if (tags.size === 0) {
       return CONSTANT_TAG;
     } else if (tags.size === 1) {
@@ -525,8 +485,8 @@ class Tracker {
       return combine(tagsArr);
     }
   }
-
 }
+
 /**
  * Whenever a tracked computed property is entered, the current tracker is
  * saved off and a new tracker is replaced.
@@ -540,29 +500,23 @@ class Tracker {
  * that corresponds to the tracked properties consumed inside of
  * itself, including child tracked computed properties.
  */
-
-
 let CURRENT_TRACKER = null;
 const OPEN_TRACK_FRAMES = [];
 function beginTrackFrame(debuggingContext) {
   OPEN_TRACK_FRAMES.push(CURRENT_TRACKER);
   CURRENT_TRACKER = new Tracker();
-
   if (DEBUG) {
-    unwrap(beginTrackingTransaction)(debuggingContext);
+    unwrap(debug.beginTrackingTransaction)(debuggingContext);
   }
 }
 function endTrackFrame() {
   let current = CURRENT_TRACKER;
-
   if (DEBUG) {
     if (OPEN_TRACK_FRAMES.length === 0) {
       throw new Error('attempted to close a tracking frame, but one was not open');
     }
-
-    unwrap(endTrackingTransaction)();
+    unwrap(debug.endTrackingTransaction)();
   }
-
   CURRENT_TRACKER = OPEN_TRACK_FRAMES.pop() || null;
   return unwrap(current).combine();
 }
@@ -574,19 +528,17 @@ function endUntrackFrame() {
   if (DEBUG && OPEN_TRACK_FRAMES.length === 0) {
     throw new Error('attempted to close a tracking frame, but one was not open');
   }
-
   CURRENT_TRACKER = OPEN_TRACK_FRAMES.pop() || null;
-} // This function is only for handling errors and resetting to a valid state
+}
 
+// This function is only for handling errors and resetting to a valid state
 function resetTracking() {
   while (OPEN_TRACK_FRAMES.length > 0) {
     OPEN_TRACK_FRAMES.pop();
   }
-
   CURRENT_TRACKER = null;
-
   if (DEBUG) {
-    return unwrap(resetTrackingTransaction)();
+    return unwrap(debug.resetTrackingTransaction)();
   }
 }
 function isTracking() {
@@ -596,28 +548,28 @@ function consumeTag(tag) {
   if (CURRENT_TRACKER !== null) {
     CURRENT_TRACKER.add(tag);
   }
-} //////////
-const FN = symbol('FN');
-const LAST_VALUE = symbol('LAST_VALUE');
-const TAG = symbol('TAG');
-const SNAPSHOT = symbol('SNAPSHOT');
-const DEBUG_LABEL = symbol('DEBUG_LABEL');
+}
+
+// public interface
+
+const FN = Symbol('FN');
+const LAST_VALUE = Symbol('LAST_VALUE');
+const TAG = Symbol('TAG');
+const SNAPSHOT = Symbol('SNAPSHOT');
+const DEBUG_LABEL = Symbol('DEBUG_LABEL');
 function createCache(fn, debuggingLabel) {
   if (DEBUG && !(typeof fn === 'function')) {
     throw new Error(`createCache() must be passed a function as its first parameter. Called with: ${String(fn)}`);
   }
-
   let cache = {
     [FN]: fn,
     [LAST_VALUE]: undefined,
     [TAG]: undefined,
     [SNAPSHOT]: -1
   };
-
   if (DEBUG) {
     cache[DEBUG_LABEL] = debuggingLabel;
   }
-
   return cache;
 }
 function getValue(cache) {
@@ -625,10 +577,8 @@ function getValue(cache) {
   let fn = cache[FN];
   let tag = cache[TAG];
   let snapshot = cache[SNAPSHOT];
-
   if (tag === undefined || !validateTag(tag, snapshot)) {
     beginTrackFrame();
-
     try {
       cache[LAST_VALUE] = fn();
     } finally {
@@ -640,7 +590,6 @@ function getValue(cache) {
   } else {
     consumeTag(tag);
   }
-
   return cache[LAST_VALUE];
 }
 function isConst(cache) {
@@ -649,45 +598,44 @@ function isConst(cache) {
   assertTag(tag, cache);
   return isConstTag(tag);
 }
-
 function assertCache(value, fnName) {
   if (DEBUG && !(typeof value === 'object' && value !== null && FN in value)) {
     throw new Error(`${fnName}() can only be used on an instance of a cache created with createCache(). Called with: ${String(value)}`);
   }
-} // replace this with `expect` when we can
-
+}
 
+// replace this with `expect` when we can
 function assertTag(tag, cache) {
   if (DEBUG && tag === undefined) {
     throw new Error(`isConst() can only be used on a cache once getValue() has been called at least once. Called with cache function:\n\n${String(cache[FN])}`);
   }
-} //////////
+}
+
+//////////
+
 // Legacy tracking APIs
+
 // track() shouldn't be necessary at all in the VM once the autotracking
 // refactors are merged, and we should generally be moving away from it. It may
 // be necessary in Ember for a while longer, but I think we'll be able to drop
 // it in favor of cache sooner rather than later.
-
-
-function track(callback, debugLabel) {
+function track(block, debugLabel) {
   beginTrackFrame(debugLabel);
   let tag;
-
   try {
-    callback();
+    block();
   } finally {
     tag = endTrackFrame();
   }
-
   return tag;
-} // untrack() is currently mainly used to handle places that were previously not
+}
+
+// untrack() is currently mainly used to handle places that were previously not
 // tracked, and that tracking now would cause backtracking rerender assertions.
 // I think once we move everyone forward onto modern APIs, we'll probably be
 // able to remove it, but I'm not sure yet.
-
 function untrack(callback) {
   beginUntrackFrame();
-
   try {
     return callback();
   } finally {
@@ -698,39 +646,34 @@ function untrack(callback) {
 function trackedData(key, initializer) {
   let values = new WeakMap();
   let hasInitializer = typeof initializer === 'function';
-
   function getter(self) {
     consumeTag(tagFor(self, key));
-    let value; // If the field has never been initialized, we should initialize it
+    let value;
 
+    // If the field has never been initialized, we should initialize it
     if (hasInitializer && !values.has(self)) {
       value = initializer.call(self);
       values.set(self, value);
     } else {
       value = values.get(self);
     }
-
     return value;
   }
-
   function setter(self, value) {
     dirtyTagFor(self, key);
     values.set(self, value);
   }
-
   return {
     getter,
     setter
   };
 }
 
-const GLIMMER_VALIDATOR_REGISTRATION = symbolFor('GLIMMER_VALIDATOR_REGISTRATION');
+const GLIMMER_VALIDATOR_REGISTRATION = Symbol('GLIMMER_VALIDATOR_REGISTRATION');
 const globalObj = getGlobal();
-
 if (globalObj[GLIMMER_VALIDATOR_REGISTRATION] === true) {
   throw new Error('The `@glimmer/validator` library has been included twice in this application. It could be different versions of the package, or the same version included twice by mistake. `@glimmer/validator` depends on having a single copy of the package in use at any time in an application, even if they are the same version. You must dedupe your build to remove the duplicate packages in order to prevent this error.');
 }
-
 globalObj[GLIMMER_VALIDATOR_REGISTRATION] = true;
 
-export { ALLOW_CYCLES, COMPUTE, CONSTANT, CONSTANT_TAG, CURRENT_TAG, CurrentTag, INITIAL, VOLATILE, VOLATILE_TAG, VolatileTag, beginTrackFrame, beginTrackingTransaction, beginUntrackFrame, bump, combine, consumeTag, createCache, createTag, createUpdatableTag, DIRTY_TAG as dirtyTag, dirtyTagFor, endTrackFrame, endTrackingTransaction, endUntrackFrame, getValue, isConst, isConstTag, isTracking, logTrackingStack, resetTracking, runInTrackingTransaction, setTrackingTransactionEnv, tagFor, tagMetaFor, track, trackedData, untrack, UPDATE_TAG as updateTag, validateTag, valueForTag };
+export { ALLOW_CYCLES, COMPUTE, CONSTANT, CONSTANT_TAG, CURRENT_TAG, CurrentTag, INITIAL, VOLATILE, VOLATILE_TAG, VolatileTag, beginTrackFrame, beginUntrackFrame, bump, combine, consumeTag, createCache, createTag, createUpdatableTag, debug, DIRTY_TAG as dirtyTag, dirtyTagFor, endTrackFrame, endUntrackFrame, getValue, isConst, isConstTag, isTracking, resetTracking, tagFor, tagMetaFor, track, trackedData, untrack, UPDATE_TAG as updateTag, validateTag, valueForTag };