ember-source 6.12.0-beta.3 → 7.0.0-alpha.1

package/dist/prod/packages/rsvp/index.js

@@ -0,0 +1 @@
+export { E as EventTarget, P as Promise, b as all, d as allSettled, e as asap, f as async, g as cast, c as configure, a as default, h as defer, i as denodeify, j as filter, k as hash, l as hashSettled, m as map, n as off, o as on, r as race, p as reject, q as resolve, s as rethrow } from '../shared-chunks/rsvp-CnCSY930.js';

package/dist/prod/packages/shared-chunks/alias-BkT-0B1G.js

@@ -0,0 +1,81 @@
+import { meta } from '../@ember/-internals/meta/lib/meta.js';
+import '../@ember/-internals/environment/index.js';
+import inspect from '../@ember/debug/lib/inspect.js';
+import { tagMetaFor, tagFor, untrack, validateTag, updateTag as UPDATE_TAG, valueForTag, consumeTag } from '../@glimmer/validator/index.js';
+import { C as CHAIN_PASS_THROUGH, g as get, k as getChainTagsForKey, l as finishLazyChains } from './observers-R1ZklwWy.js';
+import { m as makeComputedDecorator, b as descriptorForDecorator, c as ComputedDescriptor } from './decorator-BdDDBUd2.js';
+import { d as defineProperty } from './namespace_search-Aog9nySA.js';
+import { s as set } from './property_set-O080KTKZ.js';
+
+function alias(altKey) {
+  return makeComputedDecorator(new AliasedProperty(altKey), AliasDecoratorImpl);
+}
+
+// TODO: This class can be svelted once `meta` has been deprecated
+class AliasDecoratorImpl extends Function {
+  readOnly() {
+    descriptorForDecorator(this).readOnly();
+    return this;
+  }
+  oneWay() {
+    descriptorForDecorator(this).oneWay();
+    return this;
+  }
+  meta(meta) {
+    let prop = descriptorForDecorator(this);
+    if (arguments.length === 0) {
+      return prop._meta || {};
+    } else {
+      prop._meta = meta;
+    }
+  }
+}
+class AliasedProperty extends ComputedDescriptor {
+  altKey;
+  constructor(altKey) {
+    super();
+    this.altKey = altKey;
+  }
+  setup(obj, keyName, propertyDesc, meta) {
+    super.setup(obj, keyName, propertyDesc, meta);
+    CHAIN_PASS_THROUGH.add(this);
+  }
+  get(obj, keyName) {
+    let ret;
+    let meta$1 = meta(obj);
+    let tagMeta = tagMetaFor(obj);
+    let propertyTag = tagFor(obj, keyName, tagMeta);
+
+    // We don't use the tag since CPs are not automatic, we just want to avoid
+    // anything tracking while we get the altKey
+    untrack(() => {
+      ret = get(obj, this.altKey);
+    });
+    let lastRevision = meta$1.revisionFor(keyName);
+    if (lastRevision === undefined || !validateTag(propertyTag, lastRevision)) {
+      UPDATE_TAG(propertyTag, getChainTagsForKey(obj, this.altKey, tagMeta, meta$1));
+      meta$1.setRevisionFor(keyName, valueForTag(propertyTag));
+      finishLazyChains(meta$1, keyName, ret);
+    }
+    consumeTag(propertyTag);
+    return ret;
+  }
+  set(obj, _keyName, value) {
+    return set(obj, this.altKey, value);
+  }
+  readOnly() {
+    this.set = AliasedProperty_readOnlySet;
+  }
+  oneWay() {
+    this.set = AliasedProperty_oneWaySet;
+  }
+}
+function AliasedProperty_readOnlySet(obj, keyName) {
+  throw new Error(`Cannot set read-only property '${keyName}' on object: ${inspect(obj)}`);
+}
+function AliasedProperty_oneWaySet(obj, keyName, value) {
+  defineProperty(obj, keyName, null);
+  return set(obj, keyName, value);
+}
+
+export { alias as a };

