claude-flow-novice 2.2.3 → 2.2.4

package/dist/src/web/frontend/node_modules/.rxjs-i8W7PyKW/dist/cjs/internal/Observable.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Observable = void 0;
+var Subscriber_1 = require("./Subscriber");
+var Subscription_1 = require("./Subscription");
+var observable_1 = require("./symbol/observable");
+var pipe_1 = require("./util/pipe");
+var config_1 = require("./config");
+var isFunction_1 = require("./util/isFunction");
+var errorContext_1 = require("./util/errorContext");
+var Observable = (function () {
+    function Observable(subscribe) {
+        if (subscribe) {
+            this._subscribe = subscribe;
+        }
+    }
+    Observable.prototype.lift = function (operator) {
+        var observable = new Observable();
+        observable.source = this;
+        observable.operator = operator;
+        return observable;
+    };
+    Observable.prototype.subscribe = function (observerOrNext, error, complete) {
+        var _this = this;
+        var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new Subscriber_1.SafeSubscriber(observerOrNext, error, complete);
+        errorContext_1.errorContext(function () {
+            var _a = _this, operator = _a.operator, source = _a.source;
+            subscriber.add(operator
+                ?
+                    operator.call(subscriber, source)
+                : source
+                    ?
+                        _this._subscribe(subscriber)
+                    :
+                        _this._trySubscribe(subscriber));
+        });
+        return subscriber;
+    };
+    Observable.prototype._trySubscribe = function (sink) {
+        try {
+            return this._subscribe(sink);
+        }
+        catch (err) {
+            sink.error(err);
+        }
+    };
+    Observable.prototype.forEach = function (next, promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function (resolve, reject) {
+            var subscriber = new Subscriber_1.SafeSubscriber({
+                next: function (value) {
+                    try {
+                        next(value);
+                    }
+                    catch (err) {
+                        reject(err);
+                        subscriber.unsubscribe();
+                    }
+                },
+                error: reject,
+                complete: resolve,
+            });
+            _this.subscribe(subscriber);
+        });
+    };
+    Observable.prototype._subscribe = function (subscriber) {
+        var _a;
+        return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+    };
+    Observable.prototype[observable_1.observable] = function () {
+        return this;
+    };
+    Observable.prototype.pipe = function () {
+        var operations = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            operations[_i] = arguments[_i];
+        }
+        return pipe_1.pipeFromArray(operations)(this);
+    };
+    Observable.prototype.toPromise = function (promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function (resolve, reject) {
+            var value;
+            _this.subscribe(function (x) { return (value = x); }, function (err) { return reject(err); }, function () { return resolve(value); });
+        });
+    };
+    Observable.create = function (subscribe) {
+        return new Observable(subscribe);
+    };
+    return Observable;
+}());
+exports.Observable = Observable;
+function getPromiseCtor(promiseCtor) {
+    var _a;
+    return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config_1.config.Promise) !== null && _a !== void 0 ? _a : Promise;
+}
+function isObserver(value) {
+    return value && isFunction_1.isFunction(value.next) && isFunction_1.isFunction(value.error) && isFunction_1.isFunction(value.complete);
+}
+function isSubscriber(value) {
+    return (value && value instanceof Subscriber_1.Subscriber) || (isObserver(value) && Subscription_1.isSubscription(value));
+}
+//# sourceMappingURL=Observable.js.map

package/dist/src/web/frontend/node_modules/.rxjs-i8W7PyKW/dist/cjs/internal/Operator.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Operator.js.map

package/dist/src/web/frontend/node_modules/.rxjs-i8W7PyKW/dist/cjs/internal/ajax/AjaxResponse.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AjaxResponse = void 0;
+var getXHRResponse_1 = require("./getXHRResponse");
+var AjaxResponse = (function () {
+    function AjaxResponse(originalEvent, xhr, request, type) {
+        if (type === void 0) { type = 'download_load'; }
+        this.originalEvent = originalEvent;
+        this.xhr = xhr;
+        this.request = request;
+        this.type = type;
+        var status = xhr.status, responseType = xhr.responseType;
+        this.status = status !== null && status !== void 0 ? status : 0;
+        this.responseType = responseType !== null && responseType !== void 0 ? responseType : '';
+        var allHeaders = xhr.getAllResponseHeaders();
+        this.responseHeaders = allHeaders
+            ?
+                allHeaders.split('\n').reduce(function (headers, line) {
+                    var index = line.indexOf(': ');
+                    headers[line.slice(0, index)] = line.slice(index + 2);
+                    return headers;
+                }, {})
+            : {};
+        this.response = getXHRResponse_1.getXHRResponse(xhr);
+        var loaded = originalEvent.loaded, total = originalEvent.total;
+        this.loaded = loaded;
+        this.total = total;
+    }
+    return AjaxResponse;
+}());
+exports.AjaxResponse = AjaxResponse;
+//# sourceMappingURL=AjaxResponse.js.map

