@dxyl/utils 1.2.2 → 1.3.1

package/types/data/mobx.d.ts

@@ -1,2 +1,2 @@
-export { IObservable, IDepTreeNode, Reaction, IReactionPublic, IReactionDisposer, untracked, IAtom, createAtom, spy, IComputedValue, IEqualsComparer, comparer, IEnhancer, IInterceptable, IInterceptor, IListenable, IObjectWillChange, IObjectDidChange, isObservableObject, IValueDidChange, IValueWillChange, IObservableValue, isObservableValue as isBoxedObservable, IObservableArray, IArrayWillChange, IArrayWillSplice, IArraySplice, IArrayUpdate, IArrayDidChange, isObservableArray, IKeyValueMap, ObservableMap, IMapEntries, IMapEntry, IMapWillChange, IMapDidChange, isObservableMap, IObservableMapInitialValues, ObservableSet, isObservableSet, ISetDidChange, ISetWillChange, IObservableSetInitialValues, transaction, observable, IObservableFactory, CreateObservableOptions, computed, IComputedFactory, isObservable, isObservableProp, isComputed, isComputedProp, extendObservable, observe, intercept, autorun, IAutorunOptions, reaction, IReactionOptions, when, IWhenOptions, action, isAction, runInAction, IActionFactory, keys, values, entries, set, remove, has, get, apiOwnKeys as ownKeys, apiDefineProperty as defineProperty, configure, onBecomeObserved, onBecomeUnobserved, flow, isFlow, flowResult, FlowCancellationError, isFlowCancellationError, toJS, trace, IObserverTree, IDependencyTree, getDependencyTree, getObserverTree, resetGlobalState as _resetGlobalState, getGlobalState as _getGlobalState, getDebugName, getAtom, getAdministration as _getAdministration, allowStateChanges as _allowStateChanges, runInAction as _allowStateChangesInsideComputed, // This has become the default behavior in Mobx 6
-Lambda, $mobx, isComputingDerivation as _isComputingDerivation, onReactionError, interceptReads as _interceptReads, IComputedValueOptions, IActionRunInfo, _startAction, _endAction, allowStateReadsStart as _allowStateReadsStart, allowStateReadsEnd as _allowStateReadsEnd, makeObservable, makeAutoObservable, autoAction as _autoAction, AnnotationsMap, AnnotationMapEntry, override } from './mobx/internal';
+export { IObservable, IDepTreeNode, Reaction, IReactionPublic, IReactionDisposer, untracked, IAtom, createAtom, spy, IComputedValue, IEqualsComparer, comparer, IEnhancer, IInterceptable, IInterceptor, IListenable, IObjectWillChange, IObjectDidChange, isObservableObject, IValueDidChange, IValueWillChange, IObservableValue, isObservableValue as isBoxedObservable, IObservableArray, IArrayWillChange, IArrayWillSplice, IArraySplice, IArrayUpdate, IArrayDidChange, isObservableArray, IKeyValueMap, ObservableMap, IMapEntries, IMapEntry, IMapWillChange, IMapDidChange, isObservableMap, IObservableMapInitialValues, ObservableSet, isObservableSet, ISetDidChange, ISetWillChange, IObservableSetInitialValues, transaction, observable, IObservableFactory, CreateObservableOptions, computed, IComputedFactory, isObservable, isObservableProp, isComputed, isComputedProp, extendObservable, observe, intercept, autorun, IAutorunOptions, reaction, IReactionOptions, when, IWhenOptions, action, isAction, runInAction, IActionFactory, keys, values, entries, set, remove, has, get, apiOwnKeys as ownKeys, apiDefineProperty as defineProperty, configure, onBecomeObserved, onBecomeUnobserved, flow, isFlow, flowResult, FlowCancellationError, isFlowCancellationError, toJS, trace, IObserverTree, IDependencyTree, getDependencyTree, getObserverTree, resetGlobalState as _resetGlobalState, getGlobalState as _getGlobalState, getDebugName, getAtom, getAdministration as _getAdministration, allowStateChanges as _allowStateChanges, runInAction as _allowStateChangesInsideComputed, // This has become the default behavior in Mobx 6
+Lambda, $mobx, isComputingDerivation as _isComputingDerivation, onReactionError, interceptReads as _interceptReads, IComputedValueOptions, IActionRunInfo, _startAction, _endAction, allowStateReadsStart as _allowStateReadsStart, allowStateReadsEnd as _allowStateReadsEnd, makeObservable, makeAutoObservable, autoAction as _autoAction, AnnotationsMap, AnnotationMapEntry, override } from './mobx/internal';

