@alexlit/lint-kit 186.2.2 → 186.3.0

package/packages/config-stylelint/node_modules/rxjs/src/LICENSE.txt

@@ -1,202 +0,0 @@
-                               Apache License
-                         Version 2.0, January 2004
-                      http://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
-    "License" shall mean the terms and conditions for use, reproduction,
-    and distribution as defined by Sections 1 through 9 of this document.
-
-    "Licensor" shall mean the copyright owner or entity authorized by
-    the copyright owner that is granting the License.
-
-    "Legal Entity" shall mean the union of the acting entity and all
-    other entities that control, are controlled by, or are under common
-    control with that entity. For the purposes of this definition,
-    "control" means (i) the power, direct or indirect, to cause the
-    direction or management of such entity, whether by contract or
-    otherwise, or (ii) ownership of fifty percent (50%) or more of the
-    outstanding shares, or (iii) beneficial ownership of such entity.
-
-    "You" (or "Your") shall mean an individual or Legal Entity
-    exercising permissions granted by this License.
-
-    "Source" form shall mean the preferred form for making modifications,
-    including but not limited to software source code, documentation
-    source, and configuration files.
-
-    "Object" form shall mean any form resulting from mechanical
-    transformation or translation of a Source form, including but
-    not limited to compiled object code, generated documentation,
-    and conversions to other media types.
-
-    "Work" shall mean the work of authorship, whether in Source or
-    Object form, made available under the License, as indicated by a
-    copyright notice that is included in or attached to the work
-    (an example is provided in the Appendix below).
-
-    "Derivative Works" shall mean any work, whether in Source or Object
-    form, that is based on (or derived from) the Work and for which the
-    editorial revisions, annotations, elaborations, or other modifications
-    represent, as a whole, an original work of authorship. For the purposes
-    of this License, Derivative Works shall not include works that remain
-    separable from, or merely link (or bind by name) to the interfaces of,
-    the Work and Derivative Works thereof.
-
-    "Contribution" shall mean any work of authorship, including
-    the original version of the Work and any modifications or additions
-    to that Work or Derivative Works thereof, that is intentionally
-    submitted to Licensor for inclusion in the Work by the copyright owner
-    or by an individual or Legal Entity authorized to submit on behalf of
-    the copyright owner. For the purposes of this definition, "submitted"
-    means any form of electronic, verbal, or written communication sent
-    to the Licensor or its representatives, including but not limited to
-    communication on electronic mailing lists, source code control systems,
-    and issue tracking systems that are managed by, or on behalf of, the
-    Licensor for the purpose of discussing and improving the Work, but
-    excluding communication that is conspicuously marked or otherwise
-    designated in writing by the copyright owner as "Not a Contribution."
-
-    "Contributor" shall mean Licensor and any individual or Legal Entity
-    on behalf of whom a Contribution has been received by Licensor and
-    subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
-    this License, each Contributor hereby grants to You a perpetual,
-    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-    copyright license to reproduce, prepare Derivative Works of,
-    publicly display, publicly perform, sublicense, and distribute the
-    Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
-    this License, each Contributor hereby grants to You a perpetual,
-    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-    (except as stated in this section) patent license to make, have made,
-    use, offer to sell, sell, import, and otherwise transfer the Work,
-    where such license applies only to those patent claims licensable
-    by such Contributor that are necessarily infringed by their
-    Contribution(s) alone or by combination of their Contribution(s)
-    with the Work to which such Contribution(s) was submitted. If You
-    institute patent litigation against any entity (including a
-    cross-claim or counterclaim in a lawsuit) alleging that the Work
-    or a Contribution incorporated within the Work constitutes direct
-    or contributory patent infringement, then any patent licenses
-    granted to You under this License for that Work shall terminate
-    as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
-    Work or Derivative Works thereof in any medium, with or without
-    modifications, and in Source or Object form, provided that You
-    meet the following conditions:
-
-    (a) You must give any other recipients of the Work or
-        Derivative Works a copy of this License; and
-
-    (b) You must cause any modified files to carry prominent notices
-        stating that You changed the files; and
-
-    (c) You must retain, in the Source form of any Derivative Works
-        that You distribute, all copyright, patent, trademark, and
-        attribution notices from the Source form of the Work,
-        excluding those notices that do not pertain to any part of
-        the Derivative Works; and
-
-    (d) If the Work includes a "NOTICE" text file as part of its
-        distribution, then any Derivative Works that You distribute must
-        include a readable copy of the attribution notices contained
-        within such NOTICE file, excluding those notices that do not
-        pertain to any part of the Derivative Works, in at least one
-        of the following places: within a NOTICE text file distributed
-        as part of the Derivative Works; within the Source form or
-        documentation, if provided along with the Derivative Works; or,
-        within a display generated by the Derivative Works, if and
-        wherever such third-party notices normally appear. The contents
-        of the NOTICE file are for informational purposes only and
-        do not modify the License. You may add Your own attribution
-        notices within Derivative Works that You distribute, alongside
-        or as an addendum to the NOTICE text from the Work, provided
-        that such additional attribution notices cannot be construed
-        as modifying the License.
-
-    You may add Your own copyright statement to Your modifications and
-    may provide additional or different license terms and conditions
-    for use, reproduction, or distribution of Your modifications, or
-    for any such Derivative Works as a whole, provided Your use,
-    reproduction, and distribution of the Work otherwise complies with
-    the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
-    any Contribution intentionally submitted for inclusion in the Work
-    by You to the Licensor shall be under the terms and conditions of
-    this License, without any additional terms or conditions.
-    Notwithstanding the above, nothing herein shall supersede or modify
-    the terms of any separate license agreement you may have executed
-    with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
-    names, trademarks, service marks, or product names of the Licensor,
-    except as required for reasonable and customary use in describing the
-    origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
-    agreed to in writing, Licensor provides the Work (and each
-    Contributor provides its Contributions) on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-    implied, including, without limitation, any warranties or conditions
-    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-    PARTICULAR PURPOSE. You are solely responsible for determining the
-    appropriateness of using or redistributing the Work and assume any
-    risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
-    whether in tort (including negligence), contract, or otherwise,
-    unless required by applicable law (such as deliberate and grossly
-    negligent acts) or agreed to in writing, shall any Contributor be
-    liable to You for damages, including any direct, indirect, special,
-    incidental, or consequential damages of any character arising as a
-    result of this License or out of the use or inability to use the
-    Work (including but not limited to damages for loss of goodwill,
-    work stoppage, computer failure or malfunction, or any and all
-    other commercial damages or losses), even if such Contributor
-    has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
-    the Work or Derivative Works thereof, You may choose to offer,
-    and charge a fee for, acceptance of support, warranty, indemnity,
-    or other liability obligations and/or rights consistent with this
-    License. However, in accepting such obligations, You may act only
-    on Your own behalf and on Your sole responsibility, not on behalf
-    of any other Contributor, and only if You agree to indemnify,
-    defend, and hold each Contributor harmless for any liability
-    incurred by, or claims asserted against, such Contributor by reason
-    of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
-
- APPENDIX: How to apply the Apache License to your work.
-
-    To apply the Apache License to your work, attach the following
-    boilerplate notice, with the fields enclosed by brackets "[]"
-    replaced with your own identifying information. (Don't include
-    the brackets!)  The text should be enclosed in the appropriate
-    comment syntax for the file format. We also recommend that a
-    file or class name and description of purpose be included on the
-    same "printed page" as the copyright notice for easier
-    identification within third-party archives.
-
- Copyright (c) 2015-2018 Google, Inc., Netflix, Inc., Microsoft Corp. and contributors
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
- 

