https://ember-container-query.netlify.app/@embroider/virtual/vendor.js

1window.EmberENV={ ...(window.EmberENV || {}), ...{
2  "EXTEND_PROTOTYPES": false,
3  "FEATURES": {},
4  "_APPLICATION_TEMPLATE_WRAPPER": false,
5  "_DEFAULT_ASYNC_OBSERVERS": true,
6  "_JQUERY_INTEGRATION": false,
7  "_NO_IMPLICIT_ROUTE_MODEL": true,
8  "_TEMPLATE_ONLY_GLIMMER_COMPONENTS": true
9} };var runningTests=false;var loader, define, requireModule, require, requirejs;
10
11(function (global) {
12  'use strict';
13
14  function dict() {
15    var obj = Object.create(null);
16    obj['__'] = undefined;
17    delete obj['__'];
18    return obj;
19  }
20
21  // Save off the original values of these globals, so we can restore them if someone asks us to
22  var oldGlobals = {
23    loader: loader,
24    define: define,
25    requireModule: requireModule,
26    require: require,
27    requirejs: requirejs
28  };
29
30  requirejs = require = requireModule = function (id) {
31    var pending = [];
32    var mod = findModule(id, '(require)', pending);
33
34    for (var i = pending.length - 1; i >= 0; i--) {
35      pending[i].exports();
36    }
37
38    return mod.module.exports;
39  };
40
41  loader = {
42    noConflict: function (aliases) {
43      var oldName, newName;
44
45      for (oldName in aliases) {
46        if (aliases.hasOwnProperty(oldName)) {
47          if (oldGlobals.hasOwnProperty(oldName)) {
48            newName = aliases[oldName];
49
50            global[newName] = global[oldName];
51            global[oldName] = oldGlobals[oldName];
52          }
53        }
54      }
55    },
56    // Option to enable or disable the generation of default exports
57    makeDefaultExport: true
58  };
59
60  var registry = dict();
61  var seen = dict();
62
63  var uuid = 0;
64
65  function unsupportedModule(length) {
66    throw new Error('an unsupported module was defined, expected `define(id, deps, module)` instead got: `' + length + '` arguments to define`');
67  }
68
69  var defaultDeps = ['require', 'exports', 'module'];
70
71  function Module(id, deps, callback, alias) {
72    this.uuid = uuid++;
73    this.id = id;
74    this.deps = !deps.length && callback.length ? defaultDeps : deps;
75    this.module = { exports: {} };
76    this.callback = callback;
77    this.hasExportsAsDep = false;
78    this.isAlias = alias;
79    this.reified = new Array(deps.length);
80
81    /*
82       Each module normally passes through these states, in order:
83         new       : initial state
84         pending   : this module is scheduled to be executed
85         reifying  : this module's dependencies are being executed
86         reified   : this module's dependencies finished executing successfully
87         errored   : this module's dependencies failed to execute
88         finalized : this module executed successfully
89     */
90    this.state = 'new';
91  }
92
93  Module.prototype.makeDefaultExport = function () {
94    var exports = this.module.exports;
95    if (exports !== null && (typeof exports === 'object' || typeof exports === 'function') && exports['default'] === undefined && Object.isExtensible(exports)) {
96      exports['default'] = exports;
97    }
98  };
99
100  Module.prototype.exports = function () {
101    // if finalized, there is no work to do. If reifying, there is a
102    // circular dependency so we must return our (partial) exports.
103    if (this.state === 'finalized' || this.state === 'reifying') {
104      return this.module.exports;
105    }
106
107
108    if (loader.wrapModules) {
109      this.callback = loader.wrapModules(this.id, this.callback);
110    }
111
112    this.reify();
113
114    var result = this.callback.apply(this, this.reified);
115    this.reified.length = 0;
116    this.state = 'finalized';
117
118    if (!(this.hasExportsAsDep && result === undefined)) {
119      this.module.exports = result;
120    }
121    if (loader.makeDefaultExport) {
122      this.makeDefaultExport();
123    }
124    return this.module.exports;
125  };
126
127  Module.prototype.unsee = function () {
128    this.state = 'new';
129    this.module = { exports: {} };
130  };
131
132  Module.prototype.reify = function () {
133    if (this.state === 'reified') {
134      return;
135    }
136    this.state = 'reifying';
137    try {
138      this.reified = this._reify();
139      this.state = 'reified';
140    } finally {
141      if (this.state === 'reifying') {
142        this.state = 'errored';
143      }
144    }
145  };
146
147  Module.prototype._reify = function () {
148    var reified = this.reified.slice();
149    for (var i = 0; i < reified.length; i++) {
150      var mod = reified[i];
151      reified[i] = mod.exports ? mod.exports : mod.module.exports();
152    }
153    return reified;
154  };
155
156  Module.prototype.findDeps = function (pending) {
157    if (this.state !== 'new') {
158      return;
159    }
160

161    this.state = 'pending';
162
163    var deps = this.deps;
164
165    for (var i = 0; i < deps.length; i++) {
166      var dep = deps[i];
167      var entry = this.reified[i] = { exports: undefined, module: undefined };
168      if (dep === 'exports') {
169        this.hasExportsAsDep = true;
170        entry.exports = this.module.exports;
171      } else if (dep === 'require') {
172        entry.exports = this.makeRequire();
173      } else if (dep === 'module') {
174        entry.exports = this.module;
175      } else {
176        entry.module = findModule(resolve(dep, this.id), this.id, pending);
177      }
178    }
179  };
180
181  Module.prototype.makeRequire = function () {
182    var id = this.id;
183    var r = function (dep) {
184      return require(resolve(dep, id));
185    };
186    r['default'] = r;
187    r.moduleId = id;
188    r.has = function (dep) {
189      return has(resolve(dep, id));
190    };
191    return r;
192  };
193
194  define = function (id, deps, callback) {
195    var module = registry[id];
196
197    // If a module for this id has already been defined and is in any state
198    // other than `new` (meaning it has been or is currently being required),
199    // then we return early to avoid redefinition.
200    if (module && module.state !== 'new') {
201      return;
202    }
203
204    if (arguments.length < 2) {
205      unsupportedModule(arguments.length);
206    }
207
208    if (!Array.isArray(deps)) {
209      callback = deps;
210      deps = [];
211    }
212
213    if (callback instanceof Alias) {
214      registry[id] = new Module(callback.id, deps, callback, true);
215    } else {
216      registry[id] = new Module(id, deps, callback, false);
217    }
218  };
219
220  define.exports = function (name, defaultExport) {
221    var module = registry[name];
222
223    // If a module for this name has already been defined and is in any state
224    // other than `new` (meaning it has been or is currently being required),
225    // then we return early to avoid redefinition.
226    if (module && module.state !== 'new') {
227      return;
228    }
229
230    module = new Module(name, [], noop, null);
231    module.module.exports = defaultExport;
232    module.state = 'finalized';
233    registry[name] = module;
234
235    return module;
236  };
237
238  function noop() {}
239  // we don't support all of AMD
240  // define.amd = {};
241
242  function Alias(id) {
243    this.id = id;
244  }
245
246  define.alias = function (id, target) {
247    if (arguments.length === 2) {
248      return define(target, new Alias(id));
249    }
250
251    return new Alias(id);
252  };
253
254  function missingModule(id, referrer) {
255    throw new Error('Could not find module `' + id + '` imported from `' + referrer + '`');
256  }
257
258  function findModule(id, referrer, pending) {
259    var mod = registry[id] || registry[id + '/index'];
260
261    while (mod && mod.isAlias) {
262      mod = registry[mod.id] || registry[mod.id + '/index'];
263    }
264
265    if (!mod) {
266      missingModule(id, referrer);
267    }
268
269    if (pending && mod.state !== 'pending' && mod.state !== 'finalized') {
270      mod.findDeps(pending);
271      pending.push(mod);
272    }
273    return mod;
274  }
275
276  function resolve(child, id) {
277    if (child.charAt(0) !== '.') {
278      return child;
279    }
280
281
282    var parts = child.split('/');
283    var nameParts = id.split('/');
284    var parentBase = nameParts.slice(0, -1);
285
286    for (var i = 0, l = parts.length; i < l; i++) {
287      var part = parts[i];
288
289      if (part === '..') {
290        if (parentBase.length === 0) {
291          throw new Error('Cannot access parent module of root');
292        }
293        parentBase.pop();
294      } else if (part === '.') {
295        continue;
296      } else {
297        parentBase.push(part);
298      }
299    }
300
301    return parentBase.join('/');
302  }
303
304  function has(id) {
305    return !!(registry[id] || registry[id + '/index']);
306  }
307
308  requirejs.entries = requirejs._eak_seen = registry;
309  requirejs.has = has;
310  requirejs.unsee = function (id) {
311    findModule(id, '(unsee)', false).unsee();
312  };
313
314  requirejs.clear = function () {
315    requirejs.entries = requirejs._eak_seen = registry = dict();
316    seen = dict();
317  };
318
319  // This code primes the JS engine for good performance by warming the
320  // JIT compiler for these functions.
321  define('foo', function () {});
322  define('foo/bar', [], function () {});
323  define('foo/asdf', ['module', 'exports', 'require'], function (module, exports, require) {
324    if (require.has('foo/bar')) {
325      require('foo/bar');
326    }
327  });
328  define('foo/baz', [], define.alias('foo'));
329  define('foo/quz', define.alias('foo'));
330  define.alias('foo', 'foo/qux');
331  define('foo/bar', ['foo', './quz', './baz', './asdf', './bar', '../foo'], function () {});
332  define('foo/main', ['foo/bar'], function () {});
333  define.exports('foo/exports', {});
334
335  require('foo/exports');
336  require('foo/main');
337  require.unsee('foo/bar');
338
339  requirejs.clear();
340
341  if (typeof exports === 'object' && typeof module === 'object' && module.exports) {
342    module.exports = { require: require, define: define };
343  }
344})(this);