ember-source 7.1.0-alpha.4 → 7.1.0-beta.1

package/dist/dev/packages/shared-chunks/on-BueSMv9L.js

@@ -0,0 +1,253 @@
+import { g as buildUntouchableThis, h as check, e as reifyNamed } from './untouchable-this-B3DVwpHS.js';
+import { registerDestructor } from '../@glimmer/destroyable/index.js';
+import { k as setInternalModifierManager } from './api-BawZUDYD.js';
+import { v as valueForRef } from './reference-BoPB2LfI.js';
+import { n as createUpdatableTag } from './cache-B7dqAS38.js';
+
+const untouchableContext = buildUntouchableThis('`on` modifier');
+class OnModifierState {
+  tag = createUpdatableTag();
+  element;
+  args;
+  listener = null;
+  constructor(element, args) {
+    this.element = element;
+    this.args = args;
+    registerDestructor(this, () => {
+      let {
+        element,
+        listener
+      } = this;
+      if (listener) {
+        let {
+          eventName,
+          callback,
+          options
+        } = listener;
+        removeEventListener(element, eventName, callback, options);
+      }
+    });
+  }
+
+  // Update this.listener if needed
+  updateListener() {
+    let {
+      element,
+      args,
+      listener
+    } = this;
+    let selector;
+    {
+      const el = this.element;
+      selector = el.tagName.toLowerCase() + (el.id ? `#${el.id}` : '') + Array.from(el.classList).map(c => `.${c}`).join('');
+    }
+    let arg0 = args.positional[0];
+    let eventName = check(arg0 ? valueForRef(arg0) : undefined);
+    if (!eventName) {
+      throw new Error(`You must pass a valid DOM event name as the first argument to the \`on\` modifier on ${selector}`);
+    }
+    let arg1 = args.positional[1];
+    let userProvidedCallback = check(arg1 ? valueForRef(arg1) : undefined);
+    if (typeof userProvidedCallback !== 'function') {
+      throw new Error(`You must pass a function as the second argument to the \`on\` modifier; you passed ${userProvidedCallback === null ? 'null' : typeof userProvidedCallback}. While rendering:\n\n${args.positional[1]?.debugLabel ?? '(unknown)'} on ${selector}`);
+    }
+    if (args.positional.length !== 2) {
+      throw new Error(`You can only pass two positional arguments (event name and callback) to the \`on\` modifier, but you provided ${args.positional.length}. Consider using the \`fn\` helper to provide additional arguments to the \`on\` callback on ${selector}`);
+    }
+    let once = undefined;
+    let passive = undefined;
+    let capture = undefined;
+    {
+      let {
+        once: _once,
+        passive: _passive,
+        capture: _capture,
+        ...extra
+      } = reifyNamed(args.named);
+      once = check(_once);
+      passive = check(_passive);
+      capture = check(_capture);
+      if (Object.keys(extra).length > 0) {
+        throw new Error(`You can only \`once\`, \`passive\` or \`capture\` named arguments to the \`on\` modifier, but you provided ${Object.keys(extra).join(', ')} on ${selector}`);
+      }
+    }
+    let shouldUpdate = false;
+    if (listener === null) {
+      shouldUpdate = true;
+    } else {
+      shouldUpdate = eventName !== listener.eventName || userProvidedCallback !== listener.userProvidedCallback || once !== listener.once || passive !== listener.passive || capture !== listener.capture;
+    }
+    let options = undefined;
+
+    // we want to handle both `true` and `false` because both have a meaning:
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=770208
+    if (shouldUpdate) {
+      if (once !== undefined || passive !== undefined || capture !== undefined) {
+        options = {
+          once,
+          passive,
+          capture
+        };
+      }
+    }
+    if (shouldUpdate) {
+      let callback = userProvidedCallback;
+      {
+        callback = userProvidedCallback.bind(untouchableContext);
+        if (passive) {
+          let _callback = callback;
+          callback = event => {
+            event.preventDefault = () => {
+              throw new Error(`You marked this listener as 'passive', meaning that you must not call 'event.preventDefault()': \n\n${userProvidedCallback.name || `{anonymous function}`}`);
+            };
+            return _callback(event);
+          };
+        }
+      }
+      this.listener = {
+        eventName,
+        callback,
+        userProvidedCallback,
+        once,
+        passive,
+        capture,
+        options
+      };
+      if (listener) {
+        removeEventListener(element, listener.eventName, listener.callback, listener.options);
+      }
+      addEventListener(element, eventName, callback, options);
+    }
+  }
+}
+let adds = 0;
+let removes = 0;
+function removeEventListener(element, eventName, callback, options) {
+  removes++;
+  element.removeEventListener(eventName, callback, options);
+}
+function addEventListener(element, eventName, callback, options) {
+  adds++;
+  element.addEventListener(eventName, callback, options);
+}
+
+/**
+  The `{{on}}` modifier lets you easily add event listeners (it uses
+  [EventTarget.addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)
+  internally).
+
+  For example, if you'd like to run a function on your component when a `<button>`
+  in the components template is clicked you might do something like:
+
+  ```app/components/like-post.hbs
+  <button {{on 'click' this.saveLike}}>Like this post!</button>
+  ```
+
+  ```app/components/like-post.js
+  import Component from '@glimmer/component';
+  import { action } from '@ember/object';
+
+  export default class LikePostComponent extends Component {
+    saveLike = () => {
+      // someone likes your post!
+      // better send a request off to your server...
+    }
+  }
+  ```
+
+  ### Arguments
+
+  `{{on}}` accepts two positional arguments, and a few named arguments.
+
+  The positional arguments are:
+
+  - `event` -- the name to use when calling `addEventListener`
+  - `callback` -- the function to be passed to `addEventListener`
+
+  The named arguments are:
+
+  - capture -- a `true` value indicates that events of this type will be dispatched
+    to the registered listener before being dispatched to any EventTarget beneath it
+    in the DOM tree.
+  - once -- indicates that the listener should be invoked at most once after being
+    added. If true, the listener would be automatically removed when invoked.
+  - passive -- if `true`, indicates that the function specified by listener will never
+    call preventDefault(). If a passive listener does call preventDefault(), the user
+    agent will do nothing other than generate a console warning. See
+    [Improving scrolling performance with passive listeners](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Improving_scrolling_performance_with_passive_listeners)
+    to learn more.
+
+  The callback function passed to `{{on}}` will receive any arguments that are passed
+  to the event handler. Most commonly this would be the `event` itself.
+
+  If you would like to pass additional arguments to the function you should use
+  the `{{fn}}` helper.
+
+  For example, in our example case above if you'd like to pass in the post that
+  was being liked when the button is clicked you could do something like:
+
+  ```app/components/like-post.hbs
+  <button {{on 'click' (fn this.saveLike @post)}}>Like this post!</button>
+  ```
+
+  In this case, the `saveLike` function will receive two arguments: the click event
+  and the value of `@post`.
+
+  ### Function Context
+
+  In the example above, we used an arrow function to ensure that `likePost` is
+  properly bound to the `items-list`, but let's explore what happens if we
+  left out the arrow function:
+
+  ```app/components/like-post.js
+  import Component from '@glimmer/component';
+
+  export default class LikePostComponent extends Component {
+    saveLike() {
+      // ...snip...
+    }
+  }
+  ```
+
+  In this example, when the button is clicked `saveLike` will be invoked,
+  it will **not** have access to the component instance. In other
+  words, it will have no `this` context, so please make sure your functions
+  are bound (via an arrow function or other means) before passing into `on`!
+
+  @method on
+  @public
+*/
+class OnModifierManager {
+  getDebugName() {
+    return 'on';
+  }
+  getDebugInstance() {
+    return null;
+  }
+  get counters() {
+    return {
+      adds,
+      removes
+    };
+  }
+  create(_owner, element, _state, args) {
+    return new OnModifierState(element, args);
+  }
+  getTag({
+    tag
+  }) {
+    return tag;
+  }
+  install(state) {
+    state.updateListener();
+  }
+  update(state) {
+    state.updateListener();
+  }
+  getDestroyable(state) {
+    return state;
+  }
+}
+const on = setInternalModifierManager(new OnModifierManager(), {});
+
+export { on as o };

