subscribable-things - npm Package Compare versions

Comparing version 2.1.9 to 2.1.10

build/es2019/types/animation-frame-factory.d.ts

@@ -5,3 +5,3 @@ import { TAnimationFrameFunction } from './animation-frame-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TAnimationFrameFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TAnimationFrameFunction;
+export type TAnimationFrameFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TAnimationFrameFunction;
 //# sourceMappingURL=animation-frame-factory.d.ts.map

build/es2019/types/animation-frame-function.d.ts

 import { TSubscribableThing } from './subscribable-thing';
-export declare type TAnimationFrameFunction = () => TSubscribableThing<number>;
+export type TAnimationFrameFunction = () => TSubscribableThing<number>;
 //# sourceMappingURL=animation-frame-function.d.ts.map

build/es2019/types/emit-not-supported-error-function.d.ts

 import { Observer } from 'rxjs-interop';
 import { TUnsubscribeFunction } from './unsubscribe-function';
-export declare type TEmitNotSupportedErrorFunction = (observer: Observer<any>) => TUnsubscribeFunction;
+export type TEmitNotSupportedErrorFunction = (observer: Observer<any>) => TUnsubscribeFunction;
 //# sourceMappingURL=emit-not-supported-error-function.d.ts.map

build/es2019/types/event-handler.d.ts