package/dist/src/web/frontend/node_modules/.rxjs-i8W7PyKW/dist/cjs/internal/ajax/ajax.js

@@ -0,0 +1,253 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromAjax = exports.ajax = void 0;
+var map_1 = require("../operators/map");
+var Observable_1 = require("../Observable");
+var AjaxResponse_1 = require("./AjaxResponse");
+var errors_1 = require("./errors");
+function ajaxGet(url, headers) {
+    return exports.ajax({ method: 'GET', url: url, headers: headers });
+}
+function ajaxPost(url, body, headers) {
+    return exports.ajax({ method: 'POST', url: url, body: body, headers: headers });
+}
+function ajaxDelete(url, headers) {
+    return exports.ajax({ method: 'DELETE', url: url, headers: headers });
+}
+function ajaxPut(url, body, headers) {
+    return exports.ajax({ method: 'PUT', url: url, body: body, headers: headers });
+}
+function ajaxPatch(url, body, headers) {
+    return exports.ajax({ method: 'PATCH', url: url, body: body, headers: headers });
+}
+var mapResponse = map_1.map(function (x) { return x.response; });
+function ajaxGetJSON(url, headers) {
+    return mapResponse(exports.ajax({
+        method: 'GET',
+        url: url,
+        headers: headers,
+    }));
+}
+exports.ajax = (function () {
+    var create = function (urlOrConfig) {
+        var config = typeof urlOrConfig === 'string'
+            ? {
+                url: urlOrConfig,
+            }
+            : urlOrConfig;
+        return fromAjax(config);
+    };
+    create.get = ajaxGet;
+    create.post = ajaxPost;
+    create.delete = ajaxDelete;
+    create.put = ajaxPut;
+    create.patch = ajaxPatch;
+    create.getJSON = ajaxGetJSON;
+    return create;
+})();
+var UPLOAD = 'upload';
+var DOWNLOAD = 'download';
+var LOADSTART = 'loadstart';
+var PROGRESS = 'progress';
+var LOAD = 'load';
+function fromAjax(init) {
+    return new Observable_1.Observable(function (destination) {
+        var _a, _b;
+        var config = __assign({ async: true, crossDomain: false, withCredentials: false, method: 'GET', timeout: 0, responseType: 'json' }, init);
+        var queryParams = config.queryParams, configuredBody = config.body, configuredHeaders = config.headers;
+        var url = config.url;
+        if (!url) {
+            throw new TypeError('url is required');
+        }
+        if (queryParams) {
+            var searchParams_1;
+            if (url.includes('?')) {
+                var parts = url.split('?');
+                if (2 < parts.length) {
+                    throw new TypeError('invalid url');
+                }
+                searchParams_1 = new URLSearchParams(parts[1]);
+                new URLSearchParams(queryParams).forEach(function (value, key) { return searchParams_1.set(key, value); });
+                url = parts[0] + '?' + searchParams_1;
+            }
+            else {
+                searchParams_1 = new URLSearchParams(queryParams);
+                url = url + '?' + searchParams_1;
+            }
+        }
+        var headers = {};
+        if (configuredHeaders) {
+            for (var key in configuredHeaders) {
+                if (configuredHeaders.hasOwnProperty(key)) {
+                    headers[key.toLowerCase()] = configuredHeaders[key];
+                }
+            }
+        }
+        var crossDomain = config.crossDomain;
+        if (!crossDomain && !('x-requested-with' in headers)) {
+            headers['x-requested-with'] = 'XMLHttpRequest';
+        }
+        var withCredentials = config.withCredentials, xsrfCookieName = config.xsrfCookieName, xsrfHeaderName = config.xsrfHeaderName;
+        if ((withCredentials || !crossDomain) && xsrfCookieName && xsrfHeaderName) {
+            var xsrfCookie = (_b = (_a = document === null || document === void 0 ? void 0 : document.cookie.match(new RegExp("(^|;\\s*)(" + xsrfCookieName + ")=([^;]*)"))) === null || _a === void 0 ? void 0 : _a.pop()) !== null && _b !== void 0 ? _b : '';
+            if (xsrfCookie) {
+                headers[xsrfHeaderName] = xsrfCookie;
+            }
+        }
+        var body = extractContentTypeAndMaybeSerializeBody(configuredBody, headers);
+        var _request = __assign(__assign({}, config), { url: url,
+            headers: headers,
+            body: body });
+        var xhr;
+        xhr = init.createXHR ? init.createXHR() : new XMLHttpRequest();
+        {
+            var progressSubscriber_1 = init.progressSubscriber, _c = init.includeDownloadProgress, includeDownloadProgress = _c === void 0 ? false : _c, _d = init.includeUploadProgress, includeUploadProgress = _d === void 0 ? false : _d;
+            var addErrorEvent = function (type, errorFactory) {
+                xhr.addEventListener(type, function () {
+                    var _a;
+                    var error = errorFactory();
+                    (_a = progressSubscriber_1 === null || progressSubscriber_1 === void 0 ? void 0 : progressSubscriber_1.error) === null || _a === void 0 ? void 0 : _a.call(progressSubscriber_1, error);
+                    destination.error(error);
+                });
+            };
+            addErrorEvent('timeout', function () { return new errors_1.AjaxTimeoutError(xhr, _request); });
+            addErrorEvent('abort', function () { return new errors_1.AjaxError('aborted', xhr, _request); });
+            var createResponse_1 = function (direction, event) {
+                return new AjaxResponse_1.AjaxResponse(event, xhr, _request, direction + "_" + event.type);
+            };
+            var addProgressEvent_1 = function (target, type, direction) {
+                target.addEventListener(type, function (event) {
+                    destination.next(createResponse_1(direction, event));
+                });
+            };
+            if (includeUploadProgress) {
+                [LOADSTART, PROGRESS, LOAD].forEach(function (type) { return addProgressEvent_1(xhr.upload, type, UPLOAD); });
+            }
+            if (progressSubscriber_1) {
+                [LOADSTART, PROGRESS].forEach(function (type) { return xhr.upload.addEventListener(type, function (e) { var _a; return (_a = progressSubscriber_1 === null || progressSubscriber_1 === void 0 ? void 0 : progressSubscriber_1.next) === null || _a === void 0 ? void 0 : _a.call(progressSubscriber_1, e); }); });
+            }
+            if (includeDownloadProgress) {
+                [LOADSTART, PROGRESS].forEach(function (type) { return addProgressEvent_1(xhr, type, DOWNLOAD); });
+            }
+            var emitError_1 = function (status) {
+                var msg = 'ajax error' + (status ? ' ' + status : '');
+                destination.error(new errors_1.AjaxError(msg, xhr, _request));
+            };
+            xhr.addEventListener('error', function (e) {
+                var _a;
+                (_a = progressSubscriber_1 === null || progressSubscriber_1 === void 0 ? void 0 : progressSubscriber_1.error) === null || _a === void 0 ? void 0 : _a.call(progressSubscriber_1, e);
+                emitError_1();
+            });
+            xhr.addEventListener(LOAD, function (event) {
+                var _a, _b;
+                var status = xhr.status;
+                if (status < 400) {
+                    (_a = progressSubscriber_1 === null || progressSubscriber_1 === void 0 ? void 0 : progressSubscriber_1.complete) === null || _a === void 0 ? void 0 : _a.call(progressSubscriber_1);
+                    var response = void 0;
+                    try {
+                        response = createResponse_1(DOWNLOAD, event);
+                    }
+                    catch (err) {
+                        destination.error(err);
+                        return;
+                    }
+                    destination.next(response);
+                    destination.complete();
+                }
+                else {
+                    (_b = progressSubscriber_1 === null || progressSubscriber_1 === void 0 ? void 0 : progressSubscriber_1.error) === null || _b === void 0 ? void 0 : _b.call(progressSubscriber_1, event);
+                    emitError_1(status);
+                }
+            });
+        }
+        var user = _request.user, method = _request.method, async = _request.async;
+        if (user) {
+            xhr.open(method, url, async, user, _request.password);
+        }
+        else {
+            xhr.open(method, url, async);
+        }
+        if (async) {
+            xhr.timeout = _request.timeout;
+            xhr.responseType = _request.responseType;
+        }
+        if ('withCredentials' in xhr) {
+            xhr.withCredentials = _request.withCredentials;
+        }
+        for (var key in headers) {
+            if (headers.hasOwnProperty(key)) {
+                xhr.setRequestHeader(key, headers[key]);
+            }
+        }
+        if (body) {
+            xhr.send(body);
+        }
+        else {
+            xhr.send();
+        }
+        return function () {
+            if (xhr && xhr.readyState !== 4) {
+                xhr.abort();
+            }
+        };
+    });
+}
+exports.fromAjax = fromAjax;
+function extractContentTypeAndMaybeSerializeBody(body, headers) {
+    var _a;
+    if (!body ||
+        typeof body === 'string' ||
+        isFormData(body) ||
+        isURLSearchParams(body) ||
+        isArrayBuffer(body) ||
+        isFile(body) ||
+        isBlob(body) ||
+        isReadableStream(body)) {
+        return body;
+    }
+    if (isArrayBufferView(body)) {
+        return body.buffer;
+    }
+    if (typeof body === 'object') {
+        headers['content-type'] = (_a = headers['content-type']) !== null && _a !== void 0 ? _a : 'application/json;charset=utf-8';
+        return JSON.stringify(body);
+    }
+    throw new TypeError('Unknown body type');
+}
+var _toString = Object.prototype.toString;
+function toStringCheck(obj, name) {
+    return _toString.call(obj) === "[object " + name + "]";
+}
+function isArrayBuffer(body) {
+    return toStringCheck(body, 'ArrayBuffer');
+}
+function isFile(body) {
+    return toStringCheck(body, 'File');
+}
+function isBlob(body) {
+    return toStringCheck(body, 'Blob');
+}
+function isArrayBufferView(body) {
+    return typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView(body);
+}
+function isFormData(body) {
+    return typeof FormData !== 'undefined' && body instanceof FormData;
+}
+function isURLSearchParams(body) {
+    return typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams;
+}
+function isReadableStream(body) {
+    return typeof ReadableStream !== 'undefined' && body instanceof ReadableStream;
+}
+//# sourceMappingURL=ajax.js.map