package/dist/dev/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/dev/packages/shared-chunks/or-O0eJQ4K-.js

@@ -0,0 +1,118 @@
+import { toBool } from '../@glimmer/global-context/index.js';
+import { a as createComputeRef, v as valueForRef } from './reference-BoPB2LfI.js';
+import { i as internalHelper } from './hash-BRRFQJ99.js';
+
+const and = internalHelper(({
+  positional
+}) => {
+  if (positional.length < 2) {
+    throw new Error(`\`and\` expects at least two arguments, but received ${positional.length}.`);
+  }
+  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) {
+  if (arguments.length !== 2) {
+    throw new Error(`\`eq\` expects exactly two arguments, but received ${arguments.length}.`);
+  }
+  return left === right;
+}
+
+/**
+ * Performs a greater than comparison.
+ *
+ * left > right
+ */
+function gt(left, right) {
+  if (arguments.length !== 2) {
+    throw new Error(`\`gt\` expects exactly two arguments, but received ${arguments.length}.`);
+  }
+  return left > right;
+}
+
+/**
+ * Performs a greater than or equal comparison.
+ *
+ * left >= right
+ */
+function gte(left, right) {
+  if (arguments.length !== 2) {
+    throw new Error(`\`gte\` expects exactly two arguments, but received ${arguments.length}.`);
+  }
+  return left >= right;
+}
+
+/**
+ * Performs a less than comparison.
+ *
+ * left < right
+ */
+function lt(left, right) {
+  if (arguments.length !== 2) {
+    throw new Error(`\`lt\` expects exactly two arguments, but received ${arguments.length}.`);
+  }
+  return left < right;
+}
+
+/**
+ * Performs a less than or equal comparison.
+ *
+ * left <= right
+ */
+function lte(left, right) {
+  if (arguments.length !== 2) {
+    throw new Error(`\`lte\` expects exactly two arguments, but received ${arguments.length}.`);
+  }
+  return left <= right;
+}
+
+/**
+ * Performs a strict inequality comparison.
+ *
+ * left !== right
+ */
+function neq(left, right) {
+  if (arguments.length !== 2) {
+    throw new Error(`\`neq\` expects exactly two arguments, but received ${arguments.length}.`);
+  }
+  return left !== right;
+}
+
+const not = (...args) => {
+  if (args.length !== 1) {
+    throw new Error(`\`not\` expects exactly one argument, but received ${args.length}.`);
+  }
+  return !toBool(args[0]);
+};
+
+const or = internalHelper(({
+  positional
+}) => {
+  if (positional.length < 2) {
+    throw new Error(`\`or\` expects at least two arguments, but received ${positional.length}.`);
+  }
+  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/{prod/packages/shared-chunks/program-B7SJZ5NF.js → dev/packages/shared-chunks/program-DzAfcWFj.js}

@@ -1,4 +1,4 @@
-import { u as unwrap } from './collections-GpG8lT2g.js';
+import { u as unwrap } from './collections-DPkjqeA3.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/{prod/packages/shared-chunks/program-context-DFiwaPMR.js → dev/packages/shared-chunks/program-context-CadjldRr.js}

@@ -1,7 +1,8 @@
-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-D7nBU9ae.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 } from './syscall-ops-BPFtDquC.js';
+import { V as VM_INVOKE_STATIC_OP } from './vm-ops-ImHv0Wtg.js';
+import { $ as $s0 } from './registers-C_W2qYHJ.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-CjaDF9kC.js';
+import { f as EncoderImpl, g as encodeOp, i as invokePreparedComponent, S as SwitchCases, h as InvokeBareComponent, C as CallDynamic } from './index-CyZiGiEI.js';
 
 class StdLib {
   constructor(main, trustingGuardedAppend, cautiousGuardedAppend, trustingNonDynamicAppend, cautiousNonDynamicAppend) {

package/dist/dev/packages/shared-chunks/property_get-CIBS9umw.js

@@ -0,0 +1,139 @@
+import { s as setProxy } from './is_proxy-Bzg0d4m4.js';
+import { isEmberArray } from '../@ember/array/-internals.js';
+import '../@ember/debug/index.js';
+import { w as track, u as isTracking, k as consumeTag } from './cache-B7dqAS38.js';
+import { t as tagFor } from './meta-BmRXesrk.js';
+import { C as Cache } from './cache-qDyqAcpg.js';
+import { assert } from '../@ember/debug/lib/assert.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');
+let getPossibleMandatoryProxyValue;
+{
+  getPossibleMandatoryProxyValue = function getPossibleMandatoryProxyValue(obj, keyName) {
+    let content = obj[PROXY_CONTENT];
+    if (content === undefined) {
+      return obj[keyName];
+    } else {
+      /* global Reflect */
+      return Reflect.get(content, keyName, obj);
+    }
+  };
+}
+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) {
+  (!(arguments.length === 2) && assert(`Get must be called with two arguments; an object and a property key`, arguments.length === 2));
+  (!(obj !== undefined && obj !== null) && assert(`Cannot call get with '${keyName}' on an undefined object.`, obj !== undefined && obj !== null));
+  (!(typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName)) && assert(`The key provided to get must be a string or number, you passed ${keyName}`, typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName)));
+  (!(typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0) && assert(`'this' in paths is not supported`, typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0));
+  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 = getPossibleMandatoryProxyValue(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 _, getPossibleMandatoryProxyValue as a, _getProp as b, get as g, hasUnknownProperty as h, isPath as i };

package/dist/dev/packages/shared-chunks/{property_set-DaoZXGM5.js → property_set-D3PKyisF.js}

@@ -1,7 +1,9 @@
-import { b as setWithMandatorySetter, l as lookupDescriptor } from './mandatory-setter-DHZe7-kW.js';
+import { s as setWithMandatorySetter, l as lookupDescriptor } from './mandatory-setter-BpbAMTzV.js';
 import { t as toString } from './to-string-C7M8LBLH.js';
 import '../@ember/debug/index.js';
-import { m as isPath, _ as _getPath, o as COMPUTED_SETTERS, p as getPossibleMandatoryProxyValue, n as notifyPropertyChange } from './observers-Bj9qLVau.js';
+import { C as COMPUTED_SETTERS } from './decorator-B5Uh5NFI.js';
+import { i as isPath, _ as _getPath, a as getPossibleMandatoryProxyValue } from './property_get-CIBS9umw.js';
+import { n as notifyPropertyChange } from './computed-CJnghmXC.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 /**

package/dist/dev/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/dev/packages/shared-chunks/{reference-C3TKDRnP.js → reference-BoPB2LfI.js}

@@ -1,7 +1,6 @@
-import './debug-to-string-CFb7h0lY.js';
-import { i as isDict, e as expect } from './collections-D_nY_0UJ.js';
+import { i as isDict, e as expect } from './collections-DPkjqeA3.js';
 import { setProp, getProp } from '../@glimmer/global-context/index.js';
-import { CONSTANT_TAG, INITIAL, validateTag, track, valueForTag, consumeTag } from '../@glimmer/validator/index.js';
+import { b as CONSTANT_TAG, I as INITIAL, y as validateTag, w as track, z as valueForTag, k as consumeTag } from './cache-B7dqAS38.js';
 
 const REFERENCE = Symbol('REFERENCE');
 const CONSTANT = 0;
@@ -173,4 +172,4 @@ 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, createDebugAliasRef as e, isInvokableRef as f, childRefFromParts 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, isInvokableRef as b, createConstRef as c, isUpdatableRef as d, createPrimitiveRef as e, childRefFor as f, childRefFromParts as g, createDebugAliasRef as h, isConstRef as i, createInvokableRef as j, createReadOnlyRef as k, createUnboundRef as l, updateRef as u, valueForRef as v };