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

package/dist/prod/packages/shared-chunks/{setup-registry-Cs-7NIJU.js → setup-registry-C2KfZJWI.js}

@@ -1,17 +1,38 @@
 import { privatize } from '../@ember/-internals/container/index.js';
 import { getOwner } from '../@ember/-internals/owner/index.js';
-import './super-Cm_a_cLQ.js';
-import '../@ember/-internals/environment/index.js';
-import { O as OutletView, a as OutletTemplate, I as Input, L as LinkTo, T as Textarea, R as RootTemplate, b as Renderer } from './index-r-Dz_hzt.js';
-import './fragment-D7nBU9ae.js';
-import '../@glimmer/validator/index.js';
-import './reference-BNqcwZWH.js';
-import './on-CersD7PL.js';
-import './constants-DThhT5fu.js';
-import './capabilities-DXA-L0iT.js';
-import { c as clientBuilder } from './element-builder-CzXb9l1W.js';
-import { r as rehydrationBuilder } from './rehydrate-builder-D3t52iGR.js';
-import { s as serializeBuilder } from './serialize-builder-iXiRs1Pg.js';
+import { I as Input, T as Textarea } from './textarea-CHqL0Rdh.js';
+import { LinkTo } from '../@ember/routing/index.js';
+import './render-DkJJmoI4.js';
+import { c as clientBuilder } from './element-builder-CnlTPNyw.js';
+import { r as rehydrationBuilder } from './rehydrate-builder-DJ8k-6fg.js';
+import { s as serializeBuilder } from './serialize-builder-R3Ozg0sC.js';
+import { o as outletHelper, O as OutletView, R as Renderer } from './index-qDFz6Mfe.js';
+import { t as templateFactory } from './index-Bj71BDDA.js';
+
+const OutletTemplate = templateFactory(
+/*
+  {{component (outletHelper)}}
+*/
+{
+  "id": null,
+  "block": "[[[46,[28,[32,0],null,null],null,null,null]],[],[\"component\"]]",
+  "moduleName": "packages/@ember/-internals/glimmer/lib/templates/outlet.hbs",
+  "scope": () => ({
+    outletHelper
+  }),
+  "isStrictMode": true
+});
+
+const RootTemplate = templateFactory(
+/*
+  {{component this}}
+*/
+{
+  "id": null,
+  "block": "[[[46,[30,0],null,null,null]],[],[\"component\"]]",
+  "moduleName": "packages/@ember/-internals/glimmer/lib/templates/root.hbs",
+  "isStrictMode": true
+});
 
 function setupApplicationRegistry(registry) {
   // because we are using injections we can't use instantiate false
@@ -50,4 +71,4 @@ function setupEngineRegistry(registry) {
   registry.register('component:textarea', Textarea);
 }
 
-export { setupEngineRegistry as a, setupApplicationRegistry as s };
+export { RootTemplate as R, setupEngineRegistry as a, setupApplicationRegistry as s };

package/dist/prod/packages/shared-chunks/spec-BXl1reqK.js

@@ -0,0 +1,16 @@
+/**
+  Returns whether Type(value) is Object.
+
+  Useful for checking whether a value is a valid WeakMap key.
+
+  Refs: https://tc39.github.io/ecma262/#sec-typeof-operator-runtime-semantics-evaluation
+        https://tc39.github.io/ecma262/#sec-weakmap.prototype.set
+
+  @private
+  @function isObject
+*/
+function isObject(value) {
+  return value !== null && (typeof value === 'object' || typeof value === 'function');
+}
+
+export { isObject as i };

package/dist/prod/packages/shared-chunks/super-BBBjgF69.js

@@ -0,0 +1,91 @@
+const HAS_SUPER_PATTERN = /\.(_super|call\(this|apply\(this)/;
+const fnToString = Function.prototype.toString;
+const checkHasSuper = (() => {
+  let sourceAvailable = fnToString.call(function () {
+    return this;
+  }).indexOf('return this') > -1;
+  if (sourceAvailable) {
+    return function checkHasSuper(func) {
+      return HAS_SUPER_PATTERN.test(fnToString.call(func));
+    };
+  }
+  return function checkHasSuper() {
+    return true;
+  };
+})();
+const HAS_SUPER_MAP = new WeakMap();
+const ROOT = Object.freeze(function () {});
+HAS_SUPER_MAP.set(ROOT, false);
+function hasSuper(func) {
+  let hasSuper = HAS_SUPER_MAP.get(func);
+  if (hasSuper === undefined) {
+    hasSuper = checkHasSuper(func);
+    HAS_SUPER_MAP.set(func, hasSuper);
+  }
+  return hasSuper;
+}
+class ObserverListenerMeta {
+  listeners = undefined;
+  observers = undefined;
+}
+const OBSERVERS_LISTENERS_MAP = new WeakMap();
+function createObserverListenerMetaFor(fn) {
+  let meta = OBSERVERS_LISTENERS_MAP.get(fn);
+  if (meta === undefined) {
+    meta = new ObserverListenerMeta();
+    OBSERVERS_LISTENERS_MAP.set(fn, meta);
+  }
+  return meta;
+}
+function observerListenerMetaFor(fn) {
+  return OBSERVERS_LISTENERS_MAP.get(fn);
+}
+function setObservers(func, observers) {
+  let meta = createObserverListenerMetaFor(func);
+  meta.observers = observers;
+}
+function setListeners(func, listeners) {
+  let meta = createObserverListenerMetaFor(func);
+  meta.listeners = listeners;
+}
+const IS_WRAPPED_FUNCTION_SET = new WeakSet();
+
+/**
+  Wraps the passed function so that `this._super` will point to the superFunc
+  when the function is invoked. This is the primitive we use to implement
+  calls to super.
+
+  @private
+  @method wrap
+  @for Ember
+  @param {Function} func The function to call
+  @param {Function} superFunc The super function.
+  @return {Function} wrapped function.
+*/
+function wrap(func, superFunc) {
+  if (!hasSuper(func)) {
+    return func;
+  }
+  // ensure an unwrapped super that calls _super is wrapped with a terminal _super
+  if (!IS_WRAPPED_FUNCTION_SET.has(superFunc) && hasSuper(superFunc)) {
+    return _wrap(func, _wrap(superFunc, ROOT));
+  }
+  return _wrap(func, superFunc);
+}
+function _wrap(func, superFunc) {
+  function superWrapper() {
+    let orig = this._super;
+    this._super = superFunc;
+    let ret = func.apply(this, arguments);
+    this._super = orig;
+    return ret;
+  }
+  IS_WRAPPED_FUNCTION_SET.add(superWrapper);
+  let meta = OBSERVERS_LISTENERS_MAP.get(func);
+  if (meta !== undefined) {
+    OBSERVERS_LISTENERS_MAP.set(superWrapper, meta);
+  }
+  return superWrapper;
+}
+
+export { ROOT as R, setListeners as a, checkHasSuper as c, observerListenerMetaFor as o, setObservers as s, wrap as w };

package/dist/prod/packages/shared-chunks/syscall-ops-BPFtDquC.js

@@ -0,0 +1,133 @@
+const SIGN_BIT = -536870913;
+const MAX_INT = ~SIGN_BIT - 1;
+const MIN_INT = ~MAX_INT;
+function isHandle(value) {
+  return value >= 0;
+}
+function constants(...values) {
+  return [false, true, null, undefined, ...values];
+}
+function isSmallInt(value) {
+  return value % 1 === 0 && value <= MAX_INT && value >= MIN_INT;
+}
+function encodeNegative(num) {
+  return num & SIGN_BIT;
+}
+function decodeNegative(num) {
+  return num | ~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) {
+  num |= 0;
+  return num < 0 ? encodeNegative(num) : encodePositive(num);
+}
+function decodeImmediate(num) {
+  num |= 0;
+  return num > SIGN_BIT ? decodePositive(num) : decodeNegative(num);
+}
+[1, -1].forEach(x => decodeImmediate(encodeImmediate(x)));
+
+const VM_HELPER_OP = 16;
+const VM_SET_NAMED_VARIABLES_OP = 17;
+const VM_SET_BLOCKS_OP = 18;
+const VM_SET_VARIABLE_OP = 19;
+const VM_SET_BLOCK_OP = 20;
+const VM_GET_VARIABLE_OP = 21;
+const VM_GET_PROPERTY_OP = 22;
+const VM_GET_BLOCK_OP = 23;
+const VM_SPREAD_BLOCK_OP = 24;
+const VM_HAS_BLOCK_OP = 25;
+const VM_HAS_BLOCK_PARAMS_OP = 26;
+const VM_CONCAT_OP = 27;
+const VM_CONSTANT_OP = 28;
+const VM_CONSTANT_REFERENCE_OP = 29;
+const VM_PRIMITIVE_OP = 30;
+const VM_PRIMITIVE_REFERENCE_OP = 31;
+const VM_DUP_OP = 33;
+const VM_POP_OP = 34;
+const VM_LOAD_OP = 35;
+const VM_FETCH_OP = 36;
+const VM_ROOT_SCOPE_OP = 37;
+const VM_VIRTUAL_ROOT_SCOPE_OP = 38;
+const VM_CHILD_SCOPE_OP = 39;
+const VM_POP_SCOPE_OP = 40;
+const VM_TEXT_OP = 41;
+const VM_COMMENT_OP = 42;
+const VM_APPEND_HTML_OP = 43;
+const VM_APPEND_SAFE_HTML_OP = 44;
+const VM_APPEND_DOCUMENT_FRAGMENT_OP = 45;
+const VM_APPEND_NODE_OP = 46;
+const VM_APPEND_TEXT_OP = 47;
+const VM_OPEN_ELEMENT_OP = 48;
+const VM_OPEN_DYNAMIC_ELEMENT_OP = 49;
+const VM_PUSH_REMOTE_ELEMENT_OP = 50;
+const VM_STATIC_ATTR_OP = 51;
+const VM_DYNAMIC_ATTR_OP = 52;
+const VM_COMPONENT_ATTR_OP = 53;
+const VM_FLUSH_ELEMENT_OP = 54;
+const VM_CLOSE_ELEMENT_OP = 55;
+const VM_POP_REMOTE_ELEMENT_OP = 56;
+const VM_MODIFIER_OP = 57;
+const VM_BIND_DYNAMIC_SCOPE_OP = 58;
+const VM_PUSH_DYNAMIC_SCOPE_OP = 59;
+const VM_POP_DYNAMIC_SCOPE_OP = 60;
+const VM_COMPILE_BLOCK_OP = 61;
+const VM_PUSH_BLOCK_SCOPE_OP = 62;
+const VM_PUSH_SYMBOL_TABLE_OP = 63;
+const VM_INVOKE_YIELD_OP = 64;
+const VM_JUMP_IF_OP = 65;
+const VM_JUMP_UNLESS_OP = 66;
+const VM_JUMP_EQ_OP = 67;
+const VM_ASSERT_SAME_OP = 68;
+const VM_ENTER_OP = 69;
+const VM_EXIT_OP = 70;
+const VM_TO_BOOLEAN_OP = 71;
+const VM_ENTER_LIST_OP = 72;
+const VM_EXIT_LIST_OP = 73;
+const VM_ITERATE_OP = 74;
+const VM_MAIN_OP = 75;
+const VM_CONTENT_TYPE_OP = 76;
+const VM_CURRY_OP = 77;
+const VM_PUSH_COMPONENT_DEFINITION_OP = 78;
+const VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP = 79;
+const VM_RESOLVE_DYNAMIC_COMPONENT_OP = 80;
+const VM_RESOLVE_CURRIED_COMPONENT_OP = 81;
+const VM_PUSH_ARGS_OP = 82;
+const VM_PUSH_EMPTY_ARGS_OP = 83;
+const VM_PREPARE_ARGS_OP = 85;
+const VM_CAPTURE_ARGS_OP = 86;
+const VM_CREATE_COMPONENT_OP = 87;
+const VM_REGISTER_COMPONENT_DESTRUCTOR_OP = 88;
+const VM_PUT_COMPONENT_OPERATIONS_OP = 89;
+const VM_GET_COMPONENT_SELF_OP = 90;
+const VM_GET_COMPONENT_TAG_NAME_OP = 91;
+const VM_GET_COMPONENT_LAYOUT_OP = 92;
+const VM_POPULATE_LAYOUT_OP = 95;
+const VM_INVOKE_COMPONENT_LAYOUT_OP = 96;
+const VM_BEGIN_COMPONENT_TRANSACTION_OP = 97;
+const VM_COMMIT_COMPONENT_TRANSACTION_OP = 98;
+const VM_DID_CREATE_ELEMENT_OP = 99;
+const VM_DID_RENDER_LAYOUT_OP = 100;
+const VM_DEBUGGER_OP = 103;
+const VM_STATIC_COMPONENT_ATTR_OP = 105;
+const VM_DYNAMIC_CONTENT_TYPE_OP = 106;
+const VM_DYNAMIC_HELPER_OP = 107;
+const VM_DYNAMIC_MODIFIER_OP = 108;
+const VM_IF_INLINE_OP = 109;
+const VM_NOT_OP = 110;
+const VM_GET_DYNAMIC_VAR_OP = 111;
+const VM_LOG_OP = 112;
+const VM_SYSCALL_SIZE = 113;
+
+export { VM_CAPTURE_ARGS_OP as $, VM_ENTER_OP as A, VM_EXIT_OP as B, VM_PUSH_SYMBOL_TABLE_OP as C, VM_PUSH_BLOCK_SCOPE_OP as D, VM_COMPILE_BLOCK_OP as E, VM_INVOKE_YIELD_OP as F, VM_JUMP_IF_OP as G, VM_JUMP_UNLESS_OP as H, VM_JUMP_EQ_OP as I, VM_TO_BOOLEAN_OP as J, VM_TEXT_OP as K, VM_COMMENT_OP as L, VM_OPEN_ELEMENT_OP as M, VM_OPEN_DYNAMIC_ELEMENT_OP as N, VM_PUSH_REMOTE_ELEMENT_OP as O, VM_POP_REMOTE_ELEMENT_OP as P, VM_FLUSH_ELEMENT_OP as Q, VM_CLOSE_ELEMENT_OP as R, VM_MODIFIER_OP as S, VM_DYNAMIC_MODIFIER_OP as T, VM_STATIC_ATTR_OP as U, VM_MAIN_OP as V, VM_DYNAMIC_ATTR_OP as W, VM_PUSH_COMPONENT_DEFINITION_OP as X, VM_RESOLVE_DYNAMIC_COMPONENT_OP as Y, VM_PUSH_ARGS_OP as Z, VM_PUSH_EMPTY_ARGS_OP as _, VM_CONTENT_TYPE_OP as a, VM_PREPARE_ARGS_OP as a0, VM_CREATE_COMPONENT_OP as a1, VM_REGISTER_COMPONENT_DESTRUCTOR_OP as a2, VM_BEGIN_COMPONENT_TRANSACTION_OP as a3, VM_PUT_COMPONENT_OPERATIONS_OP as a4, VM_COMPONENT_ATTR_OP as a5, VM_STATIC_COMPONENT_ATTR_OP as a6, VM_DID_CREATE_ELEMENT_OP as a7, VM_GET_COMPONENT_SELF_OP as a8, VM_GET_COMPONENT_TAG_NAME_OP as a9, VM_DYNAMIC_CONTENT_TYPE_OP as aA, VM_ENTER_LIST_OP as aB, VM_EXIT_LIST_OP as aC, VM_ITERATE_OP as aD, constants as aE, encodeHandle as aF, isSmallInt as aG, encodeImmediate as aH, VM_GET_COMPONENT_LAYOUT_OP as aa, VM_POPULATE_LAYOUT_OP as ab, VM_VIRTUAL_ROOT_SCOPE_OP as ac, VM_SET_NAMED_VARIABLES_OP as ad, VM_SET_BLOCKS_OP as ae, VM_INVOKE_COMPONENT_LAYOUT_OP as af, VM_DID_RENDER_LAYOUT_OP as ag, VM_COMMIT_COMPONENT_TRANSACTION_OP as ah, VM_DEBUGGER_OP as ai, VM_CURRY_OP as aj, VM_DYNAMIC_HELPER_OP as ak, VM_HELPER_OP as al, VM_GET_VARIABLE_OP as am, VM_SET_VARIABLE_OP as an, VM_SET_BLOCK_OP as ao, VM_ROOT_SCOPE_OP as ap, VM_GET_PROPERTY_OP as aq, VM_GET_BLOCK_OP as ar, VM_SPREAD_BLOCK_OP as as, VM_HAS_BLOCK_OP as at, VM_HAS_BLOCK_PARAMS_OP as au, VM_CONCAT_OP as av, VM_IF_INLINE_OP as aw, VM_NOT_OP as ax, VM_GET_DYNAMIC_VAR_OP as ay, VM_LOG_OP as az, VM_ASSERT_SAME_OP as b, VM_APPEND_HTML_OP as c, VM_APPEND_TEXT_OP as d, VM_RESOLVE_CURRIED_COMPONENT_OP as e, VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP as f, VM_APPEND_SAFE_HTML_OP as g, VM_APPEND_DOCUMENT_FRAGMENT_OP as h, VM_APPEND_NODE_OP as i, VM_SYSCALL_SIZE as j, VM_CHILD_SCOPE_OP as k, VM_POP_SCOPE_OP as l, VM_PUSH_DYNAMIC_SCOPE_OP as m, VM_POP_DYNAMIC_SCOPE_OP as n, VM_CONSTANT_OP as o, decodeHandle as p, VM_CONSTANT_REFERENCE_OP as q, VM_PRIMITIVE_OP as r, isHandle as s, decodeImmediate as t, VM_PRIMITIVE_REFERENCE_OP as u, VM_DUP_OP as v, VM_POP_OP as w, VM_LOAD_OP as x, VM_FETCH_OP as y, VM_BIND_DYNAMIC_SCOPE_OP as z };

package/dist/prod/packages/shared-chunks/template-BRrQR6KS.js

@@ -0,0 +1,16 @@
+function unwrapHandle(handle) {
+  if (typeof handle === 'number') {
+    return handle;
+  } else {
+    let error = handle.errors[0];
+    throw new Error(`Compile Error: ${error.problem} @ ${error.span.start}..${error.span.end}`);
+  }
+}
+function unwrapTemplate(template) {
+  if (template.result === 'error') {
+    throw new Error(`Compile Error: ${template.problem} @ ${template.span.start}..${template.span.end}`);
+  }
+  return template;
+}
+
+export { unwrapHandle as a, unwrapTemplate as u };

package/dist/prod/packages/shared-chunks/template-only-BtLl0uH0.js

@@ -0,0 +1,78 @@
+import { s as setInternalComponentManager } from './api-zh_k31vb.js';
+import { N as NULL_REFERENCE } from './reference-BshxG6wn.js';
+
+const CAPABILITIES = {
+  dynamicLayout: false,
+  dynamicTag: false,
+  prepareArgs: false,
+  createArgs: false,
+  attributeHook: false,
+  elementHook: false,
+  createCaller: false,
+  dynamicScope: false,
+  updateHook: false,
+  createInstance: false,
+  wrapped: false,
+  willDestroy: false,
+  hasSubOwner: false
+};
+class TemplateOnlyComponentManager {
+  getCapabilities() {
+    return CAPABILITIES;
+  }
+  getDebugName({
+    name
+  }) {
+    return name;
+  }
+  getSelf() {
+    return NULL_REFERENCE;
+  }
+  getDestroyable() {
+    return null;
+  }
+}
+const TEMPLATE_ONLY_COMPONENT_MANAGER = new TemplateOnlyComponentManager();
+
+// This is only exported for types, don't use this class directly
+class TemplateOnlyComponentDefinition {
+  constructor(moduleName = '@glimmer/component/template-only', name = '(unknown template-only component)') {
+    this.moduleName = moduleName;
+    this.name = name;
+  }
+  toString() {
+    return this.moduleName;
+  }
+}
+setInternalComponentManager(TEMPLATE_ONLY_COMPONENT_MANAGER, TemplateOnlyComponentDefinition.prototype);
+
+/**
+  This utility function is used to declare a given component has no backing class. When the rendering engine detects this it
+  is able to perform a number of optimizations. Templates that are associated with `templateOnly()` will be rendered _as is_
+  without adding a wrapping `<div>` (or any of the other element customization behaviors of [@ember/component](/ember/release/classes/Component)).
+  Specifically, this means that the template will be rendered as "outer HTML".
+
+  In general, this method will be used by build time tooling and would not be directly written in an application. However,
+  at times it may be useful to use directly to leverage the "outer HTML" semantics mentioned above. For example, if an addon would like
+  to use these semantics for its templates but cannot be certain it will only be consumed by applications that have enabled the
+  `template-only-glimmer-components` optional feature.
+
+  @example
+
+  ```js
+  import { templateOnlyComponent } from '@glimmer/runtime';
+
+  export default templateOnlyComponent();
+  ```
+
+  @public
+  @method templateOnly
+  @param {String} moduleName the module name that the template only component represents, this will be used for debugging purposes
+  @category EMBER_GLIMMER_SET_COMPONENT_TEMPLATE
+*/
+
+function templateOnlyComponent(moduleName, name) {
+  return new TemplateOnlyComponentDefinition(moduleName, name);
+}
+
+export { TEMPLATE_ONLY_COMPONENT_MANAGER as T, TemplateOnlyComponentDefinition as a, TemplateOnlyComponentManager as b, templateOnlyComponent as t };