package/dist/src/web/frontend/node_modules/.rxjs-i8W7PyKW/dist/cjs/internal/ajax/errors.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AjaxTimeoutError = exports.AjaxError = void 0;
+var getXHRResponse_1 = require("./getXHRResponse");
+var createErrorClass_1 = require("../util/createErrorClass");
+exports.AjaxError = createErrorClass_1.createErrorClass(function (_super) {
+    return function AjaxErrorImpl(message, xhr, request) {
+        this.message = message;
+        this.name = 'AjaxError';
+        this.xhr = xhr;
+        this.request = request;
+        this.status = xhr.status;
+        this.responseType = xhr.responseType;
+        var response;
+        try {
+            response = getXHRResponse_1.getXHRResponse(xhr);
+        }
+        catch (err) {
+            response = xhr.responseText;
+        }
+        this.response = response;
+    };
+});
+exports.AjaxTimeoutError = (function () {
+    function AjaxTimeoutErrorImpl(xhr, request) {
+        exports.AjaxError.call(this, 'ajax timeout', xhr, request);
+        this.name = 'AjaxTimeoutError';
+        return this;
+    }
+    AjaxTimeoutErrorImpl.prototype = Object.create(exports.AjaxError.prototype);
+    return AjaxTimeoutErrorImpl;
+})();
+//# sourceMappingURL=errors.js.map

