ember-source 7.1.0-alpha.4 → 7.1.0-alpha.5

package/dist/prod/packages/shared-chunks/opcodes-CplRyHl_.js

@@ -0,0 +1,50 @@
+const opcodes = {
+  Append: 1,
+  TrustingAppend: 2,
+  Comment: 3,
+  Modifier: 4,
+  StrictModifier: 5,
+  Block: 6,
+  StrictBlock: 7,
+  Component: 8,
+  OpenElement: 10,
+  OpenElementWithSplat: 11,
+  FlushElement: 12,
+  CloseElement: 13,
+  StaticAttr: 14,
+  DynamicAttr: 15,
+  ComponentAttr: 16,
+  AttrSplat: 17,
+  Yield: 18,
+  DynamicArg: 20,
+  StaticArg: 21,
+  TrustingDynamicAttr: 22,
+  TrustingComponentAttr: 23,
+  StaticComponentAttr: 24,
+  Debugger: 26,
+  Undefined: 27,
+  Call: 28,
+  Concat: 29,
+  GetSymbol: 30,
+  GetLexicalSymbol: 32,
+  GetStrictKeyword: 31,
+  GetFreeAsComponentOrHelperHead: 35,
+  GetFreeAsHelperHead: 37,
+  GetFreeAsModifierHead: 38,
+  GetFreeAsComponentHead: 39,
+  InElement: 40,
+  If: 41,
+  Each: 42,
+  Let: 44,
+  WithDynamicVars: 45,
+  InvokeComponent: 46,
+  HasBlock: 48,
+  HasBlockParams: 49,
+  Curry: 50,
+  Not: 51,
+  IfInline: 52,
+  GetDynamicVar: 53,
+  Log: 54
+};
+
+export { opcodes as o };

package/dist/prod/packages/shared-chunks/or-oTVMuHc8.js

@@ -0,0 +1,91 @@
+import { toBool } from '../@glimmer/global-context/index.js';
+import { a as createComputeRef, v as valueForRef } from './reference-BshxG6wn.js';
+import { i as internalHelper } from './hash-DcUe-meU.js';
+
+const and = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => {
+    let last;
+    for (let i = 0; i < positional.length; i++) {
+      let arg = positional[i];
+      last = arg ? valueForRef(arg) : arg;
+      if (!toBool(last)) return last;
+    }
+    return last;
+  }, null, 'and');
+});
+
+/**
+ * Performs a strict equality comparison.
+ *
+ * left === right
+ */
+function eq(left, right) {
+  return left === right;
+}
+
+/**
+ * Performs a greater than comparison.
+ *
+ * left > right
+ */
+function gt(left, right) {
+  return left > right;
+}
+
+/**
+ * Performs a greater than or equal comparison.
+ *
+ * left >= right
+ */
+function gte(left, right) {
+  return left >= right;
+}
+
+/**
+ * Performs a less than comparison.
+ *
+ * left < right
+ */
+function lt(left, right) {
+  return left < right;
+}
+
+/**
+ * Performs a less than or equal comparison.
+ *
+ * left <= right
+ */
+function lte(left, right) {
+  return left <= right;
+}
+
+/**
+ * Performs a strict inequality comparison.
+ *
+ * left !== right
+ */
+function neq(left, right) {
+  return left !== right;
+}
+
+const not = (...args) => {
+  return !toBool(args[0]);
+};
+
+const or = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => {
+    let last;
+    for (let i = 0; i < positional.length; i++) {
+      let arg = positional[i];
+      last = arg ? valueForRef(arg) : arg;
+      if (toBool(last)) return last;
+    }
+    return last;
+  }, null, 'or');
+});
+
+export { and as a, gte as b, lte as c, not as d, eq as e, gt as g, lt as l, neq as n, or as o };

package/dist/{dev/packages/shared-chunks/program-DfV0v8aa.js → prod/packages/shared-chunks/program-B7CWdS8W.js}

