1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/testing/mochitest/MochiKit/Async.js Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,681 @@
1.4 +/***
1.5 +
1.6 +MochiKit.Async 1.4
1.7 +
1.8 +See <http://mochikit.com/> for documentation, downloads, license, etc.
1.9 +
1.10 +(c) 2005 Bob Ippolito. All rights Reserved.
1.11 +
1.12 +***/
1.13 +
1.14 +if (typeof(dojo) != 'undefined') {
1.15 + dojo.provide("MochiKit.Async");
1.16 + dojo.require("MochiKit.Base");
1.17 +}
1.18 +if (typeof(JSAN) != 'undefined') {
1.19 + JSAN.use("MochiKit.Base", []);
1.20 +}
1.21 +
1.22 +try {
1.23 + if (typeof(MochiKit.Base) == 'undefined') {
1.24 + throw "";
1.25 + }
1.26 +} catch (e) {
1.27 + throw "MochiKit.Async depends on MochiKit.Base!";
1.28 +}
1.29 +
1.30 +if (typeof(MochiKit.Async) == 'undefined') {
1.31 + MochiKit.Async = {};
1.32 +}
1.33 +
1.34 +MochiKit.Async.NAME = "MochiKit.Async";
1.35 +MochiKit.Async.VERSION = "1.4";
1.36 +MochiKit.Async.__repr__ = function () {
1.37 + return "[" + this.NAME + " " + this.VERSION + "]";
1.38 +};
1.39 +MochiKit.Async.toString = function () {
1.40 + return this.__repr__();
1.41 +};
1.42 +
1.43 +/** @id MochiKit.Async.Deferred */
1.44 +MochiKit.Async.Deferred = function (/* optional */ canceller) {
1.45 + this.chain = [];
1.46 + this.id = this._nextId();
1.47 + this.fired = -1;
1.48 + this.paused = 0;
1.49 + this.results = [null, null];
1.50 + this.canceller = canceller;
1.51 + this.silentlyCancelled = false;
1.52 + this.chained = false;
1.53 +};
1.54 +
1.55 +MochiKit.Async.Deferred.prototype = {
1.56 + /** @id MochiKit.Async.Deferred.prototype.repr */
1.57 + repr: function () {
1.58 + var state;
1.59 + if (this.fired == -1) {
1.60 + state = 'unfired';
1.61 + } else if (this.fired === 0) {
1.62 + state = 'success';
1.63 + } else {
1.64 + state = 'error';
1.65 + }
1.66 + return 'Deferred(' + this.id + ', ' + state + ')';
1.67 + },
1.68 +
1.69 + toString: MochiKit.Base.forwardCall("repr"),
1.70 +
1.71 + _nextId: MochiKit.Base.counter(),
1.72 +
1.73 + /** @id MochiKit.Async.Deferred.prototype.cancel */
1.74 + cancel: function () {
1.75 + var self = MochiKit.Async;
1.76 + if (this.fired == -1) {
1.77 + if (this.canceller) {
1.78 + this.canceller(this);
1.79 + } else {
1.80 + this.silentlyCancelled = true;
1.81 + }
1.82 + if (this.fired == -1) {
1.83 + this.errback(new self.CancelledError(this));
1.84 + }
1.85 + } else if ((this.fired === 0) && (this.results[0] instanceof self.Deferred)) {
1.86 + this.results[0].cancel();
1.87 + }
1.88 + },
1.89 +
1.90 + _resback: function (res) {
1.91 + /***
1.92 +
1.93 + The primitive that means either callback or errback
1.94 +
1.95 + ***/
1.96 + this.fired = ((res instanceof Error) ? 1 : 0);
1.97 + this.results[this.fired] = res;
1.98 + this._fire();
1.99 + },
1.100 +
1.101 + _check: function () {
1.102 + if (this.fired != -1) {
1.103 + if (!this.silentlyCancelled) {
1.104 + throw new MochiKit.Async.AlreadyCalledError(this);
1.105 + }
1.106 + this.silentlyCancelled = false;
1.107 + return;
1.108 + }
1.109 + },
1.110 +
1.111 + /** @id MochiKit.Async.Deferred.prototype.callback */
1.112 + callback: function (res) {
1.113 + this._check();
1.114 + if (res instanceof MochiKit.Async.Deferred) {
1.115 + throw new Error("Deferred instances can only be chained if they are the result of a callback");
1.116 + }
1.117 + this._resback(res);
1.118 + },
1.119 +
1.120 + /** @id MochiKit.Async.Deferred.prototype.errback */
1.121 + errback: function (res) {
1.122 + this._check();
1.123 + var self = MochiKit.Async;
1.124 + if (res instanceof self.Deferred) {
1.125 + throw new Error("Deferred instances can only be chained if they are the result of a callback");
1.126 + }
1.127 + if (!(res instanceof Error)) {
1.128 + res = new self.GenericError(res);
1.129 + }
1.130 + this._resback(res);
1.131 + },
1.132 +
1.133 + /** @id MochiKit.Async.Deferred.prototype.addBoth */
1.134 + addBoth: function (fn) {
1.135 + if (arguments.length > 1) {
1.136 + fn = MochiKit.Base.partial.apply(null, arguments);
1.137 + }
1.138 + return this.addCallbacks(fn, fn);
1.139 + },
1.140 +
1.141 + /** @id MochiKit.Async.Deferred.prototype.addCallback */
1.142 + addCallback: function (fn) {
1.143 + if (arguments.length > 1) {
1.144 + fn = MochiKit.Base.partial.apply(null, arguments);
1.145 + }
1.146 + return this.addCallbacks(fn, null);
1.147 + },
1.148 +
1.149 + /** @id MochiKit.Async.Deferred.prototype.addErrback */
1.150 + addErrback: function (fn) {
1.151 + if (arguments.length > 1) {
1.152 + fn = MochiKit.Base.partial.apply(null, arguments);
1.153 + }
1.154 + return this.addCallbacks(null, fn);
1.155 + },
1.156 +
1.157 + /** @id MochiKit.Async.Deferred.prototype.addCallbacks */
1.158 + addCallbacks: function (cb, eb) {
1.159 + if (this.chained) {
1.160 + throw new Error("Chained Deferreds can not be re-used");
1.161 + }
1.162 + this.chain.push([cb, eb]);
1.163 + if (this.fired >= 0) {
1.164 + this._fire();
1.165 + }
1.166 + return this;
1.167 + },
1.168 +
1.169 + _fire: function () {
1.170 + /***
1.171 +
1.172 + Used internally to exhaust the callback sequence when a result
1.173 + is available.
1.174 +
1.175 + ***/
1.176 + var chain = this.chain;
1.177 + var fired = this.fired;
1.178 + var res = this.results[fired];
1.179 + var self = this;
1.180 + var cb = null;
1.181 + while (chain.length > 0 && this.paused === 0) {
1.182 + // Array
1.183 + var pair = chain.shift();
1.184 + var f = pair[fired];
1.185 + if (f === null) {
1.186 + continue;
1.187 + }
1.188 + try {
1.189 + res = f(res);
1.190 + fired = ((res instanceof Error) ? 1 : 0);
1.191 + if (res instanceof MochiKit.Async.Deferred) {
1.192 + cb = function (res) {
1.193 + self._resback(res);
1.194 + self.paused--;
1.195 + if ((self.paused === 0) && (self.fired >= 0)) {
1.196 + self._fire();
1.197 + }
1.198 + };
1.199 + this.paused++;
1.200 + }
1.201 + } catch (err) {
1.202 + fired = 1;
1.203 + if (!(err instanceof Error)) {
1.204 + err = new MochiKit.Async.GenericError(err);
1.205 + }
1.206 + res = err;
1.207 + }
1.208 + }
1.209 + this.fired = fired;
1.210 + this.results[fired] = res;
1.211 + if (cb && this.paused) {
1.212 + // this is for "tail recursion" in case the dependent deferred
1.213 + // is already fired
1.214 + res.addBoth(cb);
1.215 + res.chained = true;
1.216 + }
1.217 + }
1.218 +};
1.219 +
1.220 +MochiKit.Base.update(MochiKit.Async, {
1.221 + /** @id MochiKit.Async.evalJSONRequest */
1.222 + evalJSONRequest: function (/* req */) {
1.223 + return eval('(' + arguments[0].responseText + ')');
1.224 + },
1.225 +
1.226 + /** @id MochiKit.Async.succeed */
1.227 + succeed: function (/* optional */result) {
1.228 + var d = new MochiKit.Async.Deferred();
1.229 + d.callback.apply(d, arguments);
1.230 + return d;
1.231 + },
1.232 +
1.233 + /** @id MochiKit.Async.fail */
1.234 + fail: function (/* optional */result) {
1.235 + var d = new MochiKit.Async.Deferred();
1.236 + d.errback.apply(d, arguments);
1.237 + return d;
1.238 + },
1.239 +
1.240 + /** @id MochiKit.Async.getXMLHttpRequest */
1.241 + getXMLHttpRequest: function () {
1.242 + var self = arguments.callee;
1.243 + if (!self.XMLHttpRequest) {
1.244 + var tryThese = [
1.245 + function () { return new XMLHttpRequest(); },
1.246 + function () { return new ActiveXObject('Msxml2.XMLHTTP'); },
1.247 + function () { return new ActiveXObject('Microsoft.XMLHTTP'); },
1.248 + function () { return new ActiveXObject('Msxml2.XMLHTTP.4.0'); },
1.249 + function () {
1.250 + throw new MochiKit.Async.BrowserComplianceError("Browser does not support XMLHttpRequest");
1.251 + }
1.252 + ];
1.253 + for (var i = 0; i < tryThese.length; i++) {
1.254 + var func = tryThese[i];
1.255 + try {
1.256 + self.XMLHttpRequest = func;
1.257 + return func();
1.258 + } catch (e) {
1.259 + // pass
1.260 + }
1.261 + }
1.262 + }
1.263 + return self.XMLHttpRequest();
1.264 + },
1.265 +
1.266 + _xhr_onreadystatechange: function (d) {
1.267 + // MochiKit.Logging.logDebug('this.readyState', this.readyState);
1.268 + var m = MochiKit.Base;
1.269 + if (this.readyState == 4) {
1.270 + // IE SUCKS
1.271 + try {
1.272 + this.onreadystatechange = null;
1.273 + } catch (e) {
1.274 + try {
1.275 + this.onreadystatechange = m.noop;
1.276 + } catch (e) {
1.277 + }
1.278 + }
1.279 + var status = null;
1.280 + try {
1.281 + status = this.status;
1.282 + if (!status && m.isNotEmpty(this.responseText)) {
1.283 + // 0 or undefined seems to mean cached or local
1.284 + status = 304;
1.285 + }
1.286 + } catch (e) {
1.287 + // pass
1.288 + // MochiKit.Logging.logDebug('error getting status?', repr(items(e)));
1.289 + }
1.290 + // 200 is OK, 304 is NOT_MODIFIED
1.291 + if (status == 200 || status == 304) { // OK
1.292 + d.callback(this);
1.293 + } else {
1.294 + var err = new MochiKit.Async.XMLHttpRequestError(this, "Request failed");
1.295 + if (err.number) {
1.296 + // XXX: This seems to happen on page change
1.297 + d.errback(err);
1.298 + } else {
1.299 + // XXX: this seems to happen when the server is unreachable
1.300 + d.errback(err);
1.301 + }
1.302 + }
1.303 + }
1.304 + },
1.305 +
1.306 + _xhr_canceller: function (req) {
1.307 + // IE SUCKS
1.308 + try {
1.309 + req.onreadystatechange = null;
1.310 + } catch (e) {
1.311 + try {
1.312 + req.onreadystatechange = MochiKit.Base.noop;
1.313 + } catch (e) {
1.314 + }
1.315 + }
1.316 + req.abort();
1.317 + },
1.318 +
1.319 +
1.320 + /** @id MochiKit.Async.sendXMLHttpRequest */
1.321 + sendXMLHttpRequest: function (req, /* optional */ sendContent) {
1.322 + if (typeof(sendContent) == "undefined" || sendContent === null) {
1.323 + sendContent = "";
1.324 + }
1.325 +
1.326 + var m = MochiKit.Base;
1.327 + var self = MochiKit.Async;
1.328 + var d = new self.Deferred(m.partial(self._xhr_canceller, req));
1.329 +
1.330 + try {
1.331 + req.onreadystatechange = m.bind(self._xhr_onreadystatechange,
1.332 + req, d);
1.333 + req.send(sendContent);
1.334 + } catch (e) {
1.335 + try {
1.336 + req.onreadystatechange = null;
1.337 + } catch (ignore) {
1.338 + // pass
1.339 + }
1.340 + d.errback(e);
1.341 + }
1.342 +
1.343 + return d;
1.344 +
1.345 + },
1.346 +
1.347 + /** @id MochiKit.Async.doXHR */
1.348 + doXHR: function (url, opts) {
1.349 + var m = MochiKit.Base;
1.350 + opts = m.update({
1.351 + method: 'GET',
1.352 + sendContent: ''
1.353 + /*
1.354 + queryString: undefined,
1.355 + username: undefined,
1.356 + password: undefined,
1.357 + headers: undefined,
1.358 + mimeType: undefined
1.359 + */
1.360 + }, opts);
1.361 + var self = MochiKit.Async;
1.362 + var req = self.getXMLHttpRequest();
1.363 + if (opts.queryString) {
1.364 + var qs = m.queryString(opts.queryString);
1.365 + if (qs) {
1.366 + url += "?" + qs;
1.367 + }
1.368 + }
1.369 + req.open(opts.method, url, true, opts.username, opts.password);
1.370 + if (req.overrideMimeType && opts.mimeType) {
1.371 + req.overrideMimeType(opts.mimeType);
1.372 + }
1.373 + if (opts.headers) {
1.374 + var headers = opts.headers;
1.375 + if (!m.isArrayLike(headers)) {
1.376 + headers = m.items(headers);
1.377 + }
1.378 + for (var i = 0; i < headers.length; i++) {
1.379 + var header = headers[i];
1.380 + var name = header[0];
1.381 + var value = header[1];
1.382 + req.setRequestHeader(name, value);
1.383 + }
1.384 + }
1.385 + return self.sendXMLHttpRequest(req, opts.sendContent);
1.386 + },
1.387 +
1.388 + _buildURL: function (url/*, ...*/) {
1.389 + if (arguments.length > 1) {
1.390 + var m = MochiKit.Base;
1.391 + var qs = m.queryString.apply(null, m.extend(null, arguments, 1));
1.392 + if (qs) {
1.393 + return url + "?" + qs;
1.394 + }
1.395 + }
1.396 + return url;
1.397 + },
1.398 +
1.399 + /** @id MochiKit.Async.doSimpleXMLHttpRequest */
1.400 + doSimpleXMLHttpRequest: function (url/*, ...*/) {
1.401 + var self = MochiKit.Async;
1.402 + url = self._buildURL.apply(self, arguments);
1.403 + return self.doXHR(url);
1.404 + },
1.405 +
1.406 + /** @id MochiKit.Async.loadJSONDoc */
1.407 + loadJSONDoc: function (url/*, ...*/) {
1.408 + var self = MochiKit.Async;
1.409 + url = self._buildURL.apply(self, arguments);
1.410 + var d = self.doXHR(url, {
1.411 + 'mimeType': 'text/plain',
1.412 + 'headers': [['Accept', 'application/json']]
1.413 + });
1.414 + d = d.addCallback(self.evalJSONRequest);
1.415 + return d;
1.416 + },
1.417 +
1.418 + /** @id MochiKit.Async.wait */
1.419 + wait: function (seconds, /* optional */value) {
1.420 + var d = new MochiKit.Async.Deferred();
1.421 + var m = MochiKit.Base;
1.422 + if (typeof(value) != 'undefined') {
1.423 + d.addCallback(function () { return value; });
1.424 + }
1.425 + var timeout = setTimeout(
1.426 + m.bind("callback", d),
1.427 + Math.floor(seconds * 1000));
1.428 + d.canceller = function () {
1.429 + try {
1.430 + clearTimeout(timeout);
1.431 + } catch (e) {
1.432 + // pass
1.433 + }
1.434 + };
1.435 + return d;
1.436 + },
1.437 +
1.438 + /** @id MochiKit.Async.callLater */
1.439 + callLater: function (seconds, func) {
1.440 + var m = MochiKit.Base;
1.441 + var pfunc = m.partial.apply(m, m.extend(null, arguments, 1));
1.442 + return MochiKit.Async.wait(seconds).addCallback(
1.443 + function (res) { return pfunc(); }
1.444 + );
1.445 + }
1.446 +});
1.447 +
1.448 +
1.449 +/** @id MochiKit.Async.DeferredLock */
1.450 +MochiKit.Async.DeferredLock = function () {
1.451 + this.waiting = [];
1.452 + this.locked = false;
1.453 + this.id = this._nextId();
1.454 +};
1.455 +
1.456 +MochiKit.Async.DeferredLock.prototype = {
1.457 + __class__: MochiKit.Async.DeferredLock,
1.458 + /** @id MochiKit.Async.DeferredLock.prototype.acquire */
1.459 + acquire: function () {
1.460 + var d = new MochiKit.Async.Deferred();
1.461 + if (this.locked) {
1.462 + this.waiting.push(d);
1.463 + } else {
1.464 + this.locked = true;
1.465 + d.callback(this);
1.466 + }
1.467 + return d;
1.468 + },
1.469 + /** @id MochiKit.Async.DeferredLock.prototype.release */
1.470 + release: function () {
1.471 + if (!this.locked) {
1.472 + throw TypeError("Tried to release an unlocked DeferredLock");
1.473 + }
1.474 + this.locked = false;
1.475 + if (this.waiting.length > 0) {
1.476 + this.locked = true;
1.477 + this.waiting.shift().callback(this);
1.478 + }
1.479 + },
1.480 + _nextId: MochiKit.Base.counter(),
1.481 + repr: function () {
1.482 + var state;
1.483 + if (this.locked) {
1.484 + state = 'locked, ' + this.waiting.length + ' waiting';
1.485 + } else {
1.486 + state = 'unlocked';
1.487 + }
1.488 + return 'DeferredLock(' + this.id + ', ' + state + ')';
1.489 + },
1.490 + toString: MochiKit.Base.forwardCall("repr")
1.491 +
1.492 +};
1.493 +
1.494 +/** @id MochiKit.Async.DeferredList */
1.495 +MochiKit.Async.DeferredList = function (list, /* optional */fireOnOneCallback, fireOnOneErrback, consumeErrors, canceller) {
1.496 +
1.497 + // call parent constructor
1.498 + MochiKit.Async.Deferred.apply(this, [canceller]);
1.499 +
1.500 + this.list = list;
1.501 + var resultList = [];
1.502 + this.resultList = resultList;
1.503 +
1.504 + this.finishedCount = 0;
1.505 + this.fireOnOneCallback = fireOnOneCallback;
1.506 + this.fireOnOneErrback = fireOnOneErrback;
1.507 + this.consumeErrors = consumeErrors;
1.508 +
1.509 + var cb = MochiKit.Base.bind(this._cbDeferred, this);
1.510 + for (var i = 0; i < list.length; i++) {
1.511 + var d = list[i];
1.512 + resultList.push(undefined);
1.513 + d.addCallback(cb, i, true);
1.514 + d.addErrback(cb, i, false);
1.515 + }
1.516 +
1.517 + if (list.length === 0 && !fireOnOneCallback) {
1.518 + this.callback(this.resultList);
1.519 + }
1.520 +
1.521 +};
1.522 +
1.523 +MochiKit.Async.DeferredList.prototype = new MochiKit.Async.Deferred();
1.524 +
1.525 +MochiKit.Async.DeferredList.prototype._cbDeferred = function (index, succeeded, result) {
1.526 + this.resultList[index] = [succeeded, result];
1.527 + this.finishedCount += 1;
1.528 + if (this.fired == -1) {
1.529 + if (succeeded && this.fireOnOneCallback) {
1.530 + this.callback([index, result]);
1.531 + } else if (!succeeded && this.fireOnOneErrback) {
1.532 + this.errback(result);
1.533 + } else if (this.finishedCount == this.list.length) {
1.534 + this.callback(this.resultList);
1.535 + }
1.536 + }
1.537 + if (!succeeded && this.consumeErrors) {
1.538 + result = null;
1.539 + }
1.540 + return result;
1.541 +};
1.542 +
1.543 +/** @id MochiKit.Async.gatherResults */
1.544 +MochiKit.Async.gatherResults = function (deferredList) {
1.545 + var d = new MochiKit.Async.DeferredList(deferredList, false, true, false);
1.546 + d.addCallback(function (results) {
1.547 + var ret = [];
1.548 + for (var i = 0; i < results.length; i++) {
1.549 + ret.push(results[i][1]);
1.550 + }
1.551 + return ret;
1.552 + });
1.553 + return d;
1.554 +};
1.555 +
1.556 +/** @id MochiKit.Async.maybeDeferred */
1.557 +MochiKit.Async.maybeDeferred = function (func) {
1.558 + var self = MochiKit.Async;
1.559 + var result;
1.560 + try {
1.561 + var r = func.apply(null, MochiKit.Base.extend([], arguments, 1));
1.562 + if (r instanceof self.Deferred) {
1.563 + result = r;
1.564 + } else if (r instanceof Error) {
1.565 + result = self.fail(r);
1.566 + } else {
1.567 + result = self.succeed(r);
1.568 + }
1.569 + } catch (e) {
1.570 + result = self.fail(e);
1.571 + }
1.572 + return result;
1.573 +};
1.574 +
1.575 +
1.576 +MochiKit.Async.EXPORT = [
1.577 + "AlreadyCalledError",
1.578 + "CancelledError",
1.579 + "BrowserComplianceError",
1.580 + "GenericError",
1.581 + "XMLHttpRequestError",
1.582 + "Deferred",
1.583 + "succeed",
1.584 + "fail",
1.585 + "getXMLHttpRequest",
1.586 + "doSimpleXMLHttpRequest",
1.587 + "loadJSONDoc",
1.588 + "wait",
1.589 + "callLater",
1.590 + "sendXMLHttpRequest",
1.591 + "DeferredLock",
1.592 + "DeferredList",
1.593 + "gatherResults",
1.594 + "maybeDeferred",
1.595 + "doXHR"
1.596 +];
1.597 +
1.598 +MochiKit.Async.EXPORT_OK = [
1.599 + "evalJSONRequest"
1.600 +];
1.601 +
1.602 +MochiKit.Async.__new__ = function () {
1.603 + var m = MochiKit.Base;
1.604 + var ne = m.partial(m._newNamedError, this);
1.605 +
1.606 + ne("AlreadyCalledError",
1.607 + /** @id MochiKit.Async.AlreadyCalledError */
1.608 + function (deferred) {
1.609 + /***
1.610 +
1.611 + Raised by the Deferred if callback or errback happens
1.612 + after it was already fired.
1.613 +
1.614 + ***/
1.615 + this.deferred = deferred;
1.616 + }
1.617 + );
1.618 +
1.619 + ne("CancelledError",
1.620 + /** @id MochiKit.Async.CancelledError */
1.621 + function (deferred) {
1.622 + /***
1.623 +
1.624 + Raised by the Deferred cancellation mechanism.
1.625 +
1.626 + ***/
1.627 + this.deferred = deferred;
1.628 + }
1.629 + );
1.630 +
1.631 + ne("BrowserComplianceError",
1.632 + /** @id MochiKit.Async.BrowserComplianceError */
1.633 + function (msg) {
1.634 + /***
1.635 +
1.636 + Raised when the JavaScript runtime is not capable of performing
1.637 + the given function. Technically, this should really never be
1.638 + raised because a non-conforming JavaScript runtime probably
1.639 + isn't going to support exceptions in the first place.
1.640 +
1.641 + ***/
1.642 + this.message = msg;
1.643 + }
1.644 + );
1.645 +
1.646 + ne("GenericError",
1.647 + /** @id MochiKit.Async.GenericError */
1.648 + function (msg) {
1.649 + this.message = msg;
1.650 + }
1.651 + );
1.652 +
1.653 + ne("XMLHttpRequestError",
1.654 + /** @id MochiKit.Async.XMLHttpRequestError */
1.655 + function (req, msg) {
1.656 + /***
1.657 +
1.658 + Raised when an XMLHttpRequest does not complete for any reason.
1.659 +
1.660 + ***/
1.661 + this.req = req;
1.662 + this.message = msg;
1.663 + try {
1.664 + // Strange but true that this can raise in some cases.
1.665 + this.number = req.status;
1.666 + } catch (e) {
1.667 + // pass
1.668 + }
1.669 + }
1.670 + );
1.671 +
1.672 +
1.673 + this.EXPORT_TAGS = {
1.674 + ":common": this.EXPORT,
1.675 + ":all": m.concat(this.EXPORT, this.EXPORT_OK)
1.676 + };
1.677 +
1.678 + m.nameFunctions(this);
1.679 +
1.680 +};
1.681 +
1.682 +MochiKit.Async.__new__();
1.683 +
1.684 +MochiKit.Base._exportSymbols(this, MochiKit.Async);