@@ -1,4 +0,4 @@
-export declare type TEventHandler<T, U extends Event = Event> = (ThisType<T> & {
+export type TEventHandler<T, U extends Event = Event> = (ThisType<T> & {
     handler(event: U): void;
 })['handler'];
 //# sourceMappingURL=event-handler.d.ts.map

build/es2019/types/event-target-with-property-handler.d.ts

 import { TEventHandler } from './event-handler';
-export declare type TEventTargetWithPropertyHandler<T extends EventTarget, U extends string, V extends Event> = {
+export type TEventTargetWithPropertyHandler<T extends EventTarget, U extends string, V extends Event> = {
     [P in U as `on${P}`]: null | TEventHandler<T, V>;
 };
 //# sourceMappingURL=event-target-with-property-handler.d.ts.map

build/es2019/types/event-type.d.ts

 import { TEventTargetWithPropertyHandler } from './event-target-with-property-handler';
-export declare type TEventType<T extends EventTarget, U extends string> = T extends TEventTargetWithPropertyHandler<T, U, infer V> ? V : Event;
+export type TEventType<T extends EventTarget, U extends string> = T extends TEventTargetWithPropertyHandler<T, U, infer V> ? V : Event;
 //# sourceMappingURL=event-type.d.ts.map

build/es2019/types/flexible-subscribe-function.d.ts

 import { TObserverParameters } from './observer-parameters';
 import { TUnsubscribeFunction } from './unsubscribe-function';
-export declare type TFlexibleSubscribeFunction<T> = (...args: TObserverParameters<T>) => TUnsubscribeFunction;
+export type TFlexibleSubscribeFunction<T> = (...args: TObserverParameters<T>) => TUnsubscribeFunction;
 //# sourceMappingURL=flexible-subscribe-function.d.ts.map

build/es2019/types/intersections-factory.d.ts

@@ -5,3 +5,3 @@ import { TEmitNotSupportedErrorFunction } from './emit-not-supported-error-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TIntersectionsFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TIntersectionsFunction;
+export type TIntersectionsFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TIntersectionsFunction;
 //# sourceMappingURL=intersections-factory.d.ts.map

build/es2019/types/intersections-function.d.ts

 import { TSubscribableThing } from './subscribable-thing';
-export declare type TIntersectionsFunction = (htmlElement: HTMLElement, options?: IntersectionObserverInit) => TSubscribableThing<IntersectionObserverEntry[]>;
+export type TIntersectionsFunction = (htmlElement: HTMLElement, options?: IntersectionObserverInit) => TSubscribableThing<IntersectionObserverEntry[]>;
 //# sourceMappingURL=intersections-function.d.ts.map

build/es2019/types/media-devices-factory.d.ts

@@ -5,3 +5,3 @@ import { TEmitNotSupportedErrorFunction } from './emit-not-supported-error-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TMediaDevicesFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TMediaDevicesFunction;
+export type TMediaDevicesFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TMediaDevicesFunction;
 //# sourceMappingURL=media-devices-factory.d.ts.map

build/es2019/types/media-devices-function.d.ts

 import { TSubscribableThing } from './subscribable-thing';
-export declare type TMediaDevicesFunction = () => TSubscribableThing<MediaDeviceInfo[]>;
+export type TMediaDevicesFunction = () => TSubscribableThing<MediaDeviceInfo[]>;
 //# sourceMappingURL=media-devices-function.d.ts.map

build/es2019/types/media-query-match-factory.d.ts

@@ -5,3 +5,3 @@ import { TEmitNotSupportedErrorFunction } from './emit-not-supported-error-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TMediaQueryMatchFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TMediaQueryMatchFunction;
+export type TMediaQueryMatchFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TMediaQueryMatchFunction;
 //# sourceMappingURL=media-query-match-factory.d.ts.map

build/es2019/types/media-query-match-function.d.ts

 import { TSubscribableThing } from './subscribable-thing';
-export declare type TMediaQueryMatchFunction = (mediaQueryString: string) => TSubscribableThing<boolean>;
+export type TMediaQueryMatchFunction = (mediaQueryString: string) => TSubscribableThing<boolean>;
 //# sourceMappingURL=media-query-match-function.d.ts.map

build/es2019/types/metrics-factory.d.ts

@@ -5,3 +5,3 @@ import { TEmitNotSupportedErrorFunction } from './emit-not-supported-error-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TMetricsFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TMetricsFunction;
+export type TMetricsFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TMetricsFunction;
 //# sourceMappingURL=metrics-factory.d.ts.map

build/es2019/types/metrics-function.d.ts

 import { TSubscribableThing } from './subscribable-thing';
-export declare type TMetricsFunction = (options: PerformanceObserverInit) => TSubscribableThing<PerformanceEntry[]>;
+export type TMetricsFunction = (options: PerformanceObserverInit) => TSubscribableThing<PerformanceEntry[]>;
 //# sourceMappingURL=metrics-function.d.ts.map

build/es2019/types/midi-connection-event-handler.d.ts

 import { IMidiConnectionEvent, IMidiPort } from '../interfaces';
 import { TEventHandler } from './event-handler';
-export declare type TMidiConnectionEventHandler<T extends IMidiPort> = TEventHandler<T, IMidiConnectionEvent<T>>;
+export type TMidiConnectionEventHandler<T extends IMidiPort> = TEventHandler<T, IMidiConnectionEvent<T>>;
 //# sourceMappingURL=midi-connection-event-handler.d.ts.map

build/es2019/types/midi-inputs-factory.d.ts

 import { TMidiInputsFunction } from './midi-inputs-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TMidiInputsFactory = (wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TMidiInputsFunction;
+export type TMidiInputsFactory = (wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TMidiInputsFunction;
 //# sourceMappingURL=midi-inputs-factory.d.ts.map

build/es2019/types/midi-inputs-function.d.ts

 import { IMidiAccess, IMidiInput } from '../interfaces';
 import { TSubscribableThing } from './subscribable-thing';
-export declare type TMidiInputsFunction = (midiAccess: IMidiAccess) => TSubscribableThing<IMidiInput[]>;
+export type TMidiInputsFunction = (midiAccess: IMidiAccess) => TSubscribableThing<IMidiInput[]>;
 //# sourceMappingURL=midi-inputs-function.d.ts.map

build/es2019/types/midi-message-event-handler.d.ts

 import { IMidiMessageEvent } from '../interfaces';
 import { TEventHandler } from './event-handler';
-export declare type TMidiMessageEventHandler<T> = TEventHandler<T, IMidiMessageEvent>;
+export type TMidiMessageEventHandler<T> = TEventHandler<T, IMidiMessageEvent>;
 //# sourceMappingURL=midi-message-event-handler.d.ts.map

build/es2019/types/midi-outputs-factory.d.ts

 import { TMidiOutputsFunction } from './midi-outputs-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TMidiOutputsFactory = (wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TMidiOutputsFunction;
+export type TMidiOutputsFactory = (wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TMidiOutputsFunction;
 //# sourceMappingURL=midi-outputs-factory.d.ts.map

build/es2019/types/midi-outputs-function.d.ts

 import { IMidiAccess, IMidiOutput } from '../interfaces';
 import { TSubscribableThing } from './subscribable-thing';
-export declare type TMidiOutputsFunction = (midiAccess: IMidiAccess) => TSubscribableThing<IMidiOutput[]>;
+export type TMidiOutputsFunction = (midiAccess: IMidiAccess) => TSubscribableThing<IMidiOutput[]>;
 //# sourceMappingURL=midi-outputs-function.d.ts.map

build/es2019/types/midi-port-connection-state.d.ts

@@ -1,2 +0,2 @@
-export declare type TMidiPortConnectionState = 'closed' | 'open' | 'pending';
+export type TMidiPortConnectionState = 'closed' | 'open' | 'pending';
 //# sourceMappingURL=midi-port-connection-state.d.ts.map

build/es2019/types/midi-port-device-state.d.ts

@@ -1,2 +0,2 @@
-export declare type TMidiPortDeviceState = 'connected' | 'disconnected';
+export type TMidiPortDeviceState = 'connected' | 'disconnected';
 //# sourceMappingURL=midi-port-device-state.d.ts.map

build/es2019/types/midi-port-type.d.ts

@@ -1,2 +0,2 @@
-export declare type TMidiPortType = 'input' | 'output';
+export type TMidiPortType = 'input' | 'output';
 //# sourceMappingURL=midi-port-type.d.ts.map

build/es2019/types/mutations-factory.d.ts

@@ -5,3 +5,3 @@ import { TEmitNotSupportedErrorFunction } from './emit-not-supported-error-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TMutationsFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TMutationsFunction;
+export type TMutationsFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TMutationsFunction;
 //# sourceMappingURL=mutations-factory.d.ts.map

build/es2019/types/mutations-function.d.ts

 import { TSubscribableThing } from './subscribable-thing';
-export declare type TMutationsFunction = (htmlElement: HTMLElement, options: MutationObserverInit) => TSubscribableThing<MutationRecord[]>;
+export type TMutationsFunction = (htmlElement: HTMLElement, options: MutationObserverInit) => TSubscribableThing<MutationRecord[]>;
 //# sourceMappingURL=mutations-function.d.ts.map

build/es2019/types/observer-parameters.d.ts

 import { Observer, Subscribable } from 'rxjs-interop';
-export declare type TObserverParameters<T> = Parameters<Subscribable<T>['subscribe']> | [Observer<T>['next']];
+export type TObserverParameters<T> = Parameters<Subscribable<T>['subscribe']> | [Observer<T>['next']];
 //# sourceMappingURL=observer-parameters.d.ts.map

build/es2019/types/on-factory.d.ts

 import { TOnFunction } from './on-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TOnFactory = (wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TOnFunction;
+export type TOnFactory = (wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TOnFunction;
 //# sourceMappingURL=on-factory.d.ts.map

build/es2019/types/on-function.d.ts

 import { TEventType } from './event-type';
 import { TSubscribableThing } from './subscribable-thing';
-export declare type TOnFunction = <T extends EventTarget, U extends string>(target: T, type: U, options?: boolean | AddEventListenerOptions) => TSubscribableThing<TEventType<T, U>>;
+export type TOnFunction = <T extends EventTarget, U extends string>(target: T, type: U, options?: boolean | AddEventListenerOptions) => TSubscribableThing<TEventType<T, U>>;
 //# sourceMappingURL=on-function.d.ts.map

build/es2019/types/online-factory.d.ts

@@ -5,3 +5,3 @@ import { TEmitNotSupportedErrorFunction } from './emit-not-supported-error-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TOnlineFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TOnlineFunction;
+export type TOnlineFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TOnlineFunction;
 //# sourceMappingURL=online-factory.d.ts.map

build/es2019/types/online-function.d.ts

 import { TSubscribableThing } from './subscribable-thing';
-export declare type TOnlineFunction = () => TSubscribableThing<boolean>;
+export type TOnlineFunction = () => TSubscribableThing<boolean>;
 //# sourceMappingURL=online-function.d.ts.map

build/es2019/types/optional-unsubscribe-function.d.ts

 import { TUnsubscribeFunction } from './unsubscribe-function';
-export declare type TOptionalUnsubscribeFunction = void | TUnsubscribeFunction;
+export type TOptionalUnsubscribeFunction = void | TUnsubscribeFunction;
 //# sourceMappingURL=optional-unsubscribe-function.d.ts.map

build/es2019/types/permission-state-factory.d.ts

@@ -5,3 +5,3 @@ import { TEmitNotSupportedErrorFunction } from './emit-not-supported-error-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TPermissionStateFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TPermissionStateFunction;
+export type TPermissionStateFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TPermissionStateFunction;
 //# sourceMappingURL=permission-state-factory.d.ts.map

build/es2019/types/permission-state-function.d.ts

 import { TSubscribableThing } from './subscribable-thing';
-export declare type TPermissionStateFunction = (...args: Parameters<Permissions['query']>) => TSubscribableThing<PermissionState>;
+export type TPermissionStateFunction = (...args: Parameters<Permissions['query']>) => TSubscribableThing<PermissionState>;
 //# sourceMappingURL=permission-state-function.d.ts.map

build/es2019/types/release-event-handler.d.ts

 import { TEventHandler } from './event-handler';
-export declare type TReleaseEventHandler<T> = TEventHandler<T, Event>;
+export type TReleaseEventHandler<T> = TEventHandler<T, Event>;
 //# sourceMappingURL=release-event-handler.d.ts.map

build/es2019/types/reports-factory.d.ts

@@ -5,3 +5,3 @@ import { TEmitNotSupportedErrorFunction } from './emit-not-supported-error-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TReportsFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TReportsFunction;
+export type TReportsFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TReportsFunction;
 //# sourceMappingURL=reports-factory.d.ts.map

build/es2019/types/reports-function.d.ts

 import { IReport, IReportingObserverOptions } from '../interfaces';
 import { TSubscribableThing } from './subscribable-thing';
-export declare type TReportsFunction = (options?: IReportingObserverOptions) => TSubscribableThing<IReport[]>;
+export type TReportsFunction = (options?: IReportingObserverOptions) => TSubscribableThing<IReport[]>;
 //# sourceMappingURL=reports-function.d.ts.map

build/es2019/types/resize-observer-box-options.d.ts

@@ -1,2 +0,2 @@
-export declare type TResizeObserverBoxOptions = 'border-box' | 'content-box' | 'device-pixel-content-box';
+export type TResizeObserverBoxOptions = 'border-box' | 'content-box' | 'device-pixel-content-box';
 //# sourceMappingURL=resize-observer-box-options.d.ts.map

build/es2019/types/resizes-factory.d.ts

@@ -5,3 +5,3 @@ import { TEmitNotSupportedErrorFunction } from './emit-not-supported-error-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TResizesFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TResizesFunction;
+export type TResizesFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TResizesFunction;
 //# sourceMappingURL=resizes-factory.d.ts.map

build/es2019/types/resizes-function.d.ts

 import { IResizeObserverEntry, IResizeObserverOptions } from '../interfaces';
 import { TSubscribableThing } from './subscribable-thing';
-export declare type TResizesFunction = (htmlElement: HTMLElement, options?: IResizeObserverOptions) => TSubscribableThing<IResizeObserverEntry[]>;
+export type TResizesFunction = (htmlElement: HTMLElement, options?: IResizeObserverOptions) => TSubscribableThing<IResizeObserverEntry[]>;
 //# sourceMappingURL=resizes-function.d.ts.map

build/es2019/types/subscribable-thing.d.ts

 import { InteropObservable } from 'rxjs-interop';
 import { TFlexibleSubscribeFunction } from './flexible-subscribe-function';
-export declare type TSubscribableThing<T> = InteropObservable<T> & TFlexibleSubscribeFunction<T>;
+export type TSubscribableThing<T> = InteropObservable<T> & TFlexibleSubscribeFunction<T>;
 //# sourceMappingURL=subscribable-thing.d.ts.map

build/es2019/types/subscribe-function.d.ts

 import { Observer } from 'rxjs-interop';
 import { TOptionalUnsubscribeFunction } from './optional-unsubscribe-function';
-export declare type TSubscribeFunction<T> = (observer: Observer<T>) => TOptionalUnsubscribeFunction;
+export type TSubscribeFunction<T> = (observer: Observer<T>) => TOptionalUnsubscribeFunction;
 //# sourceMappingURL=subscribe-function.d.ts.map

build/es2019/types/unhandled-rejection-factory.d.ts

@@ -5,3 +5,3 @@ import { TEmitNotSupportedErrorFunction } from './emit-not-supported-error-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TUnhandledRejectionFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TUnhandledRejectionFunction;
+export type TUnhandledRejectionFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TUnhandledRejectionFunction;
 //# sourceMappingURL=unhandled-rejection-factory.d.ts.map

build/es2019/types/unhandled-rejection-function.d.ts

 import { TSubscribableThing } from './subscribable-thing';
-export declare type TUnhandledRejectionFunction = (coolingOffPeriod: number) => TSubscribableThing<any>;
+export type TUnhandledRejectionFunction = (coolingOffPeriod: number) => TSubscribableThing<any>;
 //# sourceMappingURL=unhandled-rejection-function.d.ts.map

build/es2019/types/unsubscribe-function.d.ts

@@ -1,2 +0,2 @@
-export declare type TUnsubscribeFunction = () => void;
+export type TUnsubscribeFunction = () => void;
 //# sourceMappingURL=unsubscribe-function.d.ts.map

build/es2019/types/video-frame-factory.d.ts

 import { TEmitNotSupportedErrorFunction } from './emit-not-supported-error-function';
 import { TVideoFrameFunction } from './video-frame-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TVideoFrameFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TVideoFrameFunction;
+export type TVideoFrameFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TVideoFrameFunction;
 //# sourceMappingURL=video-frame-factory.d.ts.map

build/es2019/types/video-frame-function.d.ts

 import { IHTMLVideoElement, IVideoFrameMetadata } from '../interfaces';
 import { TSubscribableThing } from './subscribable-thing';
-export declare type TVideoFrameFunction = (videoElement: IHTMLVideoElement) => TSubscribableThing<{
+export type TVideoFrameFunction = (videoElement: IHTMLVideoElement) => TSubscribableThing<{
     now: number;
 } & IVideoFrameMetadata>;
 //# sourceMappingURL=video-frame-function.d.ts.map

build/es2019/types/video-frame-request-callback.d.ts

 import { IVideoFrameMetadata } from '../interfaces';
-export declare type TVideoFrameRequestCallback = (now: number, metadata: IVideoFrameMetadata) => void;
+export type TVideoFrameRequestCallback = (now: number, metadata: IVideoFrameMetadata) => void;
 //# sourceMappingURL=video-frame-request-callback.d.ts.map

build/es2019/types/wake-lock-factory.d.ts

@@ -5,3 +5,3 @@ import { TEmitNotSupportedErrorFunction } from './emit-not-supported-error-function';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TWakeLockFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TWakeLockFunction;
+export type TWakeLockFactory = (emitNotSupportedError: TEmitNotSupportedErrorFunction, window: null | TWindow, wrapSubscribeFunction: TWrapSubscribeFunctionFunction) => TWakeLockFunction;
 //# sourceMappingURL=wake-lock-factory.d.ts.map

build/es2019/types/wake-lock-function.d.ts

 import { TSubscribableThing } from './subscribable-thing';
 import { TWakeLockType } from './wake-lock-type';
-export declare type TWakeLockFunction = (type: TWakeLockType) => TSubscribableThing<boolean>;
+export type TWakeLockFunction = (type: TWakeLockType) => TSubscribableThing<boolean>;
 //# sourceMappingURL=wake-lock-function.d.ts.map

build/es2019/types/wake-lock-type.d.ts

@@ -1,2 +0,2 @@
-export declare type TWakeLockType = 'screen';
+export type TWakeLockType = 'screen';
 //# sourceMappingURL=wake-lock-type.d.ts.map

build/es2019/types/window-factory.d.ts

 import { TWindow } from './window';
-export declare type TWindowFactory = () => null | TWindow;
+export type TWindowFactory = () => null | TWindow;
 //# sourceMappingURL=window-factory.d.ts.map

build/es2019/types/window.d.ts

 import { IReport, IReportingObserver, IReportingObserverOptions, IResizeObserver, IResizeObserverEntry, IWakeLock } from '../interfaces';
-export declare type TWindow = Window & typeof globalThis & {
+export type TWindow = Window & typeof globalThis & {
     readonly navigator: Navigator & {
@@ -4,0 +4,0 @@ wakeLock: IWakeLock;

build/es2019/types/wrap-subscribe-function-factory.d.ts

 import { patch as patchFunction, toObserver as toObserverFunction } from 'rxjs-interop';
 import { TWrapSubscribeFunctionFunction } from './wrap-subscribe-function-function';
-export declare type TWrapSubscribeFunctionFactory = (patch: typeof patchFunction, toObserver: typeof toObserverFunction) => TWrapSubscribeFunctionFunction;
+export type TWrapSubscribeFunctionFactory = (patch: typeof patchFunction, toObserver: typeof toObserverFunction) => TWrapSubscribeFunctionFunction;
 //# sourceMappingURL=wrap-subscribe-function-factory.d.ts.map

build/es2019/types/wrap-subscribe-function-function.d.ts

 import { TSubscribableThing } from './subscribable-thing';
 import { TSubscribeFunction } from './subscribe-function';
-export declare type TWrapSubscribeFunctionFunction = <T>(innerSubscribe: TSubscribeFunction<T>) => TSubscribableThing<T>;
+export type TWrapSubscribeFunctionFunction = <T>(innerSubscribe: TSubscribeFunction<T>) => TSubscribableThing<T>;
 //# sourceMappingURL=wrap-subscribe-function-function.d.ts.map

package.json

@@ -28,4 +28,4 @@ {
         "@babel/preset-env": "^7.20.2",
-        "@commitlint/cli": "^17.2.0",
-        "@commitlint/config-angular": "^17.2.0",
+        "@commitlint/cli": "^17.3.0",
+        "@commitlint/config-angular": "^17.3.0",
         "@rollup/plugin-babel": "^5.3.1",
@@ -35,6 +35,6 @@ "baconjs": "^3.0.17",
         "callbag-basics": "^4.0.0",
-        "chai": "^4.3.6",
+        "chai": "^4.3.7",
         "commitizen": "^4.2.5",
         "cz-conventional-changelog": "^3.3.0",
-        "eslint": "^8.26.0",
+        "eslint": "^8.28.0",
         "eslint-config-holy-grail": "^52.0.33",
@@ -44,3 +44,3 @@ "grunt": "^1.5.3",
         "grunt-sh": "^0.2.0",
-        "husky": "^8.0.1",
+        "husky": "^8.0.2",
         "hyperf": "^1.4.0",
@@ -65,3 +65,3 @@ "karma": "^6.4.1",
         "rxjs-for-await": "^1.0.0",
-        "sinon": "^14.0.1",
+        "sinon": "^14.0.2",
         "sinon-chai": "^3.7.0",
@@ -72,4 +72,4 @@ "ts-loader": "^9.4.1",
         "tslint-config-holy-grail": "^53.2.34",
-        "typescript": "^4.8.4",
-        "webpack": "^5.74.0",
+        "typescript": "^4.9.3",
+        "webpack": "^5.75.0",
         "xstream": "^11.14.0"
@@ -103,3 +103,3 @@ },
     "types": "build/es2019/module.d.ts",
-    "version": "2.1.9"
+    "version": "2.1.10"
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

225212

decreased by-0.1%

No dependency changes