package/dist/prod/packages/shared-chunks/api-Co-k4HVs.js

@@ -0,0 +1,200 @@
+import { associateDestroyableChild } from '../@glimmer/destroyable/index.js';
+import '../@glimmer/validator/index.js';
+import { c as createComputeRef, a as createConstRef, U as UNDEFINED_REFERENCE } from './reference-BNqcwZWH.js';
+import { a as argsProxyFor } from './args-proxy-Dl0A0YWI.js';
+import { b as buildCapabilities } from './capabilities-DGmQ_mz4.js';
+
+function helperCapabilities(managerAPI, options = {}) {
+  return buildCapabilities({
+    hasValue: Boolean(options.hasValue),
+    hasDestroyable: Boolean(options.hasDestroyable),
+    hasScheduledEffect: Boolean(options.hasScheduledEffect)
+  });
+}
+
+////////////
+
+function hasValue(manager) {
+  return manager.capabilities.hasValue;
+}
+function hasDestroyable(manager) {
+  return manager.capabilities.hasDestroyable;
+}
+
+////////////
+
+class CustomHelperManager {
+  constructor(factory) {
+    this.factory = factory;
+  }
+  helperManagerDelegates = new WeakMap();
+  undefinedDelegate = null;
+  getDelegateForOwner(owner) {
+    let delegate = this.helperManagerDelegates.get(owner);
+    if (delegate === undefined) {
+      let {
+        factory
+      } = this;
+      delegate = factory(owner);
+      this.helperManagerDelegates.set(owner, delegate);
+    }
+    return delegate;
+  }
+  getDelegateFor(owner) {
+    if (owner === undefined) {
+      let {
+        undefinedDelegate
+      } = this;
+      if (undefinedDelegate === null) {
+        let {
+          factory
+        } = this;
+        this.undefinedDelegate = undefinedDelegate = factory(undefined);
+      }
+      return undefinedDelegate;
+    } else {
+      return this.getDelegateForOwner(owner);
+    }
+  }
+  getHelper(definition) {
+    return (capturedArgs, owner) => {
+      let manager = this.getDelegateFor(owner);
+      const args = argsProxyFor(capturedArgs);
+      const bucket = manager.createHelper(definition, args);
+      if (hasValue(manager)) {
+        let cache = createComputeRef(() => manager.getValue(bucket), null, false /* DEBUG */);
+        if (hasDestroyable(manager)) {
+          associateDestroyableChild(cache, manager.getDestroyable(bucket));
+        }
+        return cache;
+      } else if (hasDestroyable(manager)) {
+        let ref = createConstRef(undefined);
+        associateDestroyableChild(ref, manager.getDestroyable(bucket));
+        return ref;
+      } else {
+        return UNDEFINED_REFERENCE;
+      }
+    };
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+class FunctionHelperManager {
+  capabilities = buildCapabilities({
+    hasValue: true,
+    hasDestroyable: false,
+    hasScheduledEffect: false
+  });
+  createHelper(fn, args) {
+    return {
+      fn,
+      args
+    };
+  }
+  getValue({
+    fn,
+    args
+  }) {
+    if (Object.keys(args.named).length > 0) {
+      let argsForFn = [...args.positional, args.named];
+      return fn(...argsForFn);
+    }
+    return fn(...args.positional);
+  }
+  getDebugName(fn) {
+    if (fn.name) {
+      return `(helper function ${fn.name})`;
+    }
+    return '(anonymous helper function)';
+  }
+}
+
+const COMPONENT_MANAGERS = new WeakMap();
+const MODIFIER_MANAGERS = new WeakMap();
+const HELPER_MANAGERS = new WeakMap();
+
+///////////
+
+/**
+ * There is also Reflect.getPrototypeOf,
+ * which errors when non-objects are passed.
+ *
+ * Since our conditional for figuring out whether to render primitives or not
+ * may contain non-object values, we don't want to throw errors when we call this.
+ */
+const getPrototypeOf = Object.getPrototypeOf;
+function setManager(map, manager, obj) {
+  map.set(obj, manager);
+  return obj;
+}
+function getManager(map, obj) {
+  let pointer = obj;
+  while (pointer !== null) {
+    const manager = map.get(pointer);
+    if (manager !== undefined) {
+      return manager;
+    }
+    pointer = getPrototypeOf(pointer);
+  }
+  return undefined;
+}
+
+///////////
+
+function setInternalModifierManager(manager, definition) {
+  return setManager(MODIFIER_MANAGERS, manager, definition);
+}
+function getInternalModifierManager(definition, isOptional) {
+  const manager = getManager(MODIFIER_MANAGERS, definition);
+  if (manager === undefined) {
+    return null;
+  }
+  return manager;
+}
+function setInternalHelperManager(manager, definition) {
+  return setManager(HELPER_MANAGERS, manager, definition);
+}
+const DEFAULT_MANAGER = new CustomHelperManager(() => new FunctionHelperManager());
+function getInternalHelperManager(definition, isOptional) {
+  let manager = getManager(HELPER_MANAGERS, definition);
+
+  // Functions are special-cased because functions are defined
+  // as the "default" helper, per: https://github.com/emberjs/rfcs/pull/756
+  if (manager === undefined && typeof definition === 'function') {
+    manager = DEFAULT_MANAGER;
+  }
+  if (manager) {
+    return manager;
+  } else if (isOptional === true) {
+    return null;
+  } else ;
+  return null;
+}
+function setInternalComponentManager(factory, obj) {
+  return setManager(COMPONENT_MANAGERS, factory, obj);
+}
+function getInternalComponentManager(definition, isOptional) {
+  const manager = getManager(COMPONENT_MANAGERS, definition);
+  if (manager === undefined) {
+    return null;
+  }
+  return manager;
+}
+
+///////////
+
+function hasInternalComponentManager(definition) {
+  return getManager(COMPONENT_MANAGERS, definition) !== undefined;
+}
+function hasInternalHelperManager(definition) {
+  return hasDefaultHelperManager(definition) || getManager(HELPER_MANAGERS, definition) !== undefined;
+}
+function hasInternalModifierManager(definition) {
+  return getManager(MODIFIER_MANAGERS, definition) !== undefined;
+}
+function hasDefaultHelperManager(definition) {
+  return typeof definition === 'function';
+}
+
+export { CustomHelperManager as C, hasDestroyable as a, hasInternalComponentManager as b, helperCapabilities as c, getInternalModifierManager as d, getInternalComponentManager as e, hasInternalHelperManager as f, getInternalHelperManager as g, hasValue as h, setInternalHelperManager as i, setInternalModifierManager as j, hasInternalModifierManager as k, setInternalComponentManager as s };

package/dist/prod/packages/shared-chunks/args-proxy-Dl0A0YWI.js

@@ -0,0 +1,131 @@
+import { track } from '../@glimmer/validator/index.js';
+import { v as valueForRef } from './reference-BNqcwZWH.js';
+
+const CUSTOM_TAG_FOR = new WeakMap();
+function getCustomTagFor(obj) {
+  return CUSTOM_TAG_FOR.get(obj);
+}
+function setCustomTagFor(obj, customTagFn) {
+  CUSTOM_TAG_FOR.set(obj, customTagFn);
+}
+function convertToInt(prop) {
+  if (typeof prop === 'symbol') return null;
+  const num = Number(prop);
+  if (isNaN(num)) return null;
+  return num % 1 === 0 ? num : null;
+}
+function tagForNamedArg(namedArgs, key) {
+  return track(() => {
+    if (key in namedArgs) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+      valueForRef(namedArgs[key]);
+    }
+  });
+}
+function tagForPositionalArg(positionalArgs, key) {
+  return track(() => {
+    if (key === '[]') {
+      // consume all of the tags in the positional array
+      positionalArgs.forEach(valueForRef);
+    }
+    const parsed = convertToInt(key);
+    if (parsed !== null && parsed >= 0 && parsed < positionalArgs.length) {
+      // consume the tag of the referenced index
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+      valueForRef(positionalArgs[parsed]);
+    }
+  });
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- @fixme
+class NamedArgsProxy {
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- @fixme
+
+  constructor(named) {
+    this.named = named;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- @fixme
+  get(_target, prop) {
+    const ref = this.named[prop];
+    if (ref !== undefined) {
+      return valueForRef(ref);
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- @fixme
+  has(_target, prop) {
+    return prop in this.named;
+  }
+  ownKeys() {
+    return Object.keys(this.named);
+  }
+  isExtensible() {
+    return false;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- @fixme
+  getOwnPropertyDescriptor(_target, prop) {
+    return {
+      enumerable: true,
+      configurable: true
+    };
+  }
+}
+class PositionalArgsProxy {
+  constructor(positional) {
+    this.positional = positional;
+  }
+  get(target, prop) {
+    let {
+      positional
+    } = this;
+    if (prop === 'length') {
+      return positional.length;
+    }
+    const parsed = convertToInt(prop);
+    if (parsed !== null && parsed >= 0 && parsed < positional.length) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+      return valueForRef(positional[parsed]);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+    return target[prop];
+  }
+  isExtensible() {
+    return false;
+  }
+  has(_target, prop) {
+    const parsed = convertToInt(prop);
+    return parsed !== null && parsed >= 0 && parsed < this.positional.length;
+  }
+}
+const argsProxyFor = (capturedArgs, type) => {
+  const {
+    named,
+    positional
+  } = capturedArgs;
+  let getNamedTag = (_obj, key) => tagForNamedArg(named, key);
+  let getPositionalTag = (_obj, key) => tagForPositionalArg(positional, key);
+  const namedHandler = new NamedArgsProxy(named);
+  const positionalHandler = new PositionalArgsProxy(positional);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const namedTarget = Object.create(null);
+  const positionalTarget = [];
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const namedProxy = new Proxy(namedTarget, namedHandler);
+  const positionalProxy = new Proxy(positionalTarget, positionalHandler);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  setCustomTagFor(namedProxy, getNamedTag);
+  setCustomTagFor(positionalProxy, getPositionalTag);
+  return {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    named: namedProxy,
+    positional: positionalProxy
+  };
+};
+
+export { argsProxyFor as a, getCustomTagFor as g, setCustomTagFor as s };

package/dist/prod/packages/shared-chunks/array-EwekEvId.js

@@ -0,0 +1,117 @@
+import '../@ember/-internals/environment/index.js';
+import { peekMeta } from '../@ember/-internals/meta/lib/meta.js';
+import { s as sendEvent, e as addListener, f as removeListener } from './observers-R1ZklwWy.js';
+import { n as notifyPropertyChange } from './namespace_search-Aog9nySA.js';
+
+function arrayContentWillChange(array, startIdx, removeAmt, addAmt) {
+  // if no args are passed assume everything changes
+  if (startIdx === undefined) {
+    startIdx = 0;
+    removeAmt = addAmt = -1;
+  } else {
+    if (removeAmt === undefined) {
+      removeAmt = -1;
+    }
+    if (addAmt === undefined) {
+      addAmt = -1;
+    }
+  }
+  sendEvent(array, '@array:before', [array, startIdx, removeAmt, addAmt]);
+  return array;
+}
+function arrayContentDidChange(array, startIdx, removeAmt, addAmt, notify = true) {
+  // if no args are passed assume everything changes
+  if (startIdx === undefined) {
+    startIdx = 0;
+    removeAmt = addAmt = -1;
+  } else {
+    if (removeAmt === undefined) {
+      removeAmt = -1;
+    }
+    if (addAmt === undefined) {
+      addAmt = -1;
+    }
+  }
+  let meta = peekMeta(array);
+  if (notify) {
+    if (addAmt < 0 || removeAmt < 0 || addAmt - removeAmt !== 0) {
+      notifyPropertyChange(array, 'length', meta);
+    }
+    notifyPropertyChange(array, '[]', meta);
+  }
+  sendEvent(array, '@array:change', [array, startIdx, removeAmt, addAmt]);
+  if (meta !== null) {
+    let length = array.length;
+    let addedAmount = addAmt === -1 ? 0 : addAmt;
+    let removedAmount = removeAmt === -1 ? 0 : removeAmt;
+    let delta = addedAmount - removedAmount;
+    let previousLength = length - delta;
+    let normalStartIdx = startIdx < 0 ? previousLength + startIdx : startIdx;
+    if (meta.revisionFor('firstObject') !== undefined && normalStartIdx === 0) {
+      notifyPropertyChange(array, 'firstObject', meta);
+    }
+    if (meta.revisionFor('lastObject') !== undefined) {
+      let previousLastIndex = previousLength - 1;
+      let lastAffectedIndex = normalStartIdx + removedAmount;
+      if (previousLastIndex < lastAffectedIndex) {
+        notifyPropertyChange(array, 'lastObject', meta);
+      }
+    }
+  }
+  return array;
+}
+
+const EMPTY_ARRAY = Object.freeze([]);
+
+// Ideally, we'd use MutableArray.detect but for unknown reasons this causes
+// the node tests to fail strangely.
+function isMutableArray(obj) {
+  return obj != null && typeof obj.replace === 'function';
+}
+function replace(array, start, deleteCount, items = EMPTY_ARRAY) {
+  if (isMutableArray(array)) {
+    array.replace(start, deleteCount, items);
+  } else {
+    replaceInNativeArray(array, start, deleteCount, items);
+  }
+}
+const CHUNK_SIZE = 60000;
+
+// To avoid overflowing the stack, we splice up to CHUNK_SIZE items at a time.
+// See https://code.google.com/p/chromium/issues/detail?id=56588 for more details.
+function replaceInNativeArray(array, start, deleteCount, items) {
+  arrayContentWillChange(array, start, deleteCount, items.length);
+  if (items.length <= CHUNK_SIZE) {
+    array.splice(start, deleteCount, ...items);
+  } else {
+    array.splice(start, deleteCount);
+    for (let i = 0; i < items.length; i += CHUNK_SIZE) {
+      let chunk = items.slice(i, i + CHUNK_SIZE);
+      array.splice(start + i, 0, ...chunk);
+    }
+  }
+  arrayContentDidChange(array, start, deleteCount, items.length);
+}
+function arrayObserversHelper(obj, target, opts, operation) {
+  let {
+    willChange,
+    didChange
+  } = opts;
+  operation(obj, '@array:before', target, willChange);
+  operation(obj, '@array:change', target, didChange);
+
+  /*
+   * Array proxies have a `_revalidate` method which must be called to set
+   * up their internal array observation systems.
+   */
+  obj._revalidate?.();
+  return obj;
+}
+function addArrayObserver(array, target, opts) {
+  return arrayObserversHelper(array, target, opts, addListener);
+}
+function removeArrayObserver(array, target, opts) {
+  return arrayObserversHelper(array, target, opts, removeListener);
+}
+
+export { arrayContentWillChange as a, arrayContentDidChange as b, addArrayObserver as c, removeArrayObserver as d, replaceInNativeArray as e, replace as r };

package/dist/prod/packages/shared-chunks/array-utils-CZQxrdD3.js

@@ -0,0 +1,45 @@
+const EMPTY_ARRAY = Object.freeze([]);
+function emptyArray() {
+  return EMPTY_ARRAY;
+}
+const EMPTY_STRING_ARRAY = emptyArray();
+const EMPTY_NUMBER_ARRAY = emptyArray();
+
+/**
+ * This function returns `true` if the input array is the special empty array sentinel,
+ * which is sometimes used for optimizations.
+ */
+function isEmptyArray(input) {
+  return input === EMPTY_ARRAY;
+}
+function* reverse(input) {
+  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];
+  }
+}
+/**
+ * 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* 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, undefined, right[i]];
+  }
+}
+
+export { EMPTY_ARRAY as E, EMPTY_NUMBER_ARRAY as a, EMPTY_STRING_ARRAY as b, emptyArray as c, zipTuples as d, enumerate as e, isEmptyArray as i, reverse as r, zipArrays as z };

package/dist/prod/packages/shared-chunks/assert-CUCJBR2C.js

@@ -0,0 +1,19 @@
+// import Logger from './logger';
+
+function assert(test, msg) {
+}
+
+/**
+ * This constant exists to make it easier to differentiate normal logs from
+ * 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.
+ */
+const LOGGER = console;
+function assertNever(value, desc = 'unexpected unreachable branch') {
+  LOGGER.log('unreachable', value);
+  LOGGER.log(`${desc} :: ${JSON.stringify(value)} (${value})`);
+  throw new Error(`code reached unreachable`);
+}
+
+export { assert as a, assertNever as b };

package/dist/prod/packages/shared-chunks/cache-qDyqAcpg.js

@@ -0,0 +1,35 @@
+class Cache {
+  size = 0;
+  misses = 0;
+  hits = 0;
+  constructor(limit, func, store = new Map()) {
+    this.limit = limit;
+    this.func = func;
+    this.store = store;
+  }
+  get(key) {
+    if (this.store.has(key)) {
+      this.hits++;
+      // SAFETY: we know the value is present because `.has(key)` was `true`.
+      return this.store.get(key);
+    } else {
+      this.misses++;
+      return this.set(key, this.func(key));
+    }
+  }
+  set(key, value) {
+    if (this.limit > this.size) {
+      this.size++;
+      this.store.set(key, value);
+    }
+    return value;
+  }
+  purge() {
+    this.store.clear();
+    this.size = 0;
+    this.hits = 0;
+    this.misses = 0;
+  }
+}
+
+export { Cache as C };

package/dist/prod/packages/shared-chunks/capabilities-DGmQ_mz4.js

@@ -0,0 +1,26 @@
+import './fragment-EpVz5Xuc.js';
+import '../@glimmer/validator/index.js';
+import './reference-BNqcwZWH.js';
+import { I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
+
+function buildCapabilities(capabilities) {
+  return capabilities;
+}
+const EMPTY = InternalComponentCapabilities.Empty;
+/**
+ * Converts a ComponentCapabilities object into a 32-bit integer representation.
+ */
+function capabilityFlagsFrom(capabilities) {
+  return EMPTY | capability(capabilities, 'dynamicLayout') | capability(capabilities, 'dynamicTag') | capability(capabilities, 'prepareArgs') | capability(capabilities, 'createArgs') | capability(capabilities, 'attributeHook') | capability(capabilities, 'elementHook') | capability(capabilities, 'dynamicScope') | capability(capabilities, 'createCaller') | capability(capabilities, 'updateHook') | capability(capabilities, 'createInstance') | capability(capabilities, 'wrapped') | capability(capabilities, 'willDestroy') | capability(capabilities, 'hasSubOwner');
+}
+function capability(capabilities, capability) {
+  return capabilities[capability] ? InternalComponentCapabilities[capability] : EMPTY;
+}
+function managerHasCapability(_manager, capabilities, capability) {
+  return !!(capabilities & capability);
+}
+function hasCapability(capabilities, capability) {
+  return !!(capabilities & capability);
+}
+
+export { buildCapabilities as b, capabilityFlagsFrom as c, hasCapability as h, managerHasCapability as m };