package/packages/config-stylelint/node_modules/rxjs/src/MiscJSDoc.ts

@@ -1,451 +0,0 @@
-/*
- * This file and its definitions are needed just so that ESDoc sees these
- * JSDoc documentation comments. Originally they were meant for some TypeScript
- * interfaces, but TypeScript strips away JSDoc comments near interfaces. Hence,
- * we need these bogus classes, which are not stripped away. This file on the
- * other hand, is not included in the release bundle.
- */
-import { Observer, TeardownLogic } from './internal/types';
-import { Observable } from './internal/Observable';
-import './internal/observable/dom/MiscJSDoc';
-
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @extends {Ignored}
- * @hide true
- */
-export class ObservableDoc {
-  /**
-   * Creates a new Observable, that will execute the specified function when an
-   * {@link Observer} subscribes to it.
-   *
-   * <span class="informal">Create custom Observable, that does whatever you like.</span>
-   *
-   * ![](create.png)
-   *
-   * `create` converts an `onSubscription` function to an actual Observable.
-   * Whenever someone subscribes to that Observable, the function will be called
-   * with an {@link Observer} instance as a first and only parameter. `onSubscription` should
-   * then invoke the Observers `next`, `error` and `complete` methods.
-   *
-   * Calling `next` with a value will emit that value to the observer. Calling `complete`
-   * means that Observable finished emitting and will not do anything else.
-   * Calling `error` means that something went wrong - value passed to `error` method should
-   * provide details on what exactly happened.
-   *
-   * A well-formed Observable can emit as many values as it needs via `next` method,
-   * but `complete` and `error` methods can be called only once and nothing else can be called
-   * thereafter. If you try to invoke `next`, `complete` or `error` methods after created
-   * Observable already completed or ended with an error, these calls will be ignored to
-   * preserve so called *Observable Contract*. Note that you are not required to call
-   * `complete` at any point - it is perfectly fine to create an Observable that never ends,
-   * depending on your needs.
-   *
-   * `onSubscription` can optionally return either a function or an object with
-   * `unsubscribe` method. In both cases function or method will be called when
-   * subscription to Observable is being cancelled and should be used to clean up all
-   * resources. So, for example, if you are using `setTimeout` in your custom
-   * Observable, when someone unsubscribes, you can clear planned timeout, so that
-   * it does not fire needlessly and browser (or other environment) does not waste
-   * computing power on timing event that no one will listen to anyways.
-   *
-   * Most of the times you should not need to use `create`, because existing
-   * operators allow you to create an Observable for most of the use cases.
-   * That being said, `create` is low-level mechanism allowing you to create
-   * any Observable, if you have very specific needs.
-   *
-   * **TypeScript signature issue**
-   *
-   * Because Observable extends class which already has defined static `create` function,
-   * but with different type signature, it was impossible to assign proper signature to
-   * `Observable.create`. Because of that, it has very general type `Function` and thus
-   * function passed to `create` will not be type checked, unless you explicitly state
-   * what signature it should have.
-   *
-   * When using TypeScript we recommend to declare type signature of function passed to
-   * `create` as `(observer: Observer) => TeardownLogic`, where {@link Observer}
-   * and {@link TeardownLogic} are interfaces provided by the library.
-   *
-   * @example <caption>Emit three numbers, then complete.</caption>
-   * var observable = Rx.Observable.create(function (observer) {
-   *   observer.next(1);
-   *   observer.next(2);
-   *   observer.next(3);
-   *   observer.complete();
-   * });
-   * observable.subscribe(
-   *   value => console.log(value),
-   *   err => {},
-   *   () => console.log('this is the end')
-   * );
-   *
-   * // Logs
-   * // 1
-   * // 2
-   * // 3
-   * // "this is the end"
-   *
-   *
-   * @example <caption>Emit an error</caption>
-   * const observable = Rx.Observable.create((observer) => {
-   *   observer.error('something went really wrong...');
-   * });
-   *
-   * observable.subscribe(
-   *   value => console.log(value), // will never be called
-   *   err => console.log(err),
-   *   () => console.log('complete') // will never be called
-   * );
-   *
-   * // Logs
-   * // "something went really wrong..."
-   *
-   *
-   * @example <caption>Return unsubscribe function</caption>
-   *
-   * const observable = Rx.Observable.create(observer => {
-   *   const id = setTimeout(() => observer.next('...'), 5000); // emit value after 5s
-   *
-   *   return () => { clearTimeout(id); console.log('cleared!'); };
-   * });
-   *
-   * const subscription = observable.subscribe(value => console.log(value));
-   *
-   * setTimeout(() => subscription.unsubscribe(), 3000); // cancel subscription after 3s
-   *
-   * // Logs:
-   * // "cleared!" after 3s
-   *
-   * // Never logs "..."
-   *
-   *
-   * @see {@link empty}
-   * @see {@link never}
-   * @see {@link of}
-   * @see {@link throw}
-   *
-   * @param {function(observer: Observer): TeardownLogic} onSubscription A
-   * function that accepts an Observer, and invokes its `next`,
-   * `error`, and `complete` methods as appropriate, and optionally returns some
-   * logic for cleaning up resources.
-   * @return {Observable} An Observable that, whenever subscribed, will execute the
-   * specified function.
-   * @static true
-   * @name create
-   * @owner Observable
-   * @nocollapse
-   */
-  static create<T>(onSubscription: <R>(observer: Observer<R>) => TeardownLogic): Observable<T> {
-    return new Observable<T>(onSubscription);
-  }
-}
-
-/**
- * An interface for a consumer of push-based notifications delivered by an
- * {@link Observable}.
- *
- * ```ts
- * interface Observer<T> {
- *   closed?: boolean;
- *   next: (value: T) => void;
- *   error: (err: any) => void;
- *   complete: () => void;
- * }
- * ```
- *
- * An object conforming to the Observer interface is usually
- * given to the `observable.subscribe(observer)` method, and the Observable will
- * call the Observer's `next(value)` method to provide notifications. A
- * well-behaved Observable will call an Observer's `complete()` method exactly
- * once or the Observer's `error(err)` method exactly once, as the last
- * notification delivered.
- *
- * @interface
- * @name Observer
- * @noimport true
- */
-export class ObserverDoc<T> {
-  /**
-   * An optional flag to indicate whether this Observer, when used as a
-   * subscriber, has already been unsubscribed from its Observable.
-   * @type {boolean}
-   */
-  closed: boolean = false;
-  /**
-   * The callback to receive notifications of type `next` from the Observable,
-   * with a value. The Observable may call this method 0 or more times.
-   * @param {T} value The `next` value.
-   * @return {void}
-   */
-  next(value: T): void {
-    return void 0;
-  }
-  /**
-   * The callback to receive notifications of type `error` from the Observable,
-   * with an attached {@link Error}. Notifies the Observer that the Observable
-   * has experienced an error condition.
-   * @param {any} err The `error` exception.
-   * @return {void}
-   */
-  error(err: any): void {
-    return void 0;
-  }
-  /**
-   * The callback to receive a valueless notification of type `complete` from
-   * the Observable. Notifies the Observer that the Observable has finished
-   * sending push-based notifications.
-   * @return {void}
-   */
-  complete(): void {
-    return void 0;
-  }
-}
-
-/**
- * `SubscribableOrPromise` interface describes values that behave like either
- * Observables or Promises. Every operator that accepts arguments annotated
- * with this interface, can be also used with parameters that are not necessarily
- * RxJS Observables.
- *
- * Following types of values might be passed to operators expecting this interface:
- *
- * ## Observable
- *
- * RxJS {@link Observable} instance.
- *
- * ## Observable-like (Subscribable)
- *
- * This might be any object that has `Symbol.observable` method. This method,
- * when called, should return object with `subscribe` method on it, which should
- * behave the same as RxJS `Observable.subscribe`.
- *
- * `Symbol.observable` is part of https://github.com/tc39/proposal-observable proposal.
- * Since currently it is not supported natively, and every symbol is equal only to itself,
- * you should use https://github.com/blesh/symbol-observable polyfill, when implementing
- * custom Observable-likes.
- *
- * **TypeScript Subscribable interface issue**
- *
- * Although TypeScript interface claims that Subscribable is an object that has `subscribe`
- * method declared directly on it, passing custom objects that have `subscribe`
- * method but not `Symbol.observable` method will fail at runtime. Conversely, passing
- * objects with `Symbol.observable` but without `subscribe` will fail at compile time
- * (if you use TypeScript).
- *
- * TypeScript has problem supporting interfaces with methods defined as symbol
- * properties. To get around that, you should implement `subscribe` directly on
- * passed object, and make `Symbol.observable` method simply return `this`. That way
- * everything will work as expected, and compiler will not complain. If you really
- * do not want to put `subscribe` directly on your object, you will have to type cast
- * it to `any`, before passing it to an operator.
- *
- * When this issue is resolved, Subscribable interface will only permit Observable-like
- * objects with `Symbol.observable` defined, no matter if they themselves implement
- * `subscribe` method or not.
- *
- * ## ES6 Promise
- *
- * Promise can be interpreted as Observable that emits value and completes
- * when it is resolved or errors when it is rejected.
- *
- * ## Promise-like (Thenable)
- *
- * Promises passed to operators do not have to be native ES6 Promises.
- * They can be implementations from popular Promise libraries, polyfills
- * or even custom ones. They just need to have `then` method that works
- * as the same as ES6 Promise `then`.
- *
- * @example <caption>Use merge and then map with non-RxJS observable</caption>
- * const nonRxJSObservable = {
- *   subscribe(observer) {
- *     observer.next(1000);
- *     observer.complete();
- *   },
- *   [Symbol.observable]() {
- *     return this;
- *   }
- * };
- *
- * Rx.Observable.merge(nonRxJSObservable)
- * .map(value => "This value is " + value)
- * .subscribe(result => console.log(result)); // Logs "This value is 1000"
- *
- *
- * @example <caption>Use combineLatest with ES6 Promise</caption>
- * Rx.Observable.combineLatest(Promise.resolve(5), Promise.resolve(10), Promise.resolve(15))
- * .subscribe(
- *   value => console.log(value),
- *   err => {},
- *   () => console.log('the end!')
- * );
- * // Logs
- * // [5, 10, 15]
- * // "the end!"
- *
- *
- * @interface
- * @name SubscribableOrPromise
- * @noimport true
- */
-export class SubscribableOrPromiseDoc<T> {
-
-}
-
-/**
- * `ObservableInput` interface describes all values that are either an
- * {@link SubscribableOrPromise} or some kind of collection of values that
- * can be transformed to Observable emitting that values. Every operator that
- * accepts arguments annotated with this interface, can be also used with
- * parameters that are not necessarily RxJS Observables.
- *
- * `ObservableInput` extends {@link SubscribableOrPromise} with following types:
- *
- * ## Array
- *
- * Arrays can be interpreted as observables that emit all values in array one by one,
- * from left to right, and then complete immediately.
- *
- * ## Array-like
- *
- * Arrays passed to operators do not have to be built-in JavaScript Arrays. They
- * can be also, for example, `arguments` property available inside every function,
- * [DOM NodeList](https://developer.mozilla.org/pl/docs/Web/API/NodeList),
- * or, actually, any object that has `length` property (which is a number)
- * and stores values under non-negative (zero and up) integers.
- *
- * ## ES6 Iterable
- *
- * Operators will accept both built-in and custom ES6 Iterables, by treating them as
- * observables that emit all its values in order of iteration and then complete
- * when iteration ends. Note that contrary to arrays, Iterables do not have to
- * necessarily be finite, so creating Observables that never complete is possible as well.
- *
- * Note that you can make iterator an instance of Iterable by having it return itself
- * in `Symbol.iterator` method. It means that every operator accepting Iterables accepts,
- * though indirectly, iterators themselves as well. All native ES6 iterators are instances
- * of Iterable by default, so you do not have to implement their `Symbol.iterator` method
- * yourself.
- *
- * **TypeScript Iterable interface issue**
- *
- * TypeScript `ObservableInput` interface actually lacks type signature for Iterables,
- * because of issues it caused in some projects (see [this issue](https://github.com/ReactiveX/rxjs/issues/2306)).
- * If you want to use Iterable as argument for operator, cast it to `any` first.
- * Remember of course that, because of casting, you have to yourself ensure that passed
- * argument really implements said interface.
- *
- *
- * @example <caption>Use merge with arrays</caption>
- * Rx.Observable.merge([1, 2], [4], [5, 6])
- * .subscribe(
- *   value => console.log(value),
- *   err => {},
- *   () => console.log('ta dam!')
- * );
- *
- * // Logs
- * // 1
- * // 2
- * // 3
- * // 4
- * // 5
- * // 6
- * // "ta dam!"
- *
- *
- * @example <caption>Use merge with array-like</caption>
- * Rx.Observable.merge({0: 1, 1: 2, length: 2}, {0: 3, length: 1})
- * .subscribe(
- *   value => console.log(value),
- *   err => {},
- *   () => console.log('nice, huh?')
- * );
- *
- * // Logs
- * // 1
- * // 2
- * // 3
- * // "nice, huh?"
- *
- * @example <caption>Use merge with an Iterable (Map)</caption>
- * const firstMap = new Map([[1, 'a'], [2, 'b']]);
- * const secondMap = new Map([[3, 'c'], [4, 'd']]);
- *
- * Rx.Observable.merge(
- *   firstMap,          // pass Iterable
- *   secondMap.values() // pass iterator, which is itself an Iterable
- * ).subscribe(
- *   value => console.log(value),
- *   err => {},
- *   () => console.log('yup!')
- * );
- *
- * // Logs
- * // [1, "a"]
- * // [2, "b"]
- * // "c"
- * // "d"
- * // "yup!"
- *
- * @example <caption>Use from with generator (returning infinite iterator)</caption>
- * // infinite stream of incrementing numbers
- * const infinite = function* () {
- *   let i = 0;
- *
- *   while (true) {
- *     yield i++;
- *   }
- * };
- *
- * Rx.Observable.from(infinite())
- * .take(3) // only take 3, cause this is infinite
- * .subscribe(
- *   value => console.log(value),
- *   err => {},
- *   () => console.log('ta dam!')
- * );
- *
- * // Logs
- * // 0
- * // 1
- * // 2
- * // "ta dam!"
- *
- * @interface
- * @name ObservableInput
- * @noimport true
- */
-export class ObservableInputDoc<T> {
-
-}
-
-/**
- *
- * This interface describes what should be returned by function passed to Observable
- * constructor or static {@link create} function. Value of that interface will be used
- * to cancel subscription for given Observable.
- *
- * `TeardownLogic` can be:
- *
- * ## Function
- *
- * Function that takes no parameters. When consumer of created Observable calls `unsubscribe`,
- * that function will be called
- *
- * ## AnonymousSubscription
- *
- * `AnonymousSubscription` is simply an object with `unsubscribe` method on it. That method
- * will work the same as function
- *
- * ## void
- *
- * If created Observable does not have any resources to clean up, function does not have to
- * return anything.
- *
- * @interface
- * @name TeardownLogic
- * @noimport true
- */
-export class TeardownLogicDoc {
-
-}

package/packages/config-stylelint/node_modules/rxjs/src/Notification.ts

@@ -1 +0,0 @@
-export * from 'rxjs-compat/Notification';

package/packages/config-stylelint/node_modules/rxjs/src/Observable.ts

@@ -1 +0,0 @@
-export * from 'rxjs-compat/Observable';

package/packages/config-stylelint/node_modules/rxjs/src/Observer.ts

@@ -1 +0,0 @@
-export * from 'rxjs-compat/Observer';

package/packages/config-stylelint/node_modules/rxjs/src/Operator.ts

@@ -1 +0,0 @@
-export * from 'rxjs-compat/Operator';

package/packages/config-stylelint/node_modules/rxjs/src/OuterSubscriber.ts

@@ -1 +0,0 @@
-export * from 'rxjs-compat/OuterSubscriber';