@@ -1,5 +1,4 @@
-import './debug-to-string-CFb7h0lY.js';
-import { u as unwrap } from './collections-D_nY_0UJ.js';
+import { u as unwrap } from './collections-C3Y8z_9v.js';
 import { O as OPERAND_LEN_MASK, A as ARG_SHIFT, M as MACHINE_MASK, T as TYPE_MASK } from './flags-B9qxc-pB.js';
 
 class RuntimeOpImpl {

package/dist/{dev/packages/shared-chunks/program-context-sJz0oHOA.js → prod/packages/shared-chunks/program-context-CGMN-aQM.js}

@@ -1,7 +1,7 @@
-import { V as VM_MAIN_OP, a as VM_CONTENT_TYPE_OP, b as VM_ASSERT_SAME_OP, d as VM_APPEND_HTML_OP, e as VM_APPEND_TEXT_OP, f as VM_RESOLVE_CURRIED_COMPONENT_OP, g as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, h as VM_APPEND_SAFE_HTML_OP, i as VM_APPEND_DOCUMENT_FRAGMENT_OP, j as VM_APPEND_NODE_OP, k as VM_INVOKE_STATIC_OP } from './fragment-Cc5k9Oy4.js';
+import { V as VM_MAIN_OP, a as VM_CONTENT_TYPE_OP, b as VM_ASSERT_SAME_OP, c as VM_APPEND_HTML_OP, d as VM_APPEND_TEXT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, g as VM_APPEND_SAFE_HTML_OP, h as VM_APPEND_DOCUMENT_FRAGMENT_OP, i as VM_APPEND_NODE_OP, j as VM_INVOKE_STATIC_OP } from './opcode-metadata-9iSW5JGP.js';
+import { $ as $s0 } from './registers-DoamZwaG.js';
 import { ContentType } from '../@glimmer/vm/index.js';
-import { $ as $s0 } from './registers-ylirb0dq.js';
-import { f as EncoderImpl, g as encodeOp, i as invokePreparedComponent, S as SwitchCases, h as InvokeBareComponent, C as CallDynamic } from './index-BUPd6pkm.js';
+import { f as EncoderImpl, g as encodeOp, i as invokePreparedComponent, S as SwitchCases, h as InvokeBareComponent, C as CallDynamic } from './index--2U-v2nf.js';
 
 class StdLib {
   constructor(main, trustingGuardedAppend, cautiousGuardedAppend, trustingNonDynamicAppend, cautiousNonDynamicAppend) {

package/dist/prod/packages/shared-chunks/property_get-hWJ0nGhW.js

@@ -0,0 +1,122 @@
+import { s as setProxy } from './is_proxy-Bzg0d4m4.js';
+import { isEmberArray } from '../@ember/array/-internals.js';
+import './env-DXxsTFkM.js';
+import { t as track, x as isTracking, a as consumeTag } from './cache-BIlOoPA7.js';
+import { t as tagFor } from './meta-B9mldqPL.js';
+import { C as Cache } from './cache-qDyqAcpg.js';
+
+const firstDotIndexCache = new Cache(1000, key => key.indexOf('.'));
+function isPath(path) {
+  return typeof path === 'string' && firstDotIndexCache.get(path) !== -1;
+}
+
+/**
+@module @ember/object
+*/
+
+const PROXY_CONTENT = Symbol('PROXY_CONTENT');
+function hasUnknownProperty(val) {
+  return typeof val === 'object' && val !== null && typeof val.unknownProperty === 'function';
+}
+
+// ..........................................................
+// GET AND SET
+//
+// If we are on a platform that supports accessors we can use those.
+// Otherwise simulate accessors by looking up the property directly on the
+// object.
+
+/**
+  Gets the value of a property on an object. If the property is computed,
+  the function will be invoked. If the property is not defined but the
+  object implements the `unknownProperty` method then that will be invoked.
+
+  ```javascript
+  import { get } from '@ember/object';
+  get(obj, "name");
+  ```
+
+  You only need to use this method to retrieve properties if the property
+  might not be defined on the object and you want to respect the
+  `unknownProperty` handler. Otherwise you can access the property directly.
+
+  Note that if the object itself is `undefined`, this method will throw
+  an error.
+
+  @method get
+  @for @ember/object
+  @static
+  @param {Object} obj The object to retrieve from.
+  @param {String} keyName The property key to retrieve
+  @return {Object} the property value or `null`.
+  @public
+*/
+
+function get(obj, keyName) {
+  return isPath(keyName) ? _getPath(obj, keyName) : _getProp(obj, keyName);
+}
+function _getProp(obj, keyName) {
+  if (obj == null) {
+    return;
+  }
+  let value;
+  if (typeof obj === 'object' || typeof obj === 'function') {
+    {
+      value = obj[keyName];
+    }
+    if (value === undefined && typeof obj === 'object' && !(keyName in obj) && hasUnknownProperty(obj)) {
+      value = obj.unknownProperty(keyName);
+    }
+    if (isTracking()) {
+      consumeTag(tagFor(obj, keyName));
+      if (Array.isArray(value) || isEmberArray(value)) {
+        // Add the tag of the returned value if it is an array, since arrays
+        // should always cause updates if they are consumed and then changed
+        consumeTag(tagFor(value, '[]'));
+      }
+    }
+  } else {
+    // SAFETY: It should be ok to access properties on any non-nullish value
+    value = obj[keyName];
+  }
+  return value;
+}
+function _getPath(obj, path, forSet) {
+  let parts = typeof path === 'string' ? path.split('.') : path;
+  for (let part of parts) {
+    if (obj === undefined || obj === null || obj.isDestroyed) {
+      return undefined;
+    }
+    if (forSet && (part === '__proto__' || part === 'constructor')) {
+      return;
+    }
+    obj = _getProp(obj, part);
+  }
+  return obj;
+}
+
+// Warm it up
+_getProp('foo', 'a');
+_getProp('foo', 1);
+_getProp({}, 'a');
+_getProp({}, 1);
+_getProp({
+  unknownProperty() {}
+}, 'a');
+_getProp({
+  unknownProperty() {}
+}, 1);
+get({}, 'foo');
+get({}, 'foo.bar');
+let fakeProxy = {};
+setProxy(fakeProxy);
+track(() => _getProp({}, 'a'));
+track(() => _getProp({}, 1));
+track(() => _getProp({
+  a: []
+}, 'a'));
+track(() => _getProp({
+  a: fakeProxy
+}, 'a'));
+
+export { PROXY_CONTENT as P, _getPath as _, _getProp as a, get as g, hasUnknownProperty as h, isPath as i };

package/dist/prod/packages/shared-chunks/{property_set-B2sZxeCw.js → property_set-Dj5-ScWk.js}

@@ -1,9 +1,8 @@
-import './super-Cm_a_cLQ.js';
 import { l as lookupDescriptor } from './lookup-descriptor-CwcVgaLv.js';
-import '../@ember/-internals/environment/index.js';
-import { C as COMPUTED_SETTERS } from './decorator-BdDDBUd2.js';
-import { i as isPath, _ as _getPath } from './observers-tZ2aOzr4.js';
-import { n as notifyPropertyChange } from './namespace_search-Dcdalhj6.js';
+import './env-DXxsTFkM.js';
+import { C as COMPUTED_SETTERS } from './decorator-DBCISop4.js';
+import { i as isPath, _ as _getPath } from './property_get-hWJ0nGhW.js';
+import { n as notifyPropertyChange } from './computed-2Udcmflw.js';
 
 /**
  @module @ember/object

package/dist/prod/packages/shared-chunks/props-fiqxqhAH.js

@@ -0,0 +1,85 @@
+/*
+ * @method normalizeProperty
+ * @param element {HTMLElement}
+ * @param slotName {String}
+ * @returns {Object} { name, type }
+ */
+function normalizeProperty(element, slotName) {
+  let type, normalized;
+  if (slotName in element) {
+    normalized = slotName;
+    type = 'prop';
+  } else {
+    let lower = slotName.toLowerCase();
+    if (lower in element) {
+      type = 'prop';
+      normalized = lower;
+    } else {
+      type = 'attr';
+      normalized = slotName;
+    }
+  }
+  if (type === 'prop' && (normalized.toLowerCase() === 'style' || preferAttr(element.tagName, normalized))) {
+    type = 'attr';
+  }
+  return {
+    normalized,
+    type
+  };
+}
+
+// Properties that MUST be set as attributes because the DOM properties
+// are read-only or have type mismatches with the HTML attributes.
+//
+// element.form is a read-only DOM property on all form-associated elements
+// that returns the owning HTMLFormElement (or null). The HTML `form` attribute
+// (set via setAttribute) associates the element with a form by ID.
+// See: https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/form
+//      https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement/form
+const ATTR_OVERRIDES = {
+  INPUT: {
+    form: true,
+    // HTMLElement.autocorrect is a boolean DOM property, but the HTML attribute
+    // uses "on"/"off" strings. Setting `element.autocorrect = "off"` coerces to
+    // `true` (truthy string). Must use setAttribute for correct "on"/"off" behavior.
+    // See: https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/autocorrect
+    autocorrect: true,
+    // HTMLInputElement.list is a read-only DOM property that returns the associated
+    // HTMLDataListElement (or null). Must use setAttribute to set the datalist ID.
+    // See: https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/list
+    list: true
+  },
+  SELECT: {
+    form: true
+  },
+  OPTION: {
+    form: true
+  },
+  TEXTAREA: {
+    form: true
+  },
+  LABEL: {
+    form: true
+  },
+  FIELDSET: {
+    form: true
+  },
+  LEGEND: {
+    form: true
+  },
+  OBJECT: {
+    form: true
+  },
+  OUTPUT: {
+    form: true
+  },
+  BUTTON: {
+    form: true
+  }
+};
+function preferAttr(tagName, propName) {
+  let tag = ATTR_OVERRIDES[tagName.toUpperCase()];
+  return !!(tag && tag[propName.toLowerCase()]);
+}
+
+export { normalizeProperty as n };

package/dist/prod/packages/shared-chunks/{reference-BNqcwZWH.js → reference-BshxG6wn.js}

@@ -1,6 +1,6 @@
-import { i as isDict, e as expect } from './collections-GpG8lT2g.js';
+import { i as isDict, e as expect } from './collections-C3Y8z_9v.js';
 import { setProp, getProp } from '../@glimmer/global-context/index.js';
-import { CONSTANT_TAG, INITIAL, validateTag, track, valueForTag, consumeTag } from '../@glimmer/validator/index.js';
+import { C as CONSTANT_TAG, I as INITIAL, v as validateTag, t as track, d as valueForTag, a as consumeTag } from './cache-BIlOoPA7.js';
 
 const REFERENCE = Symbol('REFERENCE');
 const CONSTANT = 0;
@@ -148,4 +148,4 @@ function childRefFromParts(root, parts) {
 }
 let createDebugAliasRef;
 
-export { FALSE_REFERENCE as F, NULL_REFERENCE as N, REFERENCE as R, TRUE_REFERENCE as T, UNDEFINED_REFERENCE as U, createConstRef as a, childRefFor as b, createComputeRef as c, createPrimitiveRef as d, isInvokableRef as e, childRefFromParts as f, createDebugAliasRef as g, createInvokableRef as h, isConstRef as i, createReadOnlyRef as j, createUnboundRef as k, isUpdatableRef as l, updateRef as u, valueForRef as v };
+export { FALSE_REFERENCE as F, NULL_REFERENCE as N, REFERENCE as R, TRUE_REFERENCE as T, UNDEFINED_REFERENCE as U, createComputeRef as a, isConstRef as b, createConstRef as c, isUpdatableRef as d, createPrimitiveRef as e, childRefFor as f, childRefFromParts as g, createDebugAliasRef as h, isInvokableRef as i, createInvokableRef as j, createReadOnlyRef as k, createUnboundRef as l, updateRef as u, valueForRef as v };

package/dist/prod/packages/shared-chunks/{registers-ylirb0dq.js → registers-DoamZwaG.js}

@@ -32,4 +32,4 @@ function isLowLevelRegister(register) {
   return register <= $sp;
 }
 
-export { $s0 as $, $pc as a, $ra as b, $fp as c, $sp as d, $v0 as e, $t1 as f, $t0 as g, $s1 as h, isLowLevelRegister as i };
+export { $s0 as $, $v0 as a, $t1 as b, $t0 as c, $s1 as d, $sp as e, $fp as f, $ra as g, $pc as h, isLowLevelRegister as i };

package/dist/{dev/packages/shared-chunks/rehydrate-builder-BRH0p0wA.js → prod/packages/shared-chunks/rehydrate-builder-BKg2X6Lo.js}

@@ -1,10 +1,8 @@
-import { C as ConcreteBounds, A as COMMENT_NODE, b as CursorImpl, B as TEXT_NODE, F as ELEMENT_NODE, N as NS_SVG } from './dynamic-CgX8M02_.js';
-import './fragment-Cc5k9Oy4.js';
-import { a as assert } from './assert-CUCJBR2C.js';
-import './debug-to-string-CFb7h0lY.js';
-import { e as expect } from './collections-D_nY_0UJ.js';
+import { N as NewTreeBuilder, R as RemoteBlock, C as COMMENT_NODE, T as TEXT_NODE, E as ELEMENT_NODE, e as NS_SVG } from './element-builder-BPjq0rxK.js';
 import { c as castToSimple, a as castToBrowser } from './simple-cast-DCvJLSin.js';
-import { N as NewTreeBuilder, R as RemoteBlock } from './element-builder-BpJIoi99.js';
+import { e as expect } from './collections-C3Y8z_9v.js';
+import { a as assert } from './assert-CUCJBR2C.js';
+import { C as ConcreteBounds, a as CursorImpl } from './normalize-D9jDJVGg.js';
 
 const SERIALIZATION_FIRST_NODE_STRING = '%+b:0%';
 function isSerializationFirstNode(node) {
@@ -383,7 +381,9 @@ class RehydrateTree extends NewTreeBuilder {
   }
   __pushRemoteElement(element, cursorId, insertBefore) {
     const marker = this.getMarker(castToBrowser(element), cursorId);
-    (!(!marker || marker.parentNode === element) && assert(!marker || marker.parentNode === element)); // when insertBefore is not present, we clear the element
+    assert(!marker || marker.parentNode === element);
+
+    // when insertBefore is not present, we clear the element
     if (insertBefore === undefined) {
       while (element.firstChild !== null && element.firstChild !== marker) {
         this.remove(element.firstChild);