package/dist/src/web/frontend/node_modules/.rxjs-i8W7PyKW/dist/cjs/internal/ajax/getXHRResponse.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getXHRResponse = void 0;
+function getXHRResponse(xhr) {
+    switch (xhr.responseType) {
+        case 'json': {
+            if ('response' in xhr) {
+                return xhr.response;
+            }
+            else {
+                var ieXHR = xhr;
+                return JSON.parse(ieXHR.responseText);
+            }
+        }
+        case 'document':
+            return xhr.responseXML;
+        case 'text':
+        default: {
+            if ('response' in xhr) {
+                return xhr.response;
+            }
+            else {
+                var ieXHR = xhr;
+                return ieXHR.responseText;
+            }
+        }
+    }
+}
+exports.getXHRResponse = getXHRResponse;
+//# sourceMappingURL=getXHRResponse.js.map

package/dist/src/web/frontend/node_modules/.rxjs-i8W7PyKW/dist/cjs/internal/config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.config = {
+    onUnhandledError: null,
+    onStoppedNotification: null,
+    Promise: undefined,
+    useDeprecatedSynchronousErrorHandling: false,
+    useDeprecatedNextContext: false,
+};
+//# sourceMappingURL=config.js.map

package/dist/src/web/frontend/node_modules/.rxjs-i8W7PyKW/dist/cjs/internal/firstValueFrom.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstValueFrom = void 0;
+var EmptyError_1 = require("./util/EmptyError");
+var Subscriber_1 = require("./Subscriber");
+function firstValueFrom(source, config) {
+    var hasConfig = typeof config === 'object';
+    return new Promise(function (resolve, reject) {
+        var subscriber = new Subscriber_1.SafeSubscriber({
+            next: function (value) {
+                resolve(value);
+                subscriber.unsubscribe();
+            },
+            error: reject,
+            complete: function () {
+                if (hasConfig) {
+                    resolve(config.defaultValue);
+                }
+                else {
+                    reject(new EmptyError_1.EmptyError());
+                }
+            },
+        });
+        source.subscribe(subscriber);
+    });
+}
+exports.firstValueFrom = firstValueFrom;
+//# sourceMappingURL=firstValueFrom.js.map