package/types/data/reactivity.d.ts

@@ -1,4 +1,5 @@
 export type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+
 export declare enum TrackOpTypes {
     GET = "get",
     HAS = "has",
@@ -751,5 +752,5 @@ export declare function getCurrentWatcher(): ReactiveEffect<any> | undefined;
  */
 export declare function onWatcherCleanup(cleanupFn: () => void, failSilently?: boolean, owner?: ReactiveEffect | undefined): void;
 export declare function watch(source: WatchSource | WatchSource[] | WatchEffect | object, cb?: WatchCallback | null, options?: WatchOptions): WatchHandle;
-export declare function traverse(value: unknown, depth?: number, seen?: Set<unknown>): unknown;
+export declare function traverse(value: unknown, depth?: number, seen?: Map<unknown, number>): unknown;
 

package/types/events/eventTarget.d.ts

@@ -17,7 +17,7 @@ export declare const BUBBLING_PHASE: 3;
 export declare class Event<T = any, E extends Extract<keyof Record<string, any>, string> = ''> {
     static create<T = any, E extends Extract<keyof Record<string, any>, string> = ''>(type: E, bubbles?: boolean, cancelable?: boolean): Event<T, E>;
     type: E;
-    parentNode: null;
+    parentNode: any;
     target: EventTarget | null;
     currentTarget: EventTarget | null;
     data: T | null;

package/types/events/event_emiter.d.ts

@@ -1,43 +1,43 @@
-type EventData = {
-    [Key: string]: any;
-};
-type ListenerFunc<D extends EventData> = (e: EmitterEvent<D>) => void;
-type ListenerObject<D extends EventData> = {
-    handleEvent(e: EmitterEvent<D>): void;
-};
-type ListenerFuncOrObject<D extends EventData> = ListenerFunc<D> | ListenerObject<D>;
-type ListenerData<D extends EventData> = {
-    once: boolean;
-    listener: ListenerFuncOrObject<D>;
-};
-export declare class EmitterEvent<Data extends EventData> {
-    static NONE: number;
-    static AT_TARGET: number;
-    static BUBBLING_PHASE: number;
-    static new(type: string, data: any): EmitterEvent<any>;
-    type: string;
-    eventPhase: number;
-    data: Data;
-    target: EventEmitter<any> | null;
-    currentTarget: EventEmitter<any> | null;
-    composedPath: EventEmitter<any>[];
-    bubbles: boolean;
-    propagationStopped: boolean;
-    immediatePropagationStopped: boolean;
-    constructor(type: string, data: Data);
-    reset(): void;
-    stopPropagation(): void;
-    stopImmediatePropagation(): void;
-}
-declare const isEventEmitter_Property: unique symbol;
-export declare class EventEmitter<EventListeners extends Record<string, EventData> = {}> {
-    static createEvent(type: string, data: any): EmitterEvent<any>;
-    [isEventEmitter_Property]: boolean;
-    parent?: EventEmitter;
-    listeners: Map<string, ListenerData<EventData>[]>;
-    hasEvent(type: string): boolean;
-    on<Type extends Extract<keyof EventListeners, string>>(type: Type, listener: ListenerFuncOrObject<EventListeners[Type]>, once?: boolean): boolean;
-    off<Type extends Extract<keyof EventListeners, string>>(type?: Type, listener?: ListenerFuncOrObject<EventListeners[Type]>): boolean;
-    emit(event: EmitterEvent<EventListeners[keyof EventListeners]>): void;
-}
-export {};
+type EventData = {
+    [Key: string]: any;
+};
+type ListenerFunc<D extends EventData> = (e: EmitterEvent<D>) => void;
+type ListenerObject<D extends EventData> = {
+    handleEvent(e: EmitterEvent<D>): void;
+};
+type ListenerFuncOrObject<D extends EventData> = ListenerFunc<D> | ListenerObject<D>;
+type ListenerData<D extends EventData> = {
+    once: boolean;
+    listener: ListenerFuncOrObject<D>;
+};
+export declare class EmitterEvent<Data extends EventData> {
+    static NONE: number;
+    static AT_TARGET: number;
+    static BUBBLING_PHASE: number;
+    static new(type: string, data: any): EmitterEvent<any>;
+    type: string;
+    eventPhase: number;
+    data: Data;
+    target: EventEmitter<any> | null;
+    currentTarget: EventEmitter<any> | null;
+    composedPath: EventEmitter<any>[];
+    bubbles: boolean;
+    propagationStopped: boolean;
+    immediatePropagationStopped: boolean;
+    constructor(type: string, data: Data);
+    reset(): void;
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+}
+declare const isEventEmitter_Property: unique symbol;
+export declare class EventEmitter<EventListeners extends Record<string, EventData> = {}> {
+    static createEvent(type: string, data: any): EmitterEvent<any>;
+    [isEventEmitter_Property]: boolean;
+    parent?: EventEmitter;
+    listeners: Map<string, ListenerData<EventData>[]>;
+    hasEvent(type: string): boolean;
+    on<Type extends Extract<keyof EventListeners, string>>(type: Type, listener: ListenerFuncOrObject<EventListeners[Type]>, once?: boolean): boolean;
+    off<Type extends Extract<keyof EventListeners, string>>(type?: Type, listener?: ListenerFuncOrObject<EventListeners[Type]>): boolean;
+    emit(event: EmitterEvent<EventListeners[keyof EventListeners]>): void;
+}
+export {};

package/types/fast/fast-deep-equal.d.ts

@@ -0,0 +1 @@
+export default function equal(a: any, b: any): boolean;

package/types/fast/fast-diff.d.ts

@@ -0,0 +1,21 @@
+declare function diff(
+    text1: string,
+    text2: string,
+    cursorPos?: number | diff.CursorInfo,
+    cleanup?: boolean
+  ): diff.Diff[];
+  
+  declare namespace diff {
+    type Diff = [-1 | 0 | 1, string];
+  
+    const DELETE: -1;
+    const INSERT: 1;
+    const EQUAL: 0;
+  
+    interface CursorInfo {
+      oldRange: { index: number; length: number };
+      newRange: { index: number; length: number };
+    }
+  }
+  
+  export default diff;

package/types/fast/fast-json-patch/core.d.ts

@@ -0,0 +1,111 @@
+import { PatchError, _deepClone } from './helpers.js';
+export declare const JsonPatchError: typeof PatchError;
+export declare const deepClone: typeof _deepClone;
+export type Operation = AddOperation<any> | RemoveOperation | ReplaceOperation<any> | MoveOperation | CopyOperation | TestOperation<any> | GetOperation<any>;
+export interface Validator<T> {
+    (operation: Operation, index: number, document: T, existingPathFragment: string): void;
+}
+export interface OperationResult<T> {
+    removed?: any;
+    test?: boolean;
+    newDocument: T;
+}
+export interface BaseOperation {
+    path: string;
+}
+export interface AddOperation<T> extends BaseOperation {
+    op: 'add';
+    value: T;
+}
+export interface RemoveOperation extends BaseOperation {
+    op: 'remove';
+}
+export interface ReplaceOperation<T> extends BaseOperation {
+    op: 'replace';
+    value: T;
+}
+export interface MoveOperation extends BaseOperation {
+    op: 'move';
+    from: string;
+}
+export interface CopyOperation extends BaseOperation {
+    op: 'copy';
+    from: string;
+}
+export interface TestOperation<T> extends BaseOperation {
+    op: 'test';
+    value: T;
+}
+export interface GetOperation<T> extends BaseOperation {
+    op: '_get';
+    value: T;
+}
+export interface PatchResult<T> extends Array<OperationResult<T>> {
+    newDocument: T;
+}
+/**
+ * Retrieves a value from a JSON document by a JSON pointer.
+ * Returns the value.
+ *
+ * @param document The document to get the value from
+ * @param pointer an escaped JSON pointer
+ * @return The retrieved value
+ */
+export declare function getValueByPointer(document: any, pointer: string): any;
+/**
+ * Apply a single JSON Patch Operation on a JSON document.
+ * Returns the {newDocument, result} of the operation.
+ * It modifies the `document` and `operation` objects - it gets the values by reference.
+ * If you would like to avoid touching your values, clone them:
+ * `jsonpatch.applyOperation(document, jsonpatch._deepClone(operation))`.
+ *
+ * @param document The document to patch
+ * @param operation The operation to apply
+ * @param validateOperation `false` is without validation, `true` to use default jsonpatch's validation, or you can pass a `validateOperation` callback to be used for validation.
+ * @param mutateDocument Whether to mutate the original document or clone it before applying
+ * @param banPrototypeModifications Whether to ban modifications to `__proto__`, defaults to `true`.
+ * @return `{newDocument, result}` after the operation
+ */
+export declare function applyOperation<T>(document: T, operation: Operation, validateOperation?: boolean | Validator<T>, mutateDocument?: boolean, banPrototypeModifications?: boolean, index?: number): OperationResult<T>;
+/**
+ * Apply a full JSON Patch array on a JSON document.
+ * Returns the {newDocument, result} of the patch.
+ * It modifies the `document` object and `patch` - it gets the values by reference.
+ * If you would like to avoid touching your values, clone them:
+ * `jsonpatch.applyPatch(document, jsonpatch._deepClone(patch))`.
+ *
+ * @param document The document to patch
+ * @param patch The patch to apply
+ * @param validateOperation `false` is without validation, `true` to use default jsonpatch's validation, or you can pass a `validateOperation` callback to be used for validation.
+ * @param mutateDocument Whether to mutate the original document or clone it before applying
+ * @param banPrototypeModifications Whether to ban modifications to `__proto__`, defaults to `true`.
+ * @return An array of `{newDocument, result}` after the patch
+ */
+export declare function applyPatch<T>(document: T, patch: ReadonlyArray<Operation>, validateOperation?: boolean | Validator<T>, mutateDocument?: boolean, banPrototypeModifications?: boolean): PatchResult<T>;
+/**
+ * Apply a single JSON Patch Operation on a JSON document.
+ * Returns the updated document.
+ * Suitable as a reducer.
+ *
+ * @param document The document to patch
+ * @param operation The operation to apply
+ * @return The updated document
+ */
+export declare function applyReducer<T>(document: T, operation: Operation, index: number): T;
+/**
+ * Validates a single operation. Called from `jsonpatch.validate`. Throws `JsonPatchError` in case of an error.
+ * @param {object} operation - operation object (patch)
+ * @param {number} index - index of operation in the sequence
+ * @param {object} [document] - object where the operation is supposed to be applied
+ * @param {string} [existingPathFragment] - comes along with `document`
+ */
+export declare function validator(operation: Operation, index: number, document?: any, existingPathFragment?: string): void;
+/**
+ * Validates a sequence of operations. If `document` parameter is provided, the sequence is additionally validated against the object document.
+ * If error is encountered, returns a JsonPatchError object
+ * @param sequence
+ * @param document
+ * @returns {JsonPatchError|undefined}
+ */
+export declare function validate<T>(sequence: ReadonlyArray<Operation>, document?: T, externalValidator?: Validator<T>): PatchError;
+export declare function _areEquals(a: any, b: any): boolean;

package/types/fast/fast-json-patch/duplex.d.ts

@@ -0,0 +1,23 @@
+import { Operation } from './core.js';
+export interface Observer<T> {
+    object: T;
+    patches: Operation[];
+    unobserve: () => void;
+    callback: (patches: Operation[]) => void;
+}
+/**
+ * Detach an observer from an object
+ */
+export declare function unobserve<T>(root: T, observer: Observer<T>): void;
+/**
+ * Observes changes made to an object, which can then be retrieved using generate
+ */
+export declare function observe<T>(obj: Object | Array<T>, callback?: (patches: Operation[]) => void): Observer<T>;
+/**
+ * Generate an array of patches from an observer
+ */
+export declare function generate<T>(observer: Observer<Object>, invertible?: boolean): Operation[];
+/**
+ * Create an array of patches from the differences in two objects
+ */
+export declare function compare(tree1: Object | Array<any>, tree2: Object | Array<any>, invertible?: boolean): Operation[];

package/types/fast/fast-json-patch/helpers.d.ts

@@ -0,0 +1,41 @@
+/*!
+ * https://github.com/Starcounter-Jack/JSON-Patch
+ * (c) 2017-2022 Joachim Wester
+ * MIT licensed
+ */
+export declare function hasOwnProperty(obj: any, key: string): boolean;
+export declare function _objectKeys(obj: any): any[];
+/**
+* Deeply clone the object.
+* https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25 (recursiveDeepCopy)
+* @param  {any} obj value to clone
+* @return {any} cloned obj
+*/
+export declare function _deepClone(obj: any): any;
+export declare function isInteger(str: string): boolean;
+/**
+* Escapes a json pointer path
+* @param path The raw pointer
+* @return the Escaped path
+*/
+export declare function escapePathComponent(path: string): string;
+/**
+ * Unescapes a json pointer path
+ * @param path The escaped pointer
+ * @return The unescaped path
+ */
+export declare function unescapePathComponent(path: string): string;
+export declare function _getPathRecursive(root: any, obj: any): string;
+export declare function getPath(root: Object, obj: Object): string;
+/**
+* Recursively checks whether an object has any undefined values inside.
+*/
+export declare function hasUndefined(obj: any): boolean;
+export type JsonPatchErrorName = 'SEQUENCE_NOT_AN_ARRAY' | 'OPERATION_NOT_AN_OBJECT' | 'OPERATION_OP_INVALID' | 'OPERATION_PATH_INVALID' | 'OPERATION_FROM_REQUIRED' | 'OPERATION_VALUE_REQUIRED' | 'OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED' | 'OPERATION_PATH_CANNOT_ADD' | 'OPERATION_PATH_UNRESOLVABLE' | 'OPERATION_FROM_UNRESOLVABLE' | 'OPERATION_PATH_ILLEGAL_ARRAY_INDEX' | 'OPERATION_VALUE_OUT_OF_BOUNDS' | 'TEST_OPERATION_FAILED';
+export declare class PatchError extends Error {
+    name: JsonPatchErrorName;
+    index?: number;
+    operation?: any;
+    tree?: any;
+    constructor(message: string, name: JsonPatchErrorName, index?: number, operation?: any, tree?: any);
+}

package/types/fast-deep-equal.d.ts

@@ -1 +1 @@
-export default function equal(a: any, b: any): boolean;
+export default function equal(a: any, b: any): boolean;

package/types/index.d.ts

@@ -24,6 +24,14 @@ export { Options } from './Options';
 export { default as compose } from './compose';
 export type { OptionsProperties, OptionConfig } from './Options';
 export { default as deepmerge } from './deepmerge';
-export { default as fastDeepEqual } from './fast-deep-equal';
 export * from './Color';
 export * as colord from './color/colord/src';
+export * from './PluginService';
+export { default as fastDeepEqual } from './fast/fast-deep-equal';
+export { default as fastDiff } from './fast/fast-diff';
+export * as fastJsonPatch from './fast/fast-json-patch/core';
+export * as QuillDelta from './text/quill-delta/Delta';
+export * from './Transaction';
+export * from './StackCursor';
+export * from './Pool';
+export * from './Disposable';

package/types/laxer.d.ts

@@ -19,4 +19,28 @@
        *
        * sourceCode -> Lexer analysis or Tokenizer(token[]) -> ast parse (tree<astNode>) -> (code generate) | (ast interpreter)
       */
-export {};
+declare const token: (type: string, value: any, start: number) => {
+    type: string;
+    value: any;
+    start: number;
+};
+type Token = ReturnType<typeof token>;
+/**
+ * 词法分析
+ * @param {string} source 源码
+ * @returns {Token[]}
+*/
+declare const lexer: (source: string) => {
+    type: string;
+    value: any;
+    start: number;
+}[];
+declare const parse: (tokens: Token[]) => {
+    type: string;
+    body: any[];
+    start?: number;
+    end?: number;
+};
+declare const codeGen: (ast: any) => string;
+declare const interpreter: (program: any) => any;
+export { parse, codeGen, lexer, interpreter, token };

package/types/lodash/_freeGlobal.d.ts

@@ -1,3 +1,3 @@
 export default freeGlobal;
 /** Detect free variable `global` from Node.js. */
-declare var freeGlobal: false | typeof globalThis;
+declare var freeGlobal: typeof globalThis;

package/types/lodash/_stackSet.d.ts

@@ -24,5 +24,5 @@ declare class stackSet {
      */
     private constructor();
     size: any;
-    __data__: MapCache | undefined;
+    __data__: MapCache;
 }

package/types/lodash/add.d.ts

@@ -1,2 +1,3 @@
 import { add } from 'lodash';
-export default add;
+
+export default add;

package/types/lodash/after.d.ts

@@ -1,2 +1,3 @@
 import { after } from 'lodash';
-export default after;
+
+export default after;

package/types/lodash/array.d.ts

@@ -63,4 +63,6 @@ import { default as zip } from './zip';
 import { default as zipObject } from './zipObject';
 import { default as zipObjectDeep } from './zipObjectDeep';
 import { default as zipWith } from './zipWith';
-export { default } from './array.default';
+
+
+export { default } from './array.default';

package/types/lodash/array.default.d.ts

@@ -63,71 +63,73 @@ import { default as zip } from './zip';
 import { default as zipObject } from './zipObject';
 import { default as zipObjectDeep } from './zipObjectDeep';
 import { default as zipWith } from './zipWith';
-declare const defaultExport: {
-    chunk: typeof chunk;
-    compact: typeof compact;
-    concat: typeof concat;
-    difference: typeof difference;
-    differenceBy: typeof differenceBy;
-    differenceWith: typeof differenceWith;
-    drop: typeof drop;
-    dropRight: typeof dropRight;
-    dropRightWhile: typeof dropRightWhile;
-    dropWhile: typeof dropWhile;
-    fill: typeof fill;
-    findIndex: typeof findIndex;
-    findLastIndex: typeof findLastIndex;
-    first: typeof first;
-    flatten: typeof flatten;
-    flattenDeep: typeof flattenDeep;
-    flattenDepth: typeof flattenDepth;
-    fromPairs: typeof fromPairs;
-    head: typeof head;
-    indexOf: typeof indexOf;
-    initial: typeof initial;
-    intersection: typeof intersection;
-    intersectionBy: typeof intersectionBy;
-    intersectionWith: typeof intersectionWith;
-    join: typeof join;
-    last: typeof last;
-    lastIndexOf: typeof lastIndexOf;
-    nth: typeof nth;
-    pull: typeof pull;
-    pullAll: typeof pullAll;
-    pullAllBy: typeof pullAllBy;
-    pullAllWith: typeof pullAllWith;
-    pullAt: typeof pullAt;
-    remove: typeof remove;
-    reverse: typeof reverse;
-    slice: typeof slice;
-    sortedIndex: typeof sortedIndex;
-    sortedIndexBy: typeof sortedIndexBy;
-    sortedIndexOf: typeof sortedIndexOf;
-    sortedLastIndex: typeof sortedLastIndex;
-    sortedLastIndexBy: typeof sortedLastIndexBy;
-    sortedLastIndexOf: typeof sortedLastIndexOf;
-    sortedUniq: typeof sortedUniq;
-    sortedUniqBy: typeof sortedUniqBy;
-    tail: typeof tail;
-    take: typeof take;
-    takeRight: typeof takeRight;
-    takeRightWhile: typeof takeRightWhile;
-    takeWhile: typeof takeWhile;
-    union: typeof union;
-    unionBy: typeof unionBy;
-    unionWith: typeof unionWith;
-    uniq: typeof uniq;
-    uniqBy: typeof uniqBy;
-    uniqWith: typeof uniqWith;
-    unzip: typeof unzip;
-    unzipWith: typeof unzipWith;
-    without: typeof without;
-    xor: typeof xor;
-    xorBy: typeof xorBy;
-    xorWith: typeof xorWith;
-    zip: typeof zip;
-    zipObject: typeof zipObject;
-    zipObjectDeep: typeof zipObjectDeep;
-    zipWith: typeof zipWith;
-};
-export default defaultExport;
+
+
+declare const defaultExport: {
+    chunk: typeof chunk;
+    compact: typeof compact;
+    concat: typeof concat;
+    difference: typeof difference;
+    differenceBy: typeof differenceBy;
+    differenceWith: typeof differenceWith;
+    drop: typeof drop;
+    dropRight: typeof dropRight;
+    dropRightWhile: typeof dropRightWhile;
+    dropWhile: typeof dropWhile;
+    fill: typeof fill;
+    findIndex: typeof findIndex;
+    findLastIndex: typeof findLastIndex;
+    first: typeof first;
+    flatten: typeof flatten;
+    flattenDeep: typeof flattenDeep;
+    flattenDepth: typeof flattenDepth;
+    fromPairs: typeof fromPairs;
+    head: typeof head;
+    indexOf: typeof indexOf;
+    initial: typeof initial;
+    intersection: typeof intersection;
+    intersectionBy: typeof intersectionBy;
+    intersectionWith: typeof intersectionWith;
+    join: typeof join;
+    last: typeof last;
+    lastIndexOf: typeof lastIndexOf;
+    nth: typeof nth;
+    pull: typeof pull;
+    pullAll: typeof pullAll;
+    pullAllBy: typeof pullAllBy;
+    pullAllWith: typeof pullAllWith;
+    pullAt: typeof pullAt;
+    remove: typeof remove;
+    reverse: typeof reverse;
+    slice: typeof slice;
+    sortedIndex: typeof sortedIndex;
+    sortedIndexBy: typeof sortedIndexBy;
+    sortedIndexOf: typeof sortedIndexOf;
+    sortedLastIndex: typeof sortedLastIndex;
+    sortedLastIndexBy: typeof sortedLastIndexBy;
+    sortedLastIndexOf: typeof sortedLastIndexOf;
+    sortedUniq: typeof sortedUniq;
+    sortedUniqBy: typeof sortedUniqBy;
+    tail: typeof tail;
+    take: typeof take;
+    takeRight: typeof takeRight;
+    takeRightWhile: typeof takeRightWhile;
+    takeWhile: typeof takeWhile;
+    union: typeof union;
+    unionBy: typeof unionBy;
+    unionWith: typeof unionWith;
+    uniq: typeof uniq;
+    uniqBy: typeof uniqBy;
+    uniqWith: typeof uniqWith;
+    unzip: typeof unzip;
+    unzipWith: typeof unzipWith;
+    without: typeof without;
+    xor: typeof xor;
+    xorBy: typeof xorBy;
+    xorWith: typeof xorWith;
+    zip: typeof zip;
+    zipObject: typeof zipObject;
+    zipObjectDeep: typeof zipObjectDeep;
+    zipWith: typeof zipWith;
+};
+export default defaultExport;

package/types/lodash/ary.d.ts

@@ -1,2 +1,3 @@
 import { ary } from 'lodash';
-export default ary;
+
+export default ary;

package/types/lodash/assign.d.ts

@@ -1,2 +1,3 @@
 import { assign } from 'lodash';
-export default assign;
+
+export default assign;

package/types/lodash/assignIn.d.ts

@@ -1,2 +1,3 @@
 import { assignIn } from 'lodash';
-export default assignIn;
+
+export default assignIn;

package/types/lodash/assignInWith.d.ts

@@ -1,2 +1,3 @@
 import { assignInWith } from 'lodash';
-export default assignInWith;
+
+export default assignInWith;

package/types/lodash/assignWith.d.ts

@@ -1,2 +1,3 @@
 import { assignWith } from 'lodash';
-export default assignWith;
+
+export default assignWith;

package/types/lodash/at.d.ts

@@ -1,2 +1,3 @@
 import { at } from 'lodash';
-export default at;
+
+export default at;

package/types/lodash/attempt.d.ts

@@ -1,2 +1,3 @@
 import { attempt } from 'lodash';
-export default attempt;
+
+export default attempt;

package/types/lodash/augment.d.ts

@@ -1,2 +1,2 @@
-declare const augment: (...args: any[]) => void;
-export default augment;
+declare const augment: (...args: any[]) => void;
+export default augment;

package/types/lodash/before.d.ts

@@ -1,2 +1,3 @@
 import { before } from 'lodash';
-export default before;
+
+export default before;

package/types/lodash/bind.d.ts

@@ -1,2 +1,3 @@
 import { bind } from 'lodash';
-export default bind;
+
+export default bind;

package/types/lodash/bindAll.d.ts

@@ -1,2 +1,3 @@
 import { bindAll } from 'lodash';
-export default bindAll;
+
+export default bindAll;

package/types/lodash/bindKey.d.ts

@@ -1,2 +1,3 @@
 import { bindKey } from 'lodash';
-export default bindKey;
+
+export default bindKey;