new license file version [CI SKIP]
This commit is contained in:
@@ -0,0 +1,64 @@
|
||||
import { Observable } from '../Observable';
|
||||
import { OperatorFunction, ObservedValueOf } from '../../internal/types';
|
||||
import { mergeMap } from './mergeMap';
|
||||
import { ObservableInput } from '../types';
|
||||
|
||||
/* tslint:disable:max-line-length */
|
||||
export function mergeMapTo<T, O extends ObservableInput<any>>(innerObservable: O, concurrent?: number): OperatorFunction<any, ObservedValueOf<O>>;
|
||||
/** @deprecated */
|
||||
export function mergeMapTo<T, R, O extends ObservableInput<any>>(innerObservable: O, resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R, concurrent?: number): OperatorFunction<T, R>;
|
||||
/* tslint:enable:max-line-length */
|
||||
|
||||
/**
|
||||
* Projects each source value to the same Observable which is merged multiple
|
||||
* times in the output Observable.
|
||||
*
|
||||
* <span class="informal">It's like {@link mergeMap}, but maps each value always
|
||||
* to the same inner Observable.</span>
|
||||
*
|
||||
* 
|
||||
*
|
||||
* Maps each source value to the given Observable `innerObservable` regardless
|
||||
* of the source value, and then merges those resulting Observables into one
|
||||
* single Observable, which is the output Observable.
|
||||
*
|
||||
* ## Example
|
||||
* For each click event, start an interval Observable ticking every 1 second
|
||||
* ```ts
|
||||
* import { fromEvent, interval } from 'rxjs';
|
||||
* import { mergeMapTo } from 'rxjs/operators';
|
||||
*
|
||||
* const clicks = fromEvent(document, 'click');
|
||||
* const result = clicks.pipe(mergeMapTo(interval(1000)));
|
||||
* result.subscribe(x => console.log(x));
|
||||
* ```
|
||||
*
|
||||
* @see {@link concatMapTo}
|
||||
* @see {@link merge}
|
||||
* @see {@link mergeAll}
|
||||
* @see {@link mergeMap}
|
||||
* @see {@link mergeScan}
|
||||
* @see {@link switchMapTo}
|
||||
*
|
||||
* @param {ObservableInput} innerObservable An Observable to replace each value from
|
||||
* the source Observable.
|
||||
* @param {number} [concurrent=Number.POSITIVE_INFINITY] Maximum number of input
|
||||
* Observables being subscribed to concurrently.
|
||||
* @return {Observable} An Observable that emits items from the given
|
||||
* `innerObservable`
|
||||
* @method mergeMapTo
|
||||
* @owner Observable
|
||||
*/
|
||||
export function mergeMapTo<T, R, O extends ObservableInput<any>>(
|
||||
innerObservable: O,
|
||||
resultSelector?: ((outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R) | number,
|
||||
concurrent: number = Number.POSITIVE_INFINITY
|
||||
): OperatorFunction<T, ObservedValueOf<O>|R> {
|
||||
if (typeof resultSelector === 'function') {
|
||||
return mergeMap(() => innerObservable, resultSelector, concurrent);
|
||||
}
|
||||
if (typeof resultSelector === 'number') {
|
||||
concurrent = resultSelector;
|
||||
}
|
||||
return mergeMap(() => innerObservable, concurrent);
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"AsapScheduler.js","sources":["../../../src/internal/scheduler/AsapScheduler.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD;IAAmC,yCAAc;IAAjD;;IA2BA,CAAC;IA1BQ,6BAAK,GAAZ,UAAa,MAAyB;QAEpC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAEpB,IAAA,sBAAO,CAAS;QACvB,IAAI,KAAU,CAAC;QACf,IAAI,KAAK,GAAW,CAAC,CAAC,CAAC;QACvB,IAAI,KAAK,GAAW,OAAO,CAAC,MAAM,CAAC;QACnC,MAAM,GAAG,MAAM,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QAEnC,GAAG;YACD,IAAI,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE;gBACtD,MAAM;aACP;SACF,QAAQ,EAAE,KAAK,GAAG,KAAK,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,EAAE;QAExD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QAEpB,IAAI,KAAK,EAAE;YACT,OAAO,EAAE,KAAK,GAAG,KAAK,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,EAAE;gBACpD,MAAM,CAAC,WAAW,EAAE,CAAC;aACtB;YACD,MAAM,KAAK,CAAC;SACb;IACH,CAAC;IACH,oBAAC;AAAD,CAAC,AA3BD,CAAmC,cAAc,GA2BhD"}
|
||||
@@ -0,0 +1,11 @@
|
||||
// by james a rosen.
|
||||
// https://github.com/Modernizr/Modernizr/issues/258
|
||||
|
||||
Modernizr.addTest('createelement-attrs', function() {
|
||||
try {
|
||||
return document.createElement("<input name='test' />").getAttribute('name') == 'test';
|
||||
} catch(e) {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"1":"G A B","2":"J E F BC"},B:{"1":"C K L H M N O P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t"},C:{"1":"QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB","257":"0 1 2 3 4 5 6 7 8 9 I u J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB","289":"tB DC EC","292":"CC"},D:{"1":"0 1 2 3 4 5 6 7 8 9 u J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB FC","33":"I"},E:{"1":"u E F G A B C K L H JC KC 0B qB rB 1B LC MC 2B 3B 4B 5B sB 6B 7B 8B NC","33":"I GC zB","129":"J HC IC"},F:{"1":"0 1 2 3 4 5 6 7 8 9 B C H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d QC RC qB 9B SC rB","2":"G OC PC"},G:{"1":"F TC AC UC VC WC XC YC ZC aC bC cC dC eC fC gC hC iC jC kC lC mC 2B 3B 4B 5B sB 6B 7B 8B","33":"zB"},H:{"2":"nC"},I:{"1":"tB I D pC qC rC AC sC tC","33":"oC"},J:{"1":"E A"},K:{"1":"B C e qB 9B rB","2":"A"},L:{"1":"D"},M:{"1":"D"},N:{"1":"A B"},O:{"1":"uC"},P:{"1":"I vC wC xC yC zC 0B 0C 1C 2C 3C 4C sB 5C 6C 7C"},Q:{"1":"1B"},R:{"1":"8C"},S:{"257":"9C"}},B:4,C:"CSS3 Border-radius (rounded corners)"};
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"AjaxObservable.js","sources":["../../src/observable/dom/AjaxObservable.ts"],"names":[],"mappings":";;;;;AAAA,+DAA0D"}
|
||||
@@ -0,0 +1 @@
|
||||
!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).uuidv4=e()}(this,(function(){"use strict";var t,e=new Uint8Array(16);function o(){if(!t&&!(t="undefined"!=typeof crypto&&crypto.getRandomValues&&crypto.getRandomValues.bind(crypto)||"undefined"!=typeof msCrypto&&"function"==typeof msCrypto.getRandomValues&&msCrypto.getRandomValues.bind(msCrypto)))throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");return t(e)}var n=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;function r(t){return"string"==typeof t&&n.test(t)}for(var i=[],u=0;u<256;++u)i.push((u+256).toString(16).substr(1));return function(t,e,n){var u=(t=t||{}).random||(t.rng||o)();if(u[6]=15&u[6]|64,u[8]=63&u[8]|128,e){n=n||0;for(var f=0;f<16;++f)e[n+f]=u[f];return e}return function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,o=(i[t[e+0]]+i[t[e+1]]+i[t[e+2]]+i[t[e+3]]+"-"+i[t[e+4]]+i[t[e+5]]+"-"+i[t[e+6]]+i[t[e+7]]+"-"+i[t[e+8]]+i[t[e+9]]+"-"+i[t[e+10]]+i[t[e+11]]+i[t[e+12]]+i[t[e+13]]+i[t[e+14]]+i[t[e+15]]).toLowerCase();if(!r(o))throw TypeError("Stringified UUID is invalid");return o}(u)}}));
|
||||
@@ -0,0 +1,60 @@
|
||||
# has-yarn [](https://travis-ci.org/sindresorhus/has-yarn)
|
||||
|
||||
> Check if a project is using [Yarn](https://yarnpkg.com)
|
||||
|
||||
Useful for tools that needs to know whether to use `yarn` or `npm` to install dependencies.
|
||||
|
||||
It checks if a `yarn.lock` file is present in the working directory.
|
||||
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
$ npm install has-yarn
|
||||
```
|
||||
|
||||
|
||||
## Usage
|
||||
|
||||
```
|
||||
.
|
||||
├── foo
|
||||
│ └── package.json
|
||||
└── bar
|
||||
├── package.json
|
||||
└── yarn.lock
|
||||
```
|
||||
|
||||
```js
|
||||
const hasYarn = require('has-yarn');
|
||||
|
||||
hasYarn('foo');
|
||||
//=> false
|
||||
|
||||
hasYarn('bar');
|
||||
//=> true
|
||||
```
|
||||
|
||||
|
||||
## API
|
||||
|
||||
### hasYarn([cwd])
|
||||
|
||||
Returns a `boolean` of whether the project uses Yarn.
|
||||
|
||||
#### cwd
|
||||
|
||||
Type: `string`<br>
|
||||
Default: `process.cwd()`
|
||||
|
||||
Current working directory.
|
||||
|
||||
|
||||
## Related
|
||||
|
||||
- [has-yarn-cli](https://github.com/sindresorhus/has-yarn-cli) - CLI for this module
|
||||
|
||||
|
||||
## License
|
||||
|
||||
MIT © [Sindre Sorhus](https://sindresorhus.com)
|
||||
@@ -0,0 +1 @@
|
||||
import 'rxjs-compat/add/operator/partition';
|
||||
@@ -0,0 +1,114 @@
|
||||
import assertString from './util/assertString';
|
||||
/**
|
||||
* Reference:
|
||||
* https://en.wikipedia.org/ -- Wikipedia
|
||||
* https://docs.microsoft.com/en-us/microsoft-365/compliance/eu-passport-number -- EU Passport Number
|
||||
* https://countrycode.org/ -- Country Codes
|
||||
*/
|
||||
|
||||
var passportRegexByCountryCode = {
|
||||
AM: /^[A-Z]{2}\d{7}$/,
|
||||
// ARMENIA
|
||||
AR: /^[A-Z]{3}\d{6}$/,
|
||||
// ARGENTINA
|
||||
AT: /^[A-Z]\d{7}$/,
|
||||
// AUSTRIA
|
||||
AU: /^[A-Z]\d{7}$/,
|
||||
// AUSTRALIA
|
||||
BE: /^[A-Z]{2}\d{6}$/,
|
||||
// BELGIUM
|
||||
BG: /^\d{9}$/,
|
||||
// BULGARIA
|
||||
BY: /^[A-Z]{2}\d{7}$/,
|
||||
// BELARUS
|
||||
CA: /^[A-Z]{2}\d{6}$/,
|
||||
// CANADA
|
||||
CH: /^[A-Z]\d{7}$/,
|
||||
// SWITZERLAND
|
||||
CN: /^[GE]\d{8}$/,
|
||||
// CHINA [G=Ordinary, E=Electronic] followed by 8-digits
|
||||
CY: /^[A-Z](\d{6}|\d{8})$/,
|
||||
// CYPRUS
|
||||
CZ: /^\d{8}$/,
|
||||
// CZECH REPUBLIC
|
||||
DE: /^[CFGHJKLMNPRTVWXYZ0-9]{9}$/,
|
||||
// GERMANY
|
||||
DK: /^\d{9}$/,
|
||||
// DENMARK
|
||||
DZ: /^\d{9}$/,
|
||||
// ALGERIA
|
||||
EE: /^([A-Z]\d{7}|[A-Z]{2}\d{7})$/,
|
||||
// ESTONIA (K followed by 7-digits), e-passports have 2 UPPERCASE followed by 7 digits
|
||||
ES: /^[A-Z0-9]{2}([A-Z0-9]?)\d{6}$/,
|
||||
// SPAIN
|
||||
FI: /^[A-Z]{2}\d{7}$/,
|
||||
// FINLAND
|
||||
FR: /^\d{2}[A-Z]{2}\d{5}$/,
|
||||
// FRANCE
|
||||
GB: /^\d{9}$/,
|
||||
// UNITED KINGDOM
|
||||
GR: /^[A-Z]{2}\d{7}$/,
|
||||
// GREECE
|
||||
HR: /^\d{9}$/,
|
||||
// CROATIA
|
||||
HU: /^[A-Z]{2}(\d{6}|\d{7})$/,
|
||||
// HUNGARY
|
||||
IE: /^[A-Z0-9]{2}\d{7}$/,
|
||||
// IRELAND
|
||||
IN: /^[A-Z]{1}-?\d{7}$/,
|
||||
// INDIA
|
||||
IS: /^(A)\d{7}$/,
|
||||
// ICELAND
|
||||
IT: /^[A-Z0-9]{2}\d{7}$/,
|
||||
// ITALY
|
||||
JP: /^[A-Z]{2}\d{7}$/,
|
||||
// JAPAN
|
||||
KR: /^[MS]\d{8}$/,
|
||||
// SOUTH KOREA, REPUBLIC OF KOREA, [S=PS Passports, M=PM Passports]
|
||||
LT: /^[A-Z0-9]{8}$/,
|
||||
// LITHUANIA
|
||||
LU: /^[A-Z0-9]{8}$/,
|
||||
// LUXEMBURG
|
||||
LV: /^[A-Z0-9]{2}\d{7}$/,
|
||||
// LATVIA
|
||||
MT: /^\d{7}$/,
|
||||
// MALTA
|
||||
NL: /^[A-Z]{2}[A-Z0-9]{6}\d$/,
|
||||
// NETHERLANDS
|
||||
PO: /^[A-Z]{2}\d{7}$/,
|
||||
// POLAND
|
||||
PT: /^[A-Z]\d{6}$/,
|
||||
// PORTUGAL
|
||||
RO: /^\d{8,9}$/,
|
||||
// ROMANIA
|
||||
RU: /^\d{2}\d{2}\d{6}$/,
|
||||
// RUSSIAN FEDERATION
|
||||
SE: /^\d{8}$/,
|
||||
// SWEDEN
|
||||
SL: /^(P)[A-Z]\d{7}$/,
|
||||
// SLOVANIA
|
||||
SK: /^[0-9A-Z]\d{7}$/,
|
||||
// SLOVAKIA
|
||||
TR: /^[A-Z]\d{8}$/,
|
||||
// TURKEY
|
||||
UA: /^[A-Z]{2}\d{6}$/,
|
||||
// UKRAINE
|
||||
US: /^\d{9}$/ // UNITED STATES
|
||||
|
||||
};
|
||||
/**
|
||||
* Check if str is a valid passport number
|
||||
* relative to provided ISO Country Code.
|
||||
*
|
||||
* @param {string} str
|
||||
* @param {string} countryCode
|
||||
* @return {boolean}
|
||||
*/
|
||||
|
||||
export default function isPassportNumber(str, countryCode) {
|
||||
assertString(str);
|
||||
/** Remove All Whitespaces, Convert to UPPERCASE */
|
||||
|
||||
var normalizedStr = str.replace(/\s/g, '').toUpperCase();
|
||||
return countryCode.toUpperCase() in passportRegexByCountryCode && passportRegexByCountryCode[countryCode].test(normalizedStr);
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
var RetryOperation = require('./retry_operation');
|
||||
|
||||
exports.operation = function(options) {
|
||||
var timeouts = exports.timeouts(options);
|
||||
return new RetryOperation(timeouts, {
|
||||
forever: options && options.forever,
|
||||
unref: options && options.unref,
|
||||
maxRetryTime: options && options.maxRetryTime
|
||||
});
|
||||
};
|
||||
|
||||
exports.timeouts = function(options) {
|
||||
if (options instanceof Array) {
|
||||
return [].concat(options);
|
||||
}
|
||||
|
||||
var opts = {
|
||||
retries: 10,
|
||||
factor: 2,
|
||||
minTimeout: 1 * 1000,
|
||||
maxTimeout: Infinity,
|
||||
randomize: false
|
||||
};
|
||||
for (var key in options) {
|
||||
opts[key] = options[key];
|
||||
}
|
||||
|
||||
if (opts.minTimeout > opts.maxTimeout) {
|
||||
throw new Error('minTimeout is greater than maxTimeout');
|
||||
}
|
||||
|
||||
var timeouts = [];
|
||||
for (var i = 0; i < opts.retries; i++) {
|
||||
timeouts.push(this.createTimeout(i, opts));
|
||||
}
|
||||
|
||||
if (options && options.forever && !timeouts.length) {
|
||||
timeouts.push(this.createTimeout(i, opts));
|
||||
}
|
||||
|
||||
// sort the array numerically ascending
|
||||
timeouts.sort(function(a,b) {
|
||||
return a - b;
|
||||
});
|
||||
|
||||
return timeouts;
|
||||
};
|
||||
|
||||
exports.createTimeout = function(attempt, opts) {
|
||||
var random = (opts.randomize)
|
||||
? (Math.random() + 1)
|
||||
: 1;
|
||||
|
||||
var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
|
||||
timeout = Math.min(timeout, opts.maxTimeout);
|
||||
|
||||
return timeout;
|
||||
};
|
||||
|
||||
exports.wrap = function(obj, options, methods) {
|
||||
if (options instanceof Array) {
|
||||
methods = options;
|
||||
options = null;
|
||||
}
|
||||
|
||||
if (!methods) {
|
||||
methods = [];
|
||||
for (var key in obj) {
|
||||
if (typeof obj[key] === 'function') {
|
||||
methods.push(key);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (var i = 0; i < methods.length; i++) {
|
||||
var method = methods[i];
|
||||
var original = obj[method];
|
||||
|
||||
obj[method] = function retryWrapper(original) {
|
||||
var op = exports.operation(options);
|
||||
var args = Array.prototype.slice.call(arguments, 1);
|
||||
var callback = args.pop();
|
||||
|
||||
args.push(function(err) {
|
||||
if (op.retry(err)) {
|
||||
return;
|
||||
}
|
||||
if (err) {
|
||||
arguments[0] = op.mainError();
|
||||
}
|
||||
callback.apply(this, arguments);
|
||||
});
|
||||
|
||||
op.attempt(function() {
|
||||
original.apply(obj, args);
|
||||
});
|
||||
}.bind(obj, original);
|
||||
obj[method].options = options;
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1 @@
|
||||
export * from 'rxjs-compat/operators/timeoutWith';
|
||||
@@ -0,0 +1,88 @@
|
||||
import { PartialObserver } from './types';
|
||||
import { Observable } from './Observable';
|
||||
/**
|
||||
* @deprecated NotificationKind is deprecated as const enums are not compatible with isolated modules. Use a string literal instead.
|
||||
*/
|
||||
export declare enum NotificationKind {
|
||||
NEXT = "N",
|
||||
ERROR = "E",
|
||||
COMPLETE = "C"
|
||||
}
|
||||
/**
|
||||
* Represents a push-based event or value that an {@link Observable} can emit.
|
||||
* This class is particularly useful for operators that manage notifications,
|
||||
* like {@link materialize}, {@link dematerialize}, {@link observeOn}, and
|
||||
* others. Besides wrapping the actual delivered value, it also annotates it
|
||||
* with metadata of, for instance, what type of push message it is (`next`,
|
||||
* `error`, or `complete`).
|
||||
*
|
||||
* @see {@link materialize}
|
||||
* @see {@link dematerialize}
|
||||
* @see {@link observeOn}
|
||||
*
|
||||
* @class Notification<T>
|
||||
*/
|
||||
export declare class Notification<T> {
|
||||
kind: 'N' | 'E' | 'C';
|
||||
value?: T;
|
||||
error?: any;
|
||||
hasValue: boolean;
|
||||
constructor(kind: 'N' | 'E' | 'C', value?: T, error?: any);
|
||||
/**
|
||||
* Delivers to the given `observer` the value wrapped by this Notification.
|
||||
* @param {Observer} observer
|
||||
* @return
|
||||
*/
|
||||
observe(observer: PartialObserver<T>): any;
|
||||
/**
|
||||
* Given some {@link Observer} callbacks, deliver the value represented by the
|
||||
* current Notification to the correctly corresponding callback.
|
||||
* @param {function(value: T): void} next An Observer `next` callback.
|
||||
* @param {function(err: any): void} [error] An Observer `error` callback.
|
||||
* @param {function(): void} [complete] An Observer `complete` callback.
|
||||
* @return {any}
|
||||
*/
|
||||
do(next: (value: T) => void, error?: (err: any) => void, complete?: () => void): any;
|
||||
/**
|
||||
* Takes an Observer or its individual callback functions, and calls `observe`
|
||||
* or `do` methods accordingly.
|
||||
* @param {Observer|function(value: T): void} nextOrObserver An Observer or
|
||||
* the `next` callback.
|
||||
* @param {function(err: any): void} [error] An Observer `error` callback.
|
||||
* @param {function(): void} [complete] An Observer `complete` callback.
|
||||
* @return {any}
|
||||
*/
|
||||
accept(nextOrObserver: PartialObserver<T> | ((value: T) => void), error?: (err: any) => void, complete?: () => void): any;
|
||||
/**
|
||||
* Returns a simple Observable that just delivers the notification represented
|
||||
* by this Notification instance.
|
||||
* @return {any}
|
||||
*/
|
||||
toObservable(): Observable<T>;
|
||||
private static completeNotification;
|
||||
private static undefinedValueNotification;
|
||||
/**
|
||||
* A shortcut to create a Notification instance of the type `next` from a
|
||||
* given value.
|
||||
* @param {T} value The `next` value.
|
||||
* @return {Notification<T>} The "next" Notification representing the
|
||||
* argument.
|
||||
* @nocollapse
|
||||
*/
|
||||
static createNext<T>(value: T): Notification<T>;
|
||||
/**
|
||||
* A shortcut to create a Notification instance of the type `error` from a
|
||||
* given error.
|
||||
* @param {any} [err] The `error` error.
|
||||
* @return {Notification<T>} The "error" Notification representing the
|
||||
* argument.
|
||||
* @nocollapse
|
||||
*/
|
||||
static createError<T>(err?: any): Notification<T>;
|
||||
/**
|
||||
* A shortcut to create a Notification instance of the type `complete`.
|
||||
* @return {Notification<any>} The valueless "complete" Notification.
|
||||
* @nocollapse
|
||||
*/
|
||||
static createComplete(): Notification<any>;
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"zip.js","sources":["../src/operators/zip.ts"],"names":[],"mappings":";;;;;AAAA,+CAA0C"}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"fromEventPattern.js","sources":["../../../src/internal/observable/fromEventPattern.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAwIvC,MAAM,UAAU,gBAAgB,CAAI,UAA8C,EAC9C,aAAiE,EACjE,cAAsC;IAExE,IAAI,cAAc,EAAE;QAElB,OAAO,gBAAgB,CAAI,UAAU,EAAE,aAAa,CAAC,CAAC,IAAI,CACxD,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAC5E,CAAC;KACH;IAED,OAAO,IAAI,UAAU,CAAU,UAAU,CAAC,EAAE;QAC1C,MAAM,OAAO,GAAG,CAAC,GAAG,CAAM,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAE1E,IAAI,QAAa,CAAC;QAClB,IAAI;YACF,QAAQ,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;SAChC;QAAC,OAAO,GAAG,EAAE;YACZ,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YACtB,OAAO,SAAS,CAAC;SAClB;QAED,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;YAC9B,OAAO,SAAS,CAAC;SAClB;QAED,OAAO,GAAG,EAAE,CAAC,aAAa,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAE;IACjD,CAAC,CAAC,CAAC;AACL,CAAC"}
|
||||
@@ -0,0 +1,38 @@
|
||||
{
|
||||
"root": true,
|
||||
|
||||
"extends": "@ljharb",
|
||||
|
||||
"ignorePatterns": [
|
||||
"dist/",
|
||||
],
|
||||
|
||||
"rules": {
|
||||
"complexity": 0,
|
||||
"consistent-return": 1,
|
||||
"func-name-matching": 0,
|
||||
"id-length": [2, { "min": 1, "max": 25, "properties": "never" }],
|
||||
"indent": [2, 4],
|
||||
"max-lines-per-function": [2, { "max": 150 }],
|
||||
"max-params": [2, 16],
|
||||
"max-statements": [2, 53],
|
||||
"multiline-comment-style": 0,
|
||||
"no-continue": 1,
|
||||
"no-magic-numbers": 0,
|
||||
"no-restricted-syntax": [2, "BreakStatement", "DebuggerStatement", "ForInStatement", "LabeledStatement", "WithStatement"],
|
||||
},
|
||||
|
||||
"overrides": [
|
||||
{
|
||||
"files": "test/**",
|
||||
"rules": {
|
||||
"function-paren-newline": 0,
|
||||
"max-lines-per-function": 0,
|
||||
"max-statements": 0,
|
||||
"no-buffer-constructor": 0,
|
||||
"no-extend-native": 0,
|
||||
"no-throw-literal": 0,
|
||||
},
|
||||
},
|
||||
],
|
||||
}
|
||||
@@ -0,0 +1,746 @@
|
||||
/**
|
||||
* Options for compressing data into a DEFLATE format
|
||||
*/
|
||||
export interface DeflateOptions {
|
||||
/**
|
||||
* The level of compression to use, ranging from 0-9.
|
||||
*
|
||||
* 0 will store the data without compression.
|
||||
* 1 is fastest but compresses the worst, 9 is slowest but compresses the best.
|
||||
* The default level is 6.
|
||||
*
|
||||
* Typically, binary data benefits much more from higher values than text data.
|
||||
* In both cases, higher values usually take disproportionately longer than the reduction in final size that results.
|
||||
*
|
||||
* For example, a 1 MB text file could:
|
||||
* - become 1.01 MB with level 0 in 1ms
|
||||
* - become 400 kB with level 1 in 10ms
|
||||
* - become 320 kB with level 9 in 100ms
|
||||
*/
|
||||
level?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
|
||||
/**
|
||||
* The memory level to use, ranging from 0-12. Increasing this increases speed and compression ratio at the cost of memory.
|
||||
*
|
||||
* Note that this is exponential: while level 0 uses 4 kB, level 4 uses 64 kB, level 8 uses 1 MB, and level 12 uses 16 MB.
|
||||
* It is recommended not to lower the value below 4, since that tends to hurt performance.
|
||||
* In addition, values above 8 tend to help very little on most data and can even hurt performance.
|
||||
*
|
||||
* The default value is automatically determined based on the size of the input data.
|
||||
*/
|
||||
mem?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
|
||||
}
|
||||
/**
|
||||
* Options for compressing data into a GZIP format
|
||||
*/
|
||||
export interface GzipOptions extends DeflateOptions {
|
||||
/**
|
||||
* When the file was last modified. Defaults to the current time.
|
||||
* If you're using GZIP, set this to 0 to avoid revealing a modification date entirely.
|
||||
*/
|
||||
mtime?: Date | string | number;
|
||||
/**
|
||||
* The filename of the data. If the `gunzip` command is used to decompress the data, it will output a file
|
||||
* with this name instead of the name of the compressed file.
|
||||
*/
|
||||
filename?: string;
|
||||
}
|
||||
/**
|
||||
* Options for compressing data into a Zlib format
|
||||
*/
|
||||
export interface ZlibOptions extends DeflateOptions {
|
||||
}
|
||||
/**
|
||||
* Handler for data (de)compression streams
|
||||
* @param data The data output from the stream processor
|
||||
* @param final Whether this is the final block
|
||||
*/
|
||||
export declare type FlateStreamHandler = (data: Uint8Array, final: boolean) => void;
|
||||
/**
|
||||
* Handler for asynchronous data (de)compression streams
|
||||
* @param err Any error that occurred
|
||||
* @param data The data output from the stream processor
|
||||
* @param final Whether this is the final block
|
||||
*/
|
||||
export declare type AsyncFlateStreamHandler = (err: Error, data: Uint8Array, final: boolean) => void;
|
||||
/**
|
||||
* Callback for asynchronous (de)compression methods
|
||||
* @param err Any error that occurred
|
||||
* @param data The resulting data. Only present if `err` is null
|
||||
*/
|
||||
export declare type FlateCallback = (err: Error, data: Uint8Array) => void;
|
||||
interface AsyncOptions {
|
||||
/**
|
||||
* Whether or not to "consume" the source data. This will make the typed array/buffer you pass in
|
||||
* unusable but will increase performance and reduce memory usage.
|
||||
*/
|
||||
consume?: boolean;
|
||||
}
|
||||
/**
|
||||
* Options for compressing data asynchronously into a DEFLATE format
|
||||
*/
|
||||
export interface AsyncDeflateOptions extends DeflateOptions, AsyncOptions {
|
||||
}
|
||||
/**
|
||||
* Options for decompressing DEFLATE data asynchronously
|
||||
*/
|
||||
export interface AsyncInflateOptions extends AsyncOptions {
|
||||
/**
|
||||
* The original size of the data. Currently, the asynchronous API disallows
|
||||
* writing into a buffer you provide; the best you can do is provide the
|
||||
* size in bytes and be given back a new typed array.
|
||||
*/
|
||||
size?: number;
|
||||
}
|
||||
/**
|
||||
* Options for compressing data asynchronously into a GZIP format
|
||||
*/
|
||||
export interface AsyncGzipOptions extends GzipOptions, AsyncOptions {
|
||||
}
|
||||
/**
|
||||
* Options for decompressing GZIP data asynchronously
|
||||
*/
|
||||
export interface AsyncGunzipOptions extends AsyncOptions {
|
||||
}
|
||||
/**
|
||||
* Options for compressing data asynchronously into a Zlib format
|
||||
*/
|
||||
export interface AsyncZlibOptions extends ZlibOptions, AsyncOptions {
|
||||
}
|
||||
/**
|
||||
* Options for decompressing Zlib data asynchronously
|
||||
*/
|
||||
export interface AsyncUnzlibOptions extends AsyncInflateOptions {
|
||||
}
|
||||
/**
|
||||
* A terminable compression/decompression process
|
||||
*/
|
||||
export interface AsyncTerminable {
|
||||
/**
|
||||
* Terminates the worker thread immediately. The callback will not be called.
|
||||
*/
|
||||
(): void;
|
||||
}
|
||||
/**
|
||||
* Streaming DEFLATE compression
|
||||
*/
|
||||
export declare class Deflate {
|
||||
/**
|
||||
* Creates a DEFLATE stream
|
||||
* @param opts The compression options
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(opts: DeflateOptions, cb?: FlateStreamHandler);
|
||||
constructor(cb?: FlateStreamHandler);
|
||||
private o;
|
||||
private d;
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: FlateStreamHandler;
|
||||
private p;
|
||||
/**
|
||||
* Pushes a chunk to be deflated
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the last chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
}
|
||||
/**
|
||||
* Asynchronous streaming DEFLATE compression
|
||||
*/
|
||||
export declare class AsyncDeflate {
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: AsyncFlateStreamHandler;
|
||||
/**
|
||||
* Creates an asynchronous DEFLATE stream
|
||||
* @param opts The compression options
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(opts: DeflateOptions, cb?: AsyncFlateStreamHandler);
|
||||
/**
|
||||
* Creates an asynchronous DEFLATE stream
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(cb?: AsyncFlateStreamHandler);
|
||||
/**
|
||||
* Pushes a chunk to be deflated
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the last chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
/**
|
||||
* A method to terminate the stream's internal worker. Subsequent calls to
|
||||
* push() will silently fail.
|
||||
*/
|
||||
terminate: AsyncTerminable;
|
||||
}
|
||||
/**
|
||||
* Asynchronously compresses data with DEFLATE without any wrapper
|
||||
* @param data The data to compress
|
||||
* @param opts The compression options
|
||||
* @param cb The function to be called upon compression completion
|
||||
* @returns A function that can be used to immediately terminate the compression
|
||||
*/
|
||||
export declare function deflate(data: Uint8Array, opts: AsyncDeflateOptions, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Asynchronously compresses data with DEFLATE without any wrapper
|
||||
* @param data The data to compress
|
||||
* @param cb The function to be called upon compression completion
|
||||
*/
|
||||
export declare function deflate(data: Uint8Array, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Compresses data with DEFLATE without any wrapper
|
||||
* @param data The data to compress
|
||||
* @param opts The compression options
|
||||
* @returns The deflated version of the data
|
||||
*/
|
||||
export declare function deflateSync(data: Uint8Array, opts?: DeflateOptions): Uint8Array;
|
||||
/**
|
||||
* Streaming DEFLATE decompression
|
||||
*/
|
||||
export declare class Inflate {
|
||||
/**
|
||||
* Creates an inflation stream
|
||||
* @param cb The callback to call whenever data is inflated
|
||||
*/
|
||||
constructor(cb?: FlateStreamHandler);
|
||||
private s;
|
||||
private o;
|
||||
private p;
|
||||
private d;
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: FlateStreamHandler;
|
||||
private e;
|
||||
private c;
|
||||
/**
|
||||
* Pushes a chunk to be inflated
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the final chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
}
|
||||
/**
|
||||
* Asynchronous streaming DEFLATE decompression
|
||||
*/
|
||||
export declare class AsyncInflate {
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: AsyncFlateStreamHandler;
|
||||
/**
|
||||
* Creates an asynchronous inflation stream
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(cb?: AsyncFlateStreamHandler);
|
||||
/**
|
||||
* Pushes a chunk to be inflated
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the last chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
/**
|
||||
* A method to terminate the stream's internal worker. Subsequent calls to
|
||||
* push() will silently fail.
|
||||
*/
|
||||
terminate: AsyncTerminable;
|
||||
}
|
||||
/**
|
||||
* Asynchronously expands DEFLATE data with no wrapper
|
||||
* @param data The data to decompress
|
||||
* @param opts The decompression options
|
||||
* @param cb The function to be called upon decompression completion
|
||||
* @returns A function that can be used to immediately terminate the decompression
|
||||
*/
|
||||
export declare function inflate(data: Uint8Array, opts: AsyncInflateOptions, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Asynchronously expands DEFLATE data with no wrapper
|
||||
* @param data The data to decompress
|
||||
* @param cb The function to be called upon decompression completion
|
||||
* @returns A function that can be used to immediately terminate the decompression
|
||||
*/
|
||||
export declare function inflate(data: Uint8Array, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Expands DEFLATE data with no wrapper
|
||||
* @param data The data to decompress
|
||||
* @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.
|
||||
* @returns The decompressed version of the data
|
||||
*/
|
||||
export declare function inflateSync(data: Uint8Array, out?: Uint8Array): Uint8Array;
|
||||
/**
|
||||
* Streaming GZIP compression
|
||||
*/
|
||||
export declare class Gzip {
|
||||
private c;
|
||||
private l;
|
||||
private v;
|
||||
private o;
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: FlateStreamHandler;
|
||||
/**
|
||||
* Creates a GZIP stream
|
||||
* @param opts The compression options
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(opts: GzipOptions, cb?: FlateStreamHandler);
|
||||
/**
|
||||
* Creates a GZIP stream
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(cb?: FlateStreamHandler);
|
||||
/**
|
||||
* Pushes a chunk to be GZIPped
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the last chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
private p;
|
||||
}
|
||||
/**
|
||||
* Asynchronous streaming GZIP compression
|
||||
*/
|
||||
export declare class AsyncGzip {
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: AsyncFlateStreamHandler;
|
||||
/**
|
||||
* Creates an asynchronous GZIP stream
|
||||
* @param opts The compression options
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(opts: GzipOptions, cb?: AsyncFlateStreamHandler);
|
||||
/**
|
||||
* Creates an asynchronous GZIP stream
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(cb?: AsyncFlateStreamHandler);
|
||||
/**
|
||||
* Pushes a chunk to be GZIPped
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the last chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
/**
|
||||
* A method to terminate the stream's internal worker. Subsequent calls to
|
||||
* push() will silently fail.
|
||||
*/
|
||||
terminate: AsyncTerminable;
|
||||
}
|
||||
/**
|
||||
* Asynchronously compresses data with GZIP
|
||||
* @param data The data to compress
|
||||
* @param opts The compression options
|
||||
* @param cb The function to be called upon compression completion
|
||||
* @returns A function that can be used to immediately terminate the compression
|
||||
*/
|
||||
export declare function gzip(data: Uint8Array, opts: AsyncGzipOptions, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Asynchronously compresses data with GZIP
|
||||
* @param data The data to compress
|
||||
* @param cb The function to be called upon compression completion
|
||||
* @returns A function that can be used to immediately terminate the decompression
|
||||
*/
|
||||
export declare function gzip(data: Uint8Array, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Compresses data with GZIP
|
||||
* @param data The data to compress
|
||||
* @param opts The compression options
|
||||
* @returns The gzipped version of the data
|
||||
*/
|
||||
export declare function gzipSync(data: Uint8Array, opts?: GzipOptions): Uint8Array;
|
||||
/**
|
||||
* Streaming GZIP decompression
|
||||
*/
|
||||
export declare class Gunzip {
|
||||
private v;
|
||||
private p;
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: FlateStreamHandler;
|
||||
/**
|
||||
* Creates a GUNZIP stream
|
||||
* @param cb The callback to call whenever data is inflated
|
||||
*/
|
||||
constructor(cb?: FlateStreamHandler);
|
||||
/**
|
||||
* Pushes a chunk to be GUNZIPped
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the last chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
}
|
||||
/**
|
||||
* Asynchronous streaming GZIP decompression
|
||||
*/
|
||||
export declare class AsyncGunzip {
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: AsyncFlateStreamHandler;
|
||||
/**
|
||||
* Creates an asynchronous GUNZIP stream
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(cb: AsyncFlateStreamHandler);
|
||||
/**
|
||||
* Pushes a chunk to be GUNZIPped
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the last chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
/**
|
||||
* A method to terminate the stream's internal worker. Subsequent calls to
|
||||
* push() will silently fail.
|
||||
*/
|
||||
terminate: AsyncTerminable;
|
||||
}
|
||||
/**
|
||||
* Asynchronously expands GZIP data
|
||||
* @param data The data to decompress
|
||||
* @param opts The decompression options
|
||||
* @param cb The function to be called upon decompression completion
|
||||
* @returns A function that can be used to immediately terminate the decompression
|
||||
*/
|
||||
export declare function gunzip(data: Uint8Array, opts: AsyncGunzipOptions, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Asynchronously expands GZIP data
|
||||
* @param data The data to decompress
|
||||
* @param cb The function to be called upon decompression completion
|
||||
* @returns A function that can be used to immediately terminate the decompression
|
||||
*/
|
||||
export declare function gunzip(data: Uint8Array, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Expands GZIP data
|
||||
* @param data The data to decompress
|
||||
* @param out Where to write the data. GZIP already encodes the output size, so providing this doesn't save memory.
|
||||
* @returns The decompressed version of the data
|
||||
*/
|
||||
export declare function gunzipSync(data: Uint8Array, out?: Uint8Array): Uint8Array;
|
||||
/**
|
||||
* Streaming Zlib compression
|
||||
*/
|
||||
export declare class Zlib {
|
||||
private c;
|
||||
private v;
|
||||
private o;
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: FlateStreamHandler;
|
||||
/**
|
||||
* Creates a Zlib stream
|
||||
* @param opts The compression options
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(opts: ZlibOptions, cb?: FlateStreamHandler);
|
||||
/**
|
||||
* Creates a Zlib stream
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(cb?: FlateStreamHandler);
|
||||
/**
|
||||
* Pushes a chunk to be zlibbed
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the last chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
private p;
|
||||
}
|
||||
/**
|
||||
* Asynchronous streaming Zlib compression
|
||||
*/
|
||||
export declare class AsyncZlib {
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: AsyncFlateStreamHandler;
|
||||
/**
|
||||
* Creates an asynchronous DEFLATE stream
|
||||
* @param opts The compression options
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(opts: ZlibOptions, cb?: AsyncFlateStreamHandler);
|
||||
/**
|
||||
* Creates an asynchronous DEFLATE stream
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(cb?: AsyncFlateStreamHandler);
|
||||
/**
|
||||
* Pushes a chunk to be deflated
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the last chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
/**
|
||||
* A method to terminate the stream's internal worker. Subsequent calls to
|
||||
* push() will silently fail.
|
||||
*/
|
||||
terminate: AsyncTerminable;
|
||||
}
|
||||
/**
|
||||
* Asynchronously compresses data with Zlib
|
||||
* @param data The data to compress
|
||||
* @param opts The compression options
|
||||
* @param cb The function to be called upon compression completion
|
||||
*/
|
||||
export declare function zlib(data: Uint8Array, opts: AsyncZlibOptions, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Asynchronously compresses data with Zlib
|
||||
* @param data The data to compress
|
||||
* @param cb The function to be called upon compression completion
|
||||
* @returns A function that can be used to immediately terminate the compression
|
||||
*/
|
||||
export declare function zlib(data: Uint8Array, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Compress data with Zlib
|
||||
* @param data The data to compress
|
||||
* @param opts The compression options
|
||||
* @returns The zlib-compressed version of the data
|
||||
*/
|
||||
export declare function zlibSync(data: Uint8Array, opts?: ZlibOptions): Uint8Array;
|
||||
/**
|
||||
* Streaming Zlib decompression
|
||||
*/
|
||||
export declare class Unzlib {
|
||||
private v;
|
||||
private p;
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: FlateStreamHandler;
|
||||
/**
|
||||
* Creates a Zlib decompression stream
|
||||
* @param cb The callback to call whenever data is inflated
|
||||
*/
|
||||
constructor(cb?: FlateStreamHandler);
|
||||
/**
|
||||
* Pushes a chunk to be unzlibbed
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the last chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
}
|
||||
/**
|
||||
* Asynchronous streaming Zlib decompression
|
||||
*/
|
||||
export declare class AsyncUnzlib {
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: AsyncFlateStreamHandler;
|
||||
/**
|
||||
* Creates an asynchronous Zlib decompression stream
|
||||
* @param cb The callback to call whenever data is deflated
|
||||
*/
|
||||
constructor(cb?: AsyncFlateStreamHandler);
|
||||
/**
|
||||
* Pushes a chunk to be decompressed from Zlib
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the last chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
/**
|
||||
* A method to terminate the stream's internal worker. Subsequent calls to
|
||||
* push() will silently fail.
|
||||
*/
|
||||
terminate: AsyncTerminable;
|
||||
}
|
||||
/**
|
||||
* Asynchronously expands Zlib data
|
||||
* @param data The data to decompress
|
||||
* @param opts The decompression options
|
||||
* @param cb The function to be called upon decompression completion
|
||||
* @returns A function that can be used to immediately terminate the decompression
|
||||
*/
|
||||
export declare function unzlib(data: Uint8Array, opts: AsyncGunzipOptions, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Asynchronously expands Zlib data
|
||||
* @param data The data to decompress
|
||||
* @param cb The function to be called upon decompression completion
|
||||
* @returns A function that can be used to immediately terminate the decompression
|
||||
*/
|
||||
export declare function unzlib(data: Uint8Array, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Expands Zlib data
|
||||
* @param data The data to decompress
|
||||
* @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.
|
||||
* @returns The decompressed version of the data
|
||||
*/
|
||||
export declare function unzlibSync(data: Uint8Array, out?: Uint8Array): Uint8Array;
|
||||
export { gzip as compress, AsyncGzip as AsyncCompress };
|
||||
export { gzipSync as compressSync, Gzip as Compress };
|
||||
/**
|
||||
* Streaming GZIP, Zlib, or raw DEFLATE decompression
|
||||
*/
|
||||
export declare class Decompress {
|
||||
private G;
|
||||
private I;
|
||||
private Z;
|
||||
/**
|
||||
* Creates a decompression stream
|
||||
* @param cb The callback to call whenever data is decompressed
|
||||
*/
|
||||
constructor(cb?: FlateStreamHandler);
|
||||
private s;
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: FlateStreamHandler;
|
||||
private p;
|
||||
/**
|
||||
* Pushes a chunk to be decompressed
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the last chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
}
|
||||
/**
|
||||
* Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression
|
||||
*/
|
||||
export declare class AsyncDecompress {
|
||||
private G;
|
||||
private I;
|
||||
private Z;
|
||||
/**
|
||||
* Creates an asynchronous decompression stream
|
||||
* @param cb The callback to call whenever data is decompressed
|
||||
*/
|
||||
constructor(cb?: AsyncFlateStreamHandler);
|
||||
/**
|
||||
* The handler to call whenever data is available
|
||||
*/
|
||||
ondata: AsyncFlateStreamHandler;
|
||||
/**
|
||||
* Pushes a chunk to be decompressed
|
||||
* @param chunk The chunk to push
|
||||
* @param final Whether this is the last chunk
|
||||
*/
|
||||
push(chunk: Uint8Array, final?: boolean): void;
|
||||
}
|
||||
/**
|
||||
* Asynchrononously expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format
|
||||
* @param data The data to decompress
|
||||
* @param opts The decompression options
|
||||
* @param cb The function to be called upon decompression completion
|
||||
* @returns A function that can be used to immediately terminate the decompression
|
||||
*/
|
||||
export declare function decompress(data: Uint8Array, opts: AsyncInflateOptions, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Asynchrononously expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format
|
||||
* @param data The data to decompress
|
||||
* @param cb The function to be called upon decompression completion
|
||||
* @returns A function that can be used to immediately terminate the decompression
|
||||
*/
|
||||
export declare function decompress(data: Uint8Array, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format
|
||||
* @param data The data to decompress
|
||||
* @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.
|
||||
* @returns The decompressed version of the data
|
||||
*/
|
||||
export declare function decompressSync(data: Uint8Array, out?: Uint8Array): Uint8Array;
|
||||
/**
|
||||
* Options for creating a ZIP archive
|
||||
*/
|
||||
export interface ZipOptions extends DeflateOptions, Pick<GzipOptions, 'mtime'> {
|
||||
}
|
||||
/**
|
||||
* Options for asynchronously creating a ZIP archive
|
||||
*/
|
||||
export interface AsyncZipOptions extends AsyncDeflateOptions, Pick<AsyncGzipOptions, 'mtime'> {
|
||||
}
|
||||
/**
|
||||
* Options for asynchronously expanding a ZIP archive
|
||||
*/
|
||||
export interface AsyncUnzipOptions extends AsyncOptions {
|
||||
}
|
||||
/**
|
||||
* A file that can be used to create a ZIP archive
|
||||
*/
|
||||
export declare type ZippableFile = Uint8Array | [Uint8Array, ZipOptions];
|
||||
/**
|
||||
* A file that can be used to asynchronously create a ZIP archive
|
||||
*/
|
||||
export declare type AsyncZippableFile = Uint8Array | [Uint8Array, AsyncZipOptions];
|
||||
/**
|
||||
* The complete directory structure of a ZIPpable archive
|
||||
*/
|
||||
export interface Zippable extends Record<string, Zippable | ZippableFile> {
|
||||
}
|
||||
/**
|
||||
* The complete directory structure of an asynchronously ZIPpable archive
|
||||
*/
|
||||
export interface AsyncZippable extends Record<string, AsyncZippable | AsyncZippableFile> {
|
||||
}
|
||||
/**
|
||||
* An unzipped archive. The full path of each file is used as the key,
|
||||
* and the file is the value
|
||||
*/
|
||||
export interface Unzipped extends Record<string, Uint8Array> {
|
||||
}
|
||||
/**
|
||||
* Callback for asynchronous ZIP decompression
|
||||
* @param err Any error that occurred
|
||||
* @param data The decompressed ZIP archive
|
||||
*/
|
||||
export declare type UnzipCallback = (err: Error, data: Unzipped) => void;
|
||||
/**
|
||||
* Converts a string into a Uint8Array for use with compression/decompression methods
|
||||
* @param str The string to encode
|
||||
* @param latin1 Whether or not to interpret the data as Latin-1. This should
|
||||
* not need to be true unless decoding a binary string.
|
||||
* @returns The string encoded in UTF-8/Latin-1 binary
|
||||
*/
|
||||
export declare function strToU8(str: string, latin1?: boolean): Uint8Array;
|
||||
/**
|
||||
* Converts a Uint8Array to a string
|
||||
* @param dat The data to decode to string
|
||||
* @param latin1 Whether or not to interpret the data as Latin-1. This should
|
||||
* not need to be true unless encoding to binary string.
|
||||
* @returns The original UTF-8/Latin-1 string
|
||||
*/
|
||||
export declare function strFromU8(dat: Uint8Array, latin1?: boolean): string;
|
||||
/**
|
||||
* Asynchronously creates a ZIP file
|
||||
* @param data The directory structure for the ZIP archive
|
||||
* @param opts The main options, merged with per-file options
|
||||
* @param cb The callback to call with the generated ZIP archive
|
||||
* @returns A function that can be used to immediately terminate the compression
|
||||
*/
|
||||
export declare function zip(data: AsyncZippable, opts: AsyncZipOptions, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Asynchronously creates a ZIP file
|
||||
* @param data The directory structure for the ZIP archive
|
||||
* @param cb The callback to call with the generated ZIP archive
|
||||
* @returns A function that can be used to immediately terminate the compression
|
||||
*/
|
||||
export declare function zip(data: AsyncZippable, cb: FlateCallback): AsyncTerminable;
|
||||
/**
|
||||
* Synchronously creates a ZIP file. Prefer using `zip` for better performance
|
||||
* with more than one file.
|
||||
* @param data The directory structure for the ZIP archive
|
||||
* @param opts The main options, merged with per-file options
|
||||
* @returns The generated ZIP archive
|
||||
*/
|
||||
export declare function zipSync(data: Zippable, opts?: ZipOptions): Uint8Array;
|
||||
/**
|
||||
* Asynchronously decompresses a ZIP archive
|
||||
* @param data The raw compressed ZIP file
|
||||
* @param cb The callback to call with the decompressed files
|
||||
* @returns A function that can be used to immediately terminate the unzipping
|
||||
*/
|
||||
export declare function unzip(data: Uint8Array, cb: UnzipCallback): AsyncTerminable;
|
||||
/**
|
||||
* Synchronously decompresses a ZIP archive. Prefer using `unzip` for better
|
||||
* performance with more than one file.
|
||||
* @param data The raw compressed ZIP file
|
||||
* @returns The decompressed files
|
||||
*/
|
||||
export declare function unzipSync(data: Uint8Array): Unzipped;
|
||||
@@ -0,0 +1,131 @@
|
||||
import {Split} from './utilities';
|
||||
import {StringDigit} from '../source/utilities';
|
||||
|
||||
/**
|
||||
Like the `Get` type but receives an array of strings as a path parameter.
|
||||
*/
|
||||
type GetWithPath<BaseType, Keys extends readonly string[]> =
|
||||
Keys extends []
|
||||
? BaseType
|
||||
: Keys extends [infer Head, ...infer Tail]
|
||||
? GetWithPath<PropertyOf<BaseType, Extract<Head, string>>, Extract<Tail, string[]>>
|
||||
: never;
|
||||
|
||||
/**
|
||||
Splits a dot-prop style path into a tuple comprised of the properties in the path. Handles square-bracket notation.
|
||||
|
||||
@example
|
||||
```
|
||||
ToPath<'foo.bar.baz'>
|
||||
//=> ['foo', 'bar', 'baz']
|
||||
|
||||
ToPath<'foo[0].bar.baz'>
|
||||
//=> ['foo', '0', 'bar', 'baz']
|
||||
```
|
||||
*/
|
||||
type ToPath<S extends string> = Split<FixPathSquareBrackets<S>, '.'>;
|
||||
|
||||
/**
|
||||
Replaces square-bracketed dot notation with dots, for example, `foo[0].bar` -> `foo.0.bar`.
|
||||
*/
|
||||
type FixPathSquareBrackets<Path extends string> =
|
||||
Path extends `${infer Head}[${infer Middle}]${infer Tail}`
|
||||
? `${Head}.${Middle}${FixPathSquareBrackets<Tail>}`
|
||||
: Path;
|
||||
|
||||
/**
|
||||
Returns true if `LongString` is made up out of `Substring` repeated 0 or more times.
|
||||
|
||||
@example
|
||||
```
|
||||
ConsistsOnlyOf<'aaa', 'a'> //=> true
|
||||
ConsistsOnlyOf<'ababab', 'ab'> //=> true
|
||||
ConsistsOnlyOf<'aBa', 'a'> //=> false
|
||||
ConsistsOnlyOf<'', 'a'> //=> true
|
||||
```
|
||||
*/
|
||||
type ConsistsOnlyOf<LongString extends string, Substring extends string> =
|
||||
LongString extends ''
|
||||
? true
|
||||
: LongString extends `${Substring}${infer Tail}`
|
||||
? ConsistsOnlyOf<Tail, Substring>
|
||||
: false;
|
||||
|
||||
/**
|
||||
Convert a type which may have number keys to one with string keys, making it possible to index using strings retrieved from template types.
|
||||
|
||||
@example
|
||||
```
|
||||
type WithNumbers = {foo: string; 0: boolean};
|
||||
type WithStrings = WithStringKeys<WithNumbers>;
|
||||
|
||||
type WithNumbersKeys = keyof WithNumbers;
|
||||
//=> 'foo' | 0
|
||||
type WithStringsKeys = keyof WithStrings;
|
||||
//=> 'foo' | '0'
|
||||
```
|
||||
*/
|
||||
type WithStringKeys<BaseType extends Record<string | number, any>> = {
|
||||
[Key in `${Extract<keyof BaseType, string | number>}`]: BaseType[Key]
|
||||
};
|
||||
|
||||
/**
|
||||
Get a property of an object or array. Works when indexing arrays using number-literal-strings, for example, `PropertyOf<number[], '0'> = number`, and when indexing objects with number keys.
|
||||
|
||||
Note:
|
||||
- Returns `unknown` if `Key` is not a property of `BaseType`, since TypeScript uses structural typing, and it cannot be guaranteed that extra properties unknown to the type system will exist at runtime.
|
||||
- Returns `undefined` from nullish values, to match the behaviour of most deep-key libraries like `lodash`, `dot-prop`, etc.
|
||||
*/
|
||||
type PropertyOf<BaseType, Key extends string> =
|
||||
BaseType extends null | undefined
|
||||
? undefined
|
||||
: Key extends keyof BaseType
|
||||
? BaseType[Key]
|
||||
: BaseType extends {
|
||||
[n: number]: infer Item;
|
||||
length: number; // Note: This is needed to avoid being too lax with records types using number keys like `{0: string; 1: boolean}`.
|
||||
}
|
||||
? (
|
||||
ConsistsOnlyOf<Key, StringDigit> extends true
|
||||
? Item
|
||||
: unknown
|
||||
)
|
||||
: Key extends keyof WithStringKeys<BaseType>
|
||||
? WithStringKeys<BaseType>[Key]
|
||||
: unknown;
|
||||
|
||||
// This works by first splitting the path based on `.` and `[...]` characters into a tuple of string keys. Then it recursively uses the head key to get the next property of the current object, until there are no keys left. Number keys extract the item type from arrays, or are converted to strings to extract types from tuples and dictionaries with number keys.
|
||||
/**
|
||||
Get a deeply-nested property from an object using a key path, like Lodash's `.get()` function.
|
||||
|
||||
Use-case: Retrieve a property from deep inside an API response or some other complex object.
|
||||
|
||||
@example
|
||||
```
|
||||
import {Get} from 'type-fest';
|
||||
import * as lodash from 'lodash';
|
||||
|
||||
const get = <BaseType, Path extends string>(object: BaseType, path: Path): Get<BaseType, Path> =>
|
||||
lodash.get(object, path);
|
||||
|
||||
interface ApiResponse {
|
||||
hits: {
|
||||
hits: Array<{
|
||||
_id: string
|
||||
_source: {
|
||||
name: Array<{
|
||||
given: string[]
|
||||
family: string
|
||||
}>
|
||||
birthDate: string
|
||||
}
|
||||
}>
|
||||
}
|
||||
}
|
||||
|
||||
const getName = (apiResponse: ApiResponse) =>
|
||||
get(apiResponse, 'hits.hits[0]._source.name');
|
||||
//=> Array<{given: string[]; family: string}>
|
||||
```
|
||||
*/
|
||||
export type Get<BaseType, Path extends string> = GetWithPath<BaseType, ToPath<Path>>;
|
||||
@@ -0,0 +1,6 @@
|
||||
// Dart
|
||||
// By Theodoor van Donge
|
||||
|
||||
// https://chromiumcodereview.appspot.com/9232049/
|
||||
|
||||
Modernizr.addTest('dart', !!Modernizr.prefixed('startDart', navigator));
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"race.js","sources":["../../src/add/observable/race.ts"],"names":[],"mappings":";;AAAA,2CAAyC"}
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"1":"E F G A B","16":"J BC"},B:{"1":"C K L H M N O P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t"},C:{"16":"CC tB DC EC","129":"0 1 2 3 4 5 6 7 8 9 I u J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB"},D:{"1":"0 1 2 3 4 5 6 7 8 9 H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB FC","16":"I u J E F G A B C K L"},E:{"16":"I u GC zB","257":"J E F G A B C K L H HC IC JC KC 0B qB rB 1B LC MC 2B 3B 4B 5B sB 6B 7B 8B NC"},F:{"1":"0 1 2 3 4 5 6 7 8 9 B C H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d OC PC QC RC qB 9B SC rB","16":"G"},G:{"769":"F zB TC AC UC VC WC XC YC ZC aC bC cC dC eC fC gC hC iC jC kC lC mC 2B 3B 4B 5B sB 6B 7B 8B"},H:{"16":"nC"},I:{"16":"tB I D oC pC qC rC AC sC tC"},J:{"16":"E A"},K:{"1":"e","16":"A B C qB 9B rB"},L:{"1":"D"},M:{"1":"D"},N:{"16":"A B"},O:{"1":"uC"},P:{"16":"I vC wC xC yC zC 0B 0C 1C 2C 3C 4C sB 5C 6C 7C"},Q:{"1":"1B"},R:{"1":"8C"},S:{"129":"9C"}},B:1,C:"tabindex global attribute"};
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"2":"J E F G A B BC"},B:{"1":"T U V W X Y Z a b c d f g h i j k l m n o p q r s D t","2":"C K L H M N O P Q R S"},C:{"1":"fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB","2":"0 1 2 3 4 5 6 7 8 9 CC tB I u J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB DC EC"},D:{"1":"T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB FC","2":"0 1 2 3 4 5 6 7 8 9 I u J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R S"},E:{"1":"A B C K L H KC 0B qB rB 1B LC MC 2B 3B 4B 5B sB 6B 7B 8B NC","2":"I u J E F G GC zB HC IC JC"},F:{"1":"e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d","2":"0 1 2 3 4 5 6 7 8 9 G B C H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB OC PC QC RC qB 9B SC rB"},G:{"1":"ZC aC bC cC dC eC fC gC hC iC jC kC lC mC 2B 3B 4B 5B sB 6B 7B 8B","2":"F zB TC AC UC VC WC XC YC"},H:{"2":"nC"},I:{"1":"D","2":"tB I oC pC qC rC AC sC tC"},J:{"2":"E A"},K:{"1":"e","2":"A B C qB 9B rB"},L:{"1":"D"},M:{"1":"D"},N:{"2":"A B"},O:{"2":"uC"},P:{"1":"3C 4C sB 5C 6C 7C","2":"I vC wC xC yC zC 0B 0C 1C 2C"},Q:{"2":"1B"},R:{"1":"8C"},S:{"2":"9C"}},B:4,C:"CSS revert value"};
|
||||
@@ -0,0 +1,7 @@
|
||||
"use strict";
|
||||
function __export(m) {
|
||||
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
|
||||
}
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
__export(require("rxjs-compat/observable/from"));
|
||||
//# sourceMappingURL=from.js.map
|
||||
@@ -0,0 +1,10 @@
|
||||
import { Observable } from '../Observable';
|
||||
import { ConnectableObservable } from '../observable/ConnectableObservable';
|
||||
import { UnaryFunction } from '../types';
|
||||
/**
|
||||
* @param value
|
||||
* @return {ConnectableObservable<T>}
|
||||
* @method publishBehavior
|
||||
* @owner Observable
|
||||
*/
|
||||
export declare function publishBehavior<T>(value: T): UnaryFunction<Observable<T>, ConnectableObservable<T>>;
|
||||
@@ -0,0 +1,5 @@
|
||||
{
|
||||
"name": "es6-promise",
|
||||
"version": "1.0.0",
|
||||
"main": "./promise.js"
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
module.exports={A:{A:{"1":"G A B","2":"J E F BC"},B:{"1":"C K L H M N O P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t"},C:{"1":"0 1 2 3 4 5 6 7 8 9 G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB","2":"CC tB I u J E F DC EC"},D:{"1":"OB PB QB RB SB TB UB VB WB XB YB uB ZB vB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R S T U V W X Y Z a b c d f g h i j k l m n o p q r s D t xB yB FC","2":"0 1 2 3 4 5 6 7 8 9 I u J E F G A B C K L H M N O v w x y z AB BB CB DB EB FB GB HB IB JB KB LB MB NB"},E:{"1":"B C K L H qB rB 1B LC MC 2B 3B 4B 5B sB 6B 7B 8B NC","2":"I u J E F G A GC zB HC IC JC KC 0B"},F:{"1":"BB CB DB EB FB GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB ZB aB bB cB dB eB fB gB hB iB jB kB e lB mB nB oB pB P Q R wB S T U V W X Y Z a b c d","2":"0 1 2 3 4 5 6 7 8 9 G B C H M N O v w x y z AB OC PC QC RC qB 9B SC rB"},G:{"1":"bC cC dC eC fC gC hC iC jC kC lC mC 2B 3B 4B 5B sB 6B 7B 8B","2":"F zB TC AC UC VC WC XC YC ZC aC"},H:{"2":"nC"},I:{"1":"D","2":"tB I oC pC qC rC AC sC tC"},J:{"2":"E A"},K:{"1":"e","2":"A B C qB 9B rB"},L:{"1":"D"},M:{"1":"D"},N:{"1":"A B"},O:{"1":"uC"},P:{"1":"vC wC xC yC zC 0B 0C 1C 2C 3C 4C sB 5C 6C 7C","2":"I"},Q:{"1":"1B"},R:{"1":"8C"},S:{"1":"9C"}},B:2,C:"CSS font-stretch"};
|
||||
@@ -0,0 +1 @@
|
||||
import 'rxjs-compat/add/operator/combineAll';
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"throttleTime.js","sources":["../src/operator/throttleTime.ts"],"names":[],"mappings":";;;;;AAAA,uDAAkD"}
|
||||
Reference in New Issue
Block a user