package/dist/src/web/frontend/node_modules/.rxjs-i8W7PyKW/dist/cjs/internal/lastValueFrom.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lastValueFrom = void 0;
+var EmptyError_1 = require("./util/EmptyError");
+function lastValueFrom(source, config) {
+    var hasConfig = typeof config === 'object';
+    return new Promise(function (resolve, reject) {
+        var _hasValue = false;
+        var _value;
+        source.subscribe({
+            next: function (value) {
+                _value = value;
+                _hasValue = true;
+            },
+            error: reject,
+            complete: function () {
+                if (_hasValue) {
+                    resolve(_value);
+                }
+                else if (hasConfig) {
+                    resolve(config.defaultValue);
+                }
+                else {
+                    reject(new EmptyError_1.EmptyError());
+                }
+            },
+        });
+    });
+}
+exports.lastValueFrom = lastValueFrom;
+//# sourceMappingURL=lastValueFrom.js.map

package/dist/src/web/frontend/node_modules/.rxjs-i8W7PyKW/dist/cjs/internal/observable/ConnectableObservable.js

@@ -0,0 +1,80 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectableObservable = void 0;
+var Observable_1 = require("../Observable");
+var Subscription_1 = require("../Subscription");
+var refCount_1 = require("../operators/refCount");
+var OperatorSubscriber_1 = require("../operators/OperatorSubscriber");
+var lift_1 = require("../util/lift");
+var ConnectableObservable = (function (_super) {
+    __extends(ConnectableObservable, _super);
+    function ConnectableObservable(source, subjectFactory) {
+        var _this = _super.call(this) || this;
+        _this.source = source;
+        _this.subjectFactory = subjectFactory;
+        _this._subject = null;
+        _this._refCount = 0;
+        _this._connection = null;
+        if (lift_1.hasLift(source)) {
+            _this.lift = source.lift;
+        }
+        return _this;
+    }
+    ConnectableObservable.prototype._subscribe = function (subscriber) {
+        return this.getSubject().subscribe(subscriber);
+    };
+    ConnectableObservable.prototype.getSubject = function () {
+        var subject = this._subject;
+        if (!subject || subject.isStopped) {
+            this._subject = this.subjectFactory();
+        }
+        return this._subject;
+    };
+    ConnectableObservable.prototype._teardown = function () {
+        this._refCount = 0;
+        var _connection = this._connection;
+        this._subject = this._connection = null;
+        _connection === null || _connection === void 0 ? void 0 : _connection.unsubscribe();
+    };
+    ConnectableObservable.prototype.connect = function () {
+        var _this = this;
+        var connection = this._connection;
+        if (!connection) {
+            connection = this._connection = new Subscription_1.Subscription();
+            var subject_1 = this.getSubject();
+            connection.add(this.source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subject_1, undefined, function () {
+                _this._teardown();
+                subject_1.complete();
+            }, function (err) {
+                _this._teardown();
+                subject_1.error(err);
+            }, function () { return _this._teardown(); })));
+            if (connection.closed) {
+                this._connection = null;
+                connection = Subscription_1.Subscription.EMPTY;
+            }
+        }
+        return connection;
+    };
+    ConnectableObservable.prototype.refCount = function () {
+        return refCount_1.refCount()(this);
+    };
+    return ConnectableObservable;
+}(Observable_1.Observable));
+exports.ConnectableObservable = ConnectableObservable;
+//# sourceMappingURL=ConnectableObservable.js.map

package/dist/src/web/frontend/node_modules/.rxjs-i8W7PyKW/dist/cjs/internal/observable/bindCallback.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindCallback = void 0;
+var bindCallbackInternals_1 = require("./bindCallbackInternals");
+function bindCallback(callbackFunc, resultSelector, scheduler) {
+    return bindCallbackInternals_1.bindCallbackInternals(false, callbackFunc, resultSelector, scheduler);
+}
+exports.bindCallback = bindCallback;
+//# sourceMappingURL=bindCallback.js.map