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

package/dist/packages/@glimmer/util/index.js

@@ -1,5 +1,3 @@
-import { isDevelopingApp } from '@embroider/macros';
-
 const EMPTY_ARRAY = Object.freeze([]);
 function emptyArray() {
   return EMPTY_ARRAY;
@@ -15,90 +13,46 @@ function isEmptyArray(input) {
   return input === EMPTY_ARRAY;
 }
 function* reverse(input) {
-  for (let i = input.length - 1; i >= 0; i--) yield input[i];
+  for (let i = input.length - 1; i >= 0; i--)
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+  yield input[i];
 }
 function* enumerate(input) {
   let i = 0;
   for (const item of input) yield [i++, item];
 }
 
-// import Logger from './logger';
-// let alreadyWarned = false;
-function debugAssert(test, msg) {
-  // if (!alreadyWarned) {
-  //   alreadyWarned = true;
-  //   Logger.warn("Don't leave debug assertions on in public builds");
-  // }
-  if (!test) throw new Error(msg || "assertion failure");
-}
-function deprecate(desc) {
-  LOCAL_LOGGER.warn(`DEPRECATION: ${desc}`);
-}
-function keys(obj) {
-  return Object.keys(obj);
-}
-function unwrap(val) {
-  if (null == val) throw new Error("Expected value to be present");
-  return val;
-}
-function expect(val, message) {
-  if (null == val) throw new Error(message);
-  return val;
-}
-function unreachable(message = "unreachable") {
-  return new Error(message);
-}
-function exhausted(value) {
-  throw new Error(`Exhausted ${String(value)}`);
-}
-const tuple = (...args) => args;
-function isPresent(value) {
-  return null != value;
+/**
+ * Zip two tuples with the same type and number of elements.
+ */
+function* zipTuples(left, right) {
+  for (let i = 0; i < left.length; i++) yield [i, left[i], right[i]];
 }
-function assertPresent(value, message) {
-  if (!isPresent(value)) throw new Error(`Expected present, got ${"string" == typeof value ? value : message}`);
+function* zipArrays(left, right) {
+  for (let i = 0; i < left.length; i++) {
+    const perform = i < right.length ? "retain" : "pop";
+    yield [perform, i, left[i], right[i]];
+  }
+  for (let i = left.length; i < right.length; i++) yield ["push", i, void 0, right[i]];
 }
 function isPresentArray(list) {
-  return list.length > 0;
-}
-function ifPresent(list, ifPresent, otherwise) {
-  return isPresentArray(list) ? ifPresent(list) : otherwise();
-}
-function arrayToOption(list) {
-  return isPresentArray(list) ? list : null;
-}
-function assertPresentArray(list, message = "unexpected empty list") {
-  if (!isPresentArray(list)) throw new Error(message);
-}
-function asPresentArray(list, message = "unexpected empty list") {
-  return assertPresentArray(list, message), list;
+  return !!list && list.length > 0;
 }
 function getLast(list) {
   return 0 === list.length ? void 0 : list[list.length - 1];
 }
-function getFirst(list) {
-  return 0 === list.length ? void 0 : list[0];
-}
-function mapPresentArray(list, mapper) {
-  if (null === list) return null;
-  let out = [];
-  for (let item of list) out.push(mapper(item));
-  return out;
-}
 function dict() {
   return Object.create(null);
 }
 function isDict(u) {
   return null != u;
 }
-function isObject(u) {
+function isIndexable(u) {
   return "function" == typeof u || "object" == typeof u && null !== u;
 }
 class StackImpl {
-  stack;
-  current = null;
   constructor(values = []) {
-    this.stack = values;
+    this.current = null, this.stack = values;
   }
   get size() {
     return this.stack.length;
@@ -112,39 +66,21 @@ class StackImpl {
   }
   nth(from) {
     let len = this.stack.length;
-    return len < from ? null : unwrap(this.stack[len - from]);
+    return len < from ? null : this.stack[len - from];
   }
   isEmpty() {
     return 0 === this.stack.length;
   }
+  snapshot() {
+    return [...this.stack];
+  }
   toArray() {
     return this.stack;
   }
 }
 
 /// <reference types="qunit" />
-let beginTestSteps, endTestSteps, verifySteps, logStep, debugToString;
-if (isDevelopingApp()) {
-  let getFunctionName = fn => {
-      let functionName = fn.name;
-      if (void 0 === functionName) {
-        let match = /function (\w+)\s*\(/u.exec(String(fn));
-        functionName = match && match[1] || "";
-      }
-      return functionName.replace(/^bound /u, "");
-    },
-    getObjectName = obj => {
-      let name, className;
-      // If the class has a decent looking name, and the `toString` is one of the
-      // default Ember toStrings, replace the constructor portion of the toString
-      // with the class name. We check the length of the class name to prevent doing
-      // this when the value is minified.
-      return obj.constructor && "function" == typeof obj.constructor && (className = getFunctionName(obj.constructor)), "toString" in obj && obj.toString !== Object.prototype.toString && obj.toString !== Function.prototype.toString && (name = obj.toString()), name && /<.*:ember\d+>/u.test(name) && className && "_" !== className[0] && className.length > 2 && "Class" !== className ? name.replace(/<.*:/u, `<${className}:`) : name || className;
-    },
-    getPrimitiveName = value => String(value);
-  debugToString = value => "function" == typeof value ? getFunctionName(value) || "(unknown function)" : "object" == typeof value && null !== value ? getObjectName(value) || "(unknown object)" : getPrimitiveName(value);
-}
-var debugToString$1 = debugToString;
+let beginTestSteps, endTestSteps, verifySteps, logStep;
 function clearElement(parent) {
   let current = parent.firstChild;
   for (; current;) {
@@ -152,98 +88,6 @@ function clearElement(parent) {
     parent.removeChild(current), current = next;
   }
 }
-const RAW_NODE = -1,
-  ELEMENT_NODE = 1,
-  TEXT_NODE = 3,
-  COMMENT_NODE = 8,
-  DOCUMENT_NODE = 9,
-  DOCUMENT_TYPE_NODE = 10,
-  DOCUMENT_FRAGMENT_NODE = 11,
-  NS_HTML = "http://www.w3.org/1999/xhtml",
-  NS_MATHML = "http://www.w3.org/1998/Math/MathML",
-  NS_SVG = "http://www.w3.org/2000/svg",
-  NS_XLINK = "http://www.w3.org/1999/xlink",
-  NS_XML = "http://www.w3.org/XML/1998/namespace",
-  NS_XMLNS = "http://www.w3.org/2000/xmlns/",
-  INSERT_BEFORE_BEGIN = "beforebegin",
-  INSERT_AFTER_BEGIN = "afterbegin",
-  INSERT_BEFORE_END = "beforeend",
-  INSERT_AFTER_END = "afterend";
-
-/*
-  Encoding notes
-
-  We use 30 bit integers for encoding, so that we don't ever encode a non-SMI
-  integer to push on the stack.
-
-  Handles are >= 0
-  Immediates are < 0
-
-  True, False, Undefined and Null are pushed as handles into the symbol table,
-  with well known handles (0, 1, 2, 3)
-
-  The negative space is divided into positives and negatives. Positives are
-  higher numbers (-1, -2, -3, etc), negatives are lower.
-
-  We only encode immediates for two reasons:
-
-  1. To transfer over the wire, so they're smaller in general
-  2. When pushing values onto the stack from the low level/inner VM, which may
-     be converted into WASM one day.
-
-  This allows the low-level VM to always use SMIs, and to minimize using JS
-  values via handles for things like the stack pointer and frame pointer.
-  Externally, most code pushes values as JS values, except when being pulled
-  from the append byte code where it was already encoded.
-
-  Logically, this is because the low level VM doesn't really care about these
-  higher level values. For instance, the result of a userland helper may be a
-  number, or a boolean, or undefined/null, but it's extra work to figure that
-  out and push it correctly, vs. just pushing the value as a JS value with a
-  handle.
-
-  Note: The details could change here in the future, this is just the current
-  strategy.
-*/
-let ImmediateConstants = function (ImmediateConstants) {
-  return ImmediateConstants[ImmediateConstants.MAX_SMI = 1073741823] = "MAX_SMI", ImmediateConstants[ImmediateConstants.MIN_SMI = -1073741824] = "MIN_SMI", ImmediateConstants[ImmediateConstants.SIGN_BIT = -536870913] = "SIGN_BIT", ImmediateConstants[ImmediateConstants.MAX_INT = 536870911] = "MAX_INT", ImmediateConstants[ImmediateConstants.MIN_INT = -536870912] = "MIN_INT", ImmediateConstants[ImmediateConstants.FALSE_HANDLE = 0] = "FALSE_HANDLE", ImmediateConstants[ImmediateConstants.TRUE_HANDLE = 1] = "TRUE_HANDLE", ImmediateConstants[ImmediateConstants.NULL_HANDLE = 2] = "NULL_HANDLE", ImmediateConstants[ImmediateConstants.UNDEFINED_HANDLE = 3] = "UNDEFINED_HANDLE", ImmediateConstants[ImmediateConstants.ENCODED_FALSE_HANDLE = 0] = "ENCODED_FALSE_HANDLE", ImmediateConstants[ImmediateConstants.ENCODED_TRUE_HANDLE = 1] = "ENCODED_TRUE_HANDLE", ImmediateConstants[ImmediateConstants.ENCODED_NULL_HANDLE = 2] = "ENCODED_NULL_HANDLE", ImmediateConstants[ImmediateConstants.ENCODED_UNDEFINED_HANDLE = 3] = "ENCODED_UNDEFINED_HANDLE", ImmediateConstants;
-}({});
-function isHandle(value) {
-  return value >= 0;
-}
-function isNonPrimitiveHandle(value) {
-  return value > ImmediateConstants.ENCODED_UNDEFINED_HANDLE;
-}
-function constants(...values) {
-  return [!1, !0, null, void 0, ...values];
-}
-function isSmallInt(value) {
-  return value % 1 == 0 && value <= ImmediateConstants.MAX_INT && value >= ImmediateConstants.MIN_INT;
-}
-function encodeNegative(num) {
-  return num & ImmediateConstants.SIGN_BIT;
-}
-function decodeNegative(num) {
-  return num | ~ImmediateConstants.SIGN_BIT;
-}
-function encodePositive(num) {
-  return ~num;
-}
-function decodePositive(num) {
-  return ~num;
-}
-function encodeHandle(num) {
-  return num;
-}
-function decodeHandle(num) {
-  return num;
-}
-function encodeImmediate(num) {
-  return (num |= 0) < 0 ? encodeNegative(num) : encodePositive(num);
-}
-function decodeImmediate(num) {
-  return (num |= 0) > ImmediateConstants.SIGN_BIT ? decodePositive(num) : decodeNegative(num);
-}
 
 /**
   Strongly hint runtimes to intern the provided string.
@@ -290,77 +134,29 @@ function intern(str) {
   for (let key in obj) if (key === str) return key;
   return str;
 }
-[1, -1].forEach(x => decodeImmediate(encodeImmediate(x)));
 const SERIALIZATION_FIRST_NODE_STRING = "%+b:0%";
 function isSerializationFirstNode(node) {
   return "%+b:0%" === node.nodeValue;
 }
-let assign = Object.assign;
+const assign = Object.assign;
 function values(obj) {
   return Object.values(obj);
 }
 function entries(dict) {
   return Object.entries(dict);
 }
-function castToSimple(node) {
-  return isDocument(node) || isSimpleElement(node), node;
-}
-
-// If passed a document, verify we're in the browser and return it as a Document
-// If we don't know what this is, but the check requires it to be an element,
-// the cast will mandate that it's a browser element
-// Finally, if it's a more generic check, the cast will mandate that it's a
-// browser node and return a BrowserNodeUtils corresponding to the check
-function castToBrowser(node, sugaryCheck) {
-  if (null == node) return null;
-  if (void 0 === typeof document) throw new Error("Attempted to cast to a browser node in a non-browser context");
-  if (isDocument(node)) return node;
-  if (node.ownerDocument !== document) throw new Error("Attempted to cast to a browser node with a node that was not created from this document");
-  return checkBrowserNode(node, sugaryCheck);
-}
-function isDocument(node) {
-  return node.nodeType === DOCUMENT_NODE;
-}
-function isSimpleElement(node) {
-  return node?.nodeType === ELEMENT_NODE;
-}
-function isElement(node) {
-  return node?.nodeType === ELEMENT_NODE && node instanceof Element;
-}
-function checkBrowserNode(node, check) {
-  let isMatch = !1;
-  if (null !== node) if ("string" == typeof check) isMatch = stringCheckNode(node, check);else {
-    if (!Array.isArray(check)) throw unreachable();
-    isMatch = check.some(c => stringCheckNode(node, c));
-  }
-  if (isMatch && node instanceof Node) return node;
-  throw function (from, check) {
-    return new Error(`cannot cast a ${from} into ${String(check)}`);
-  }(`SimpleElement(${node?.constructor?.name ?? "null"})`, check);
-}
-function stringCheckNode(node, check) {
-  switch (check) {
-    case "NODE":
-      return !0;
-    case "HTML":
-      return node instanceof HTMLElement;
-    case "SVG":
-      return node instanceof SVGElement;
-    case "ELEMENT":
-      return node instanceof Element;
-    default:
-      if (check.toUpperCase() === check) throw new Error("BUG: this code is missing handling for a generic node type");
-      return node instanceof Element && node.tagName.toLowerCase() === check;
-  }
+function keys(obj) {
+  return Object.keys(obj);
 }
 function strip(strings, ...args) {
   let out = "";
   for (const [i, string] of enumerate(strings)) out += `${string}${void 0 !== args[i] ? String(args[i]) : ""}`;
   let lines = out.split("\n");
-  for (; isPresentArray(lines) && /^\s*$/u.test(getFirst(lines));) lines.shift();
-  for (; isPresentArray(lines) && /^\s*$/u.test(getLast(lines));) lines.pop();
+  for (; isPresentArray(lines) && /^\s*$/u.test(0 === (list = lines).length ? void 0 : list[0]);) lines.shift();
+  for (var list; isPresentArray(lines) && /^\s*$/u.test(getLast(lines));) lines.pop();
   let min = 1 / 0;
   for (let line of lines) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
     let leading = /^\s*/u.exec(line)[0].length;
     min = Math.min(min, leading);
   }
@@ -368,50 +164,13 @@ function strip(strings, ...args) {
   for (let line of lines) stripped.push(line.slice(min));
   return stripped.join("\n");
 }
-function unwrapHandle(handle) {
-  if ("number" == typeof handle) return handle;
-  {
-    let error = handle.errors[0];
-    throw new Error(`Compile Error: ${error.problem} @ ${error.span.start}..${error.span.end}`);
-  }
-}
-function unwrapTemplate(template) {
-  if ("error" === template.result) throw new Error(`Compile Error: ${template.problem} @ ${template.span.start}..${template.span.end}`);
-  return template;
-}
-function extractHandle(handle) {
-  return "number" == typeof handle ? handle : handle.handle;
-}
-function isOkHandle(handle) {
-  return "number" == typeof handle;
-}
-function isErrHandle(handle) {
-  return "number" == typeof handle;
-}
-function buildUntouchableThis(source) {
-  let context = null;
-  if (isDevelopingApp()) {
-    let assertOnProperty = property => {
-      let access = "symbol" == typeof property || "number" == typeof property ? `[${String(property)}]` : `.${property}`;
-      throw new Error(`You accessed \`this${access}\` from a function passed to the ${source}, but the function itself was not bound to a valid \`this\` context. Consider updating to use a bound function (for instance, use an arrow function, \`() => {}\`).`);
-    };
-    context = new Proxy({}, {
-      get(_target, property) {
-        assertOnProperty(property);
-      },
-      set: (_target, property) => (assertOnProperty(property), !1),
-      has: (_target, property) => (assertOnProperty(property), !1)
-    });
-  }
-  return context;
-}
 
 /**
  * This constant exists to make it easier to differentiate normal logs from
  * errant console.logs. LOCAL_LOGGER should only be used inside a
- * LOCAL_SHOULD_LOG check.
+ * LOCAL_TRACE_LOGGING check.
  *
- * It does not alleviate the need to check LOCAL_SHOULD_LOG, which is used
+ * It does not alleviate the need to check LOCAL_TRACE_LOGGING, which is used
  * for stripping.
  */
 const LOCAL_LOGGER = console,
@@ -419,7 +178,7 @@ const LOCAL_LOGGER = console,
 
 /**
  * This constant exists to make it easier to differentiate normal logs from
- * errant console.logs. LOGGER can be used outside of LOCAL_SHOULD_LOG checks,
+ * errant console.logs. LOGGER can be used outside of LOCAL_TRACE_LOGGING checks,
  * and is meant to be used in the rare situation where a console.* call is
  * actually appropriate.
  */
@@ -427,4 +186,4 @@ function assertNever(value, desc = "unexpected unreachable branch") {
   throw LOGGER.log("unreachable", value), LOGGER.log(`${desc} :: ${JSON.stringify(value)} (${value})`), new Error("code reached unreachable");
 }
 
-export { COMMENT_NODE, DOCUMENT_FRAGMENT_NODE, DOCUMENT_NODE, DOCUMENT_TYPE_NODE, ELEMENT_NODE, EMPTY_ARRAY, EMPTY_NUMBER_ARRAY, EMPTY_STRING_ARRAY, INSERT_AFTER_BEGIN, INSERT_AFTER_END, INSERT_BEFORE_BEGIN, INSERT_BEFORE_END, ImmediateConstants, LOCAL_LOGGER, LOGGER, NS_HTML, NS_MATHML, NS_SVG, NS_XLINK, NS_XML, NS_XMLNS, RAW_NODE, SERIALIZATION_FIRST_NODE_STRING, StackImpl as Stack, TEXT_NODE, arrayToOption, asPresentArray, debugAssert as assert, assertNever, assertPresent, assertPresentArray, assign, beginTestSteps, buildUntouchableThis, castToBrowser, castToSimple, checkBrowserNode as checkNode, clearElement, constants, debugToString$1 as debugToString, decodeHandle, decodeImmediate, decodeNegative, decodePositive, deprecate, dict, emptyArray, encodeHandle, encodeImmediate, encodeNegative, encodePositive, endTestSteps, entries, enumerate, exhausted, expect, extractHandle, getFirst, getLast, ifPresent, intern, isDict, isElement, isEmptyArray, isErrHandle, isHandle, isNonPrimitiveHandle, isObject, isOkHandle, isPresent, isPresentArray, isSerializationFirstNode, isSimpleElement, isSmallInt, keys, logStep, mapPresentArray, reverse, strip, tuple, unreachable, unwrap, unwrapHandle, unwrapTemplate, values, verifySteps };
+export { EMPTY_ARRAY, EMPTY_NUMBER_ARRAY, EMPTY_STRING_ARRAY, LOCAL_LOGGER, LOGGER, SERIALIZATION_FIRST_NODE_STRING, StackImpl as Stack, assertNever, assign, beginTestSteps, clearElement, dict, emptyArray, endTestSteps, entries, enumerate, intern, isDict, isEmptyArray, isIndexable, isSerializationFirstNode, keys, logStep, reverse, strip, values, verifySteps, zipArrays, zipTuples };

package/dist/packages/@glimmer/validator/index.js

@@ -1,11 +1,6 @@
 import { assert, scheduleRevalidate } from '../global-context/index.js';
-import { getLast, asPresentArray } from '../util/index.js';
 import { isDevelopingApp } from '@embroider/macros';
 
-function unwrap(val) {
-  if (null == val) throw new Error("Expected value to be present");
-  return val;
-}
 const debug = {};
 if (isDevelopingApp()) {
   let CONSUMED_TAGS = null;
@@ -13,7 +8,7 @@ if (isDevelopingApp()) {
     TRANSACTION_ENV = {
       debugMessage(obj, keyName) {
         let objName;
-        return objName = "function" == typeof obj ? obj.name : "object" == typeof obj && null !== obj ? `(an instance of ${obj.constructor && obj.constructor.name || "(unknown class)"})` : void 0 === obj ? "(an unknown tag)" : String(obj), `You attempted to update ${keyName ? `\`${keyName}\` on \`${objName}\`` : `\`${objName}\``}, 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.`;
+        return objName = "function" == typeof obj ? obj.name : "object" == typeof obj && null !== obj ? `(an instance of ${obj.constructor.name || "(unknown class)"})` : void 0 === obj ? "(an unknown tag)" : String(obj), `You attempted to update ${keyName ? `\`${keyName}\` on \`${objName}\`` : `\`${objName}\``}, 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.`;
       }
     };
   /////////
@@ -49,7 +44,7 @@ if (isDevelopingApp()) {
       let value = fn();
       return didError = !1, value;
     } finally {
-      !0 !== didError && debug.endTrackingTransaction();
+      didError || 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})`
@@ -74,7 +69,8 @@ if (isDevelopingApp()) {
     return trackingStack.map((label, index) => " ".repeat(2 * index) + label).join("\n");
   }, debug.markTagAsConsumed = _tag => {
     if (!CONSUMED_TAGS || CONSUMED_TAGS.has(_tag)) return;
-    CONSUMED_TAGS.set(_tag, getLast(asPresentArray(TRANSACTION_STACK)));
+    var list;
+    CONSUMED_TAGS.set(_tag, 0 === (list = TRANSACTION_STACK).length ? void 0 : list[list.length - 1]);
     // 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.
@@ -84,7 +80,6 @@ if (isDevelopingApp()) {
     if (null === CONSUMED_TAGS) return;
     let transaction = CONSUMED_TAGS.get(tag);
     var error;
-    //////////
     if (transaction)
       // 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
@@ -97,6 +92,7 @@ if (isDevelopingApp()) {
           if (-1 !== updateStackBegin) {
             let start = nthIndex(e.stack, "\n", 1, updateStackBegin),
               end = nthIndex(e.stack, "\n", 4, updateStackBegin);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated -- @fixme
             e.stack = e.stack.substr(0, start) + e.stack.substr(end);
           }
         }
@@ -104,6 +100,10 @@ if (isDevelopingApp()) {
       }
   };
 }
+function unwrap(val) {
+  if (null == val) throw new Error("Expected value to be present");
+  return val;
+}
 const CONSTANT = 0,
   INITIAL = 1,
   VOLATILE = NaN;
@@ -113,8 +113,7 @@ function bump() {
 }
 
 //////////
-const UPDATABLE_TAG_ID = 1,
-  COMPUTE = Symbol("TAG_COMPUTE");
+const COMPUTE = Symbol("TAG_COMPUTE");
 
 //////////
 /**
@@ -144,6 +143,7 @@ function validateTag(tag, snapshot) {
 }
 
 //////////
+Reflect.set(globalThis, "COMPUTE_SYMBOL", COMPUTE);
 const TYPE = Symbol("TAG_TYPE");
 
 // this is basically a const
@@ -163,21 +163,14 @@ class MonomorphicTagImpl {
         }
     }
   }
-  revision = 1;
-  lastChecked = 1;
-  lastValue = 1;
-  isUpdating = !1;
-  subtag = null;
-  subtagBufferCache = null;
-  [TYPE];
   constructor(type) {
-    this[TYPE] = type;
+    this.revision = 1, this.lastChecked = 1, this.lastValue = 1, this.isUpdating = !1, this.subtag = null, this.subtagBufferCache = null, this[TYPE] = type;
   }
   [COMPUTE]() {
     let {
       lastChecked: lastChecked
     } = this;
-    if (!0 === this.isUpdating) {
+    if (this.isUpdating) {
       if (isDevelopingApp() && void 0 !== ALLOW_CYCLES && !ALLOW_CYCLES.has(this)) throw new Error("Cycles in tags are not allowed");
       this.lastChecked = ++$REVISION;
     } else if (lastChecked !== $REVISION) {
@@ -204,7 +197,9 @@ class MonomorphicTagImpl {
     return this.lastValue;
   }
   static updateTag(_tag, _subtag) {
-    if (isDevelopingApp() && _tag[TYPE] !== UPDATABLE_TAG_ID) throw new Error("Attempted to update a tag that was not updatable");
+    // catch bug by non-TS users
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (isDevelopingApp() && 1 !== _tag[TYPE]) 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,
       subtag = _subtag;
@@ -227,7 +222,7 @@ class MonomorphicTagImpl {
     tag.subtagBufferCache = subtag[COMPUTE](), tag.subtag = subtag);
   }
   static dirtyTag(tag, disableConsumptionAssertion) {
-    if (isDevelopingApp() && tag[TYPE] !== UPDATABLE_TAG_ID && 0 !== tag[TYPE]) throw new Error("Attempted to dirty a tag that was not dirtyable");
+    if (isDevelopingApp() && 1 !== tag[TYPE] && 0 !== tag[TYPE]) throw new Error("Attempted to dirty a tag that was not dirtyable");
     isDevelopingApp() && !0 !== disableConsumptionAssertion &&
     // Usually by this point, we've already asserted with better error information,
     // but this is our last line of defense.
@@ -242,7 +237,7 @@ function createTag() {
   return new MonomorphicTagImpl(0);
 }
 function createUpdatableTag() {
-  return new MonomorphicTagImpl(UPDATABLE_TAG_ID);
+  return new MonomorphicTagImpl(1);
 }
 
 //////////
@@ -253,19 +248,23 @@ function isConstTag(tag) {
 
 //////////
 class VolatileTag {
-  [TYPE] = 100;
   [COMPUTE]() {
     return NaN;
   }
+  constructor() {
+    this[TYPE] = 100;
+  }
 }
 const VOLATILE_TAG = new VolatileTag();
 
 //////////
 class CurrentTag {
-  [TYPE] = 101;
   [COMPUTE]() {
     return $REVISION;
   }
+  constructor() {
+    this[TYPE] = 101;
+  }
 }
 const CURRENT_TAG = new CurrentTag(),
   combine = MonomorphicTagImpl.combine;
@@ -276,8 +275,6 @@ let tag1 = createUpdatableTag(),
   tag2 = createUpdatableTag(),
   tag3 = createUpdatableTag();
 valueForTag(tag1), DIRTY_TAG(tag1), valueForTag(tag1), UPDATE_TAG(tag1, combine([tag2, tag3])), valueForTag(tag1), DIRTY_TAG(tag2), valueForTag(tag1), DIRTY_TAG(tag3), valueForTag(tag1), UPDATE_TAG(tag1, tag3), valueForTag(tag1), DIRTY_TAG(tag3), valueForTag(tag1);
-
-///////////
 const TRACKED_TAGS = new WeakMap();
 function dirtyTagFor(obj, key, meta) {
   if (isDevelopingApp() && ("object" != typeof (u = obj) || null === u) && "function" != typeof u) throw new Error("BUG: Can't update a tag for a primitive");
@@ -303,8 +300,6 @@ function tagFor(obj, key, meta) {
  * An object that that tracks @tracked properties that were consumed.
  */
 class Tracker {
-  tags = new Set();
-  last = null;
   add(tag) {
     tag !== CONSTANT_TAG && (this.tags.add(tag), isDevelopingApp() && unwrap(debug.markTagAsConsumed)(tag), this.last = tag);
   }
@@ -314,6 +309,9 @@ class Tracker {
     } = this;
     return 0 === tags.size ? CONSTANT_TAG : 1 === tags.size ? this.last : combine(Array.from(this.tags));
   }
+  constructor() {
+    this.tags = new Set(), this.last = null;
+  }
 }
 
 /**
@@ -361,8 +359,6 @@ function isTracking() {
 function consumeTag(tag) {
   null !== CURRENT_TRACKER && CURRENT_TRACKER.add(tag);
 }
-
-// public interface
 const FN = Symbol("FN"),
   LAST_VALUE = Symbol("LAST_VALUE"),
   TAG = Symbol("TAG"),
@@ -409,7 +405,9 @@ function isConst(cache) {
   (tag, cache), isConstTag(tag);
 }
 function assertCache(value, fnName) {
-  if (isDevelopingApp() && ("object" != typeof value || null === value || !(FN in value))) throw new Error(`${fnName}() can only be used on an instance of a cache created with createCache(). Called with: ${String(value)}`);
+  if (isDevelopingApp() && ("object" != typeof value || !(FN in value))) throw new Error(`${fnName}() can only be used on an instance of a cache created with createCache(). Called with: ${String(
+  // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @fixme
+  value)}`);
 }
 function track(block, debugLabel) {
   let tag;
@@ -441,22 +439,17 @@ function trackedData(key, initializer) {
     getter: function (self) {
       let value;
       // If the field has never been initialized, we should initialize it
-      return consumeTag(tagFor(self, key)), hasInitializer && !values.has(self) ? (value = initializer.call(self), values.set(self, value)) : value = values.get(self), value;
+      return consumeTag(tagFor(self, key)), hasInitializer && !values.has(self) ? (
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+      value = initializer.call(self), values.set(self, value)) : value = values.get(self), value;
     },
     setter: function (self, value) {
       dirtyTagFor(self, key), values.set(self, value);
     }
   };
 }
-const GLIMMER_VALIDATOR_REGISTRATION = Symbol("GLIMMER_VALIDATOR_REGISTRATION"),
-  globalObj = function () {
-    if ("undefined" != typeof globalThis) return globalThis;
-    if ("undefined" != typeof self) return self;
-    if ("undefined" != typeof window) return window;
-    if ("undefined" != typeof global) return global;
-    throw new Error("unable to locate global object");
-  }();
-if (!0 === globalObj[GLIMMER_VALIDATOR_REGISTRATION]) 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] = !0;
+const GLIMMER_VALIDATOR_REGISTRATION = Symbol("GLIMMER_VALIDATOR_REGISTRATION");
+if (Reflect.has(globalThis, GLIMMER_VALIDATOR_REGISTRATION)) 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.");
+Reflect.set(globalThis, GLIMMER_VALIDATOR_REGISTRATION, !0);
 
 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 };