index.json

{
    "$": {
        "dependencies": [
            "Select",
            "$offset",
            "$show",
            "$css",
            "$attr",
            "$property",
            "last",
            "$remove",
            "$data",
            "$event",
            "$class",
            "$insert",
            "isUndef",
            "isStr"
        ],
        "description": "jQuery like style dom manipulator.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "$attr": {
        "dependencies": [
            "toArr",
            "isObj",
            "isStr",
            "each",
            "isUndef",
            "$safeEls"
        ],
        "description": "Element attribute manipulation.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "$class": {
        "dependencies": [
            "toArr",
            "some",
            "$safeEls",
            "isStr",
            "each"
        ],
        "description": "Element class manipulations.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "$css": {
        "dependencies": [
            "isStr",
            "isObj",
            "kebabCase",
            "isUndef",
            "contain",
            "isNum",
            "$safeEls",
            "prefix",
            "each"
        ],
        "description": "Element css manipulation.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "$data": {
        "dependencies": [
            "$attr",
            "isStr",
            "isObj",
            "each",
            "$safeEls"
        ],
        "description": "Wrapper of $attr, adds data- prefix to keys.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "$event": {
        "dependencies": [
            "delegate",
            "isUndef",
            "$safeEls",
            "each"
        ],
        "description": "bind events to certain dom elements.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "$insert": {
        "dependencies": [
            "each",
            "$safeEls",
            "isStr"
        ],
        "description": "Insert html on different position.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "$offset": {
        "dependencies": [
            "$safeEls"
        ],
        "description": "Get the position of the element in document.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "$property": {
        "dependencies": [
            "isUndef",
            "each",
            "$safeEls"
        ],
        "description": "Element property html, text, val getter and setter.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "$remove": {
        "dependencies": [
            "each",
            "$safeEls"
        ],
        "description": "Remove the set of matched elements from the DOM.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "$safeEls": {
        "dependencies": [
            "isStr",
            "toArr",
            "Select"
        ],
        "description": "Convert value into an array, if it's a string, do querySelector.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "$show": {
        "dependencies": [
            "each",
            "$safeEls"
        ],
        "description": "Show elements.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "Benchmark": {
        "dependencies": [
            "Class",
            "defaults",
            "Promise",
            "perfNow",
            "delay",
            "average",
            "reduce",
            "each",
            "map",
            "table",
            "toStr"
        ],
        "description": "JavaScript Benchmark.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.30.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "Blob": {
        "dependencies": [
            "root",
            "each"
        ],
        "description": "Use Blob when available, otherwise BlobBuilder.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "BloomFilter": {
        "dependencies": [
            "Class",
            "fill",
            "fnv1a",
            "strHash",
            "each",
            "some"
        ],
        "description": "Bloom filter implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.10.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "Caseless": {
        "dependencies": [
            "Class",
            "lowerCase",
            "keys"
        ],
        "description": "Modify object props without caring about letter case.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.9.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "Channel": {
        "dependencies": [
            "Emitter",
            "each",
            "remove",
            "some"
        ],
        "description": "Interconnectable Message channel.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.42.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "Class": {
        "demo": true,
        "dependencies": [
            "extend",
            "toArr",
            "inherits",
            "safeGet",
            "isMiniProgram"
        ],
        "description": "Create JavaScript class.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "Color": {
        "dependencies": [
            "Class",
            "isStr",
            "clamp",
            "rgbToHsl",
            "hslToRgb",
            "hex"
        ],
        "description": "Color converter.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "Delegator": {
        "dependencies": [
            "Class",
            "safeGet",
            "defineProp",
            "isStr"
        ],
        "description": "Object delegation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.17.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "Dispatcher": {
        "dependencies": [
            "Class",
            "uniqId"
        ],
        "description": "Flux dispatcher.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "Emitter": {
        "dependencies": [
            "Class",
            "has",
            "each",
            "slice",
            "once",
            "clone"
        ],
        "description": "Event emitter class which provides observer pattern.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "Enum": {
        "dependencies": [
            "Class",
            "freeze",
            "isArr",
            "each",
            "keys"
        ],
        "description": "Enum type implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "FileBlobStore": {
        "dependencies": [
            "isStr",
            "isObj",
            "each",
            "Emitter",
            "toArr",
            "unique",
            "concat",
            "keys"
        ],
        "description": "Binary file storage.",
        "env": [
            "node"
        ],
        "since": "1.32.0",
        "test": [
            "node"
        ]
    },
    "FileStore": {
        "dependencies": [
            "Store",
            "isEmpty",
            "debounce",
            "stringify",
            "isObj",
            "defaults",
            "noop"
        ],
        "description": "File storage.",
        "env": [
            "node"
        ],
        "since": "1.32.0",
        "test": [
            "node"
        ]
    },
    "HashTable": {
        "dependencies": [
            "Class",
            "LinkedList",
            "map",
            "strHash",
            "has"
        ],
        "description": "Hash table implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.13.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "Heap": {
        "dependencies": [
            "Class",
            "swap",
            "isSorted"
        ],
        "description": "Heap implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.11.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "HeapSnapshot": {
        "dependencies": [
            "Class",
            "toBool",
            "camelCase",
            "LinkedList",
            "isStr",
            "each",
            "map"
        ],
        "description": "V8 heap snapshot manipulator.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.31.0",
        "test": [
            "node"
        ]
    },
    "I18n": {
        "dependencies": [
            "Class",
            "safeGet",
            "extend",
            "strTpl",
            "isStr",
            "isFn"
        ],
        "description": "Simple internationalization library.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.23.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "JsonTransformer": {
        "dependencies": [
            "Class",
            "safeSet",
            "safeGet",
            "map",
            "filter",
            "isFn",
            "safeDel",
            "toArr",
            "each"
        ],
        "description": "Json to json transformer.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "LinkedList": {
        "dependencies": [
            "Class"
        ],
        "description": "Doubly-linked list implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "LocalStore": {
        "dependencies": [
            "Store",
            "safeStorage",
            "isEmpty",
            "stringify",
            "defaults",
            "isObj"
        ],
        "description": "LocalStorage wrapper.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "Logger": {
        "demo": true,
        "dependencies": [
            "Emitter",
            "Enum",
            "toArr",
            "isUndef",
            "clone",
            "isStr",
            "isNum"
        ],
        "description": "Simple logger with level filter.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "Lru": {
        "dependencies": [
            "LinkedList",
            "PseudoMap",
            "Class"
        ],
        "description": "Simple LRU cache.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.4.5",
        "test": [
            "node",
            "browser"
        ]
    },
    "MediaQuery": {
        "demo": true,
        "dependencies": [
            "Emitter"
        ],
        "description": "CSS media query listener.",
        "env": [
            "browser"
        ],
        "since": "1.5.2",
        "test": [
            "browser"
        ]
    },
    "MutationObserver": {
        "dependencies": [
            "Class"
        ],
        "description": "Safe MutationObserver, does nothing if MutationObserver is not supported.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "PriorityQueue": {
        "dependencies": [
            "Class",
            "Heap",
            "isSorted",
            "wrap"
        ],
        "description": "Priority queue implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.11.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "Promise": {
        "demo": true,
        "dependencies": [
            "Class",
            "isObj",
            "isFn",
            "State",
            "bind",
            "nextTick",
            "noop",
            "toArr"
        ],
        "description": "Lightweight Promise implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": []
    },
    "PseudoMap": {
        "dependencies": [
            "Class",
            "root",
            "defineProp",
            "keys",
            "each",
            "isArr",
            "isUndef"
        ],
        "description": "Like es6 Map, without iterators.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "Queue": {
        "dependencies": [
            "Class"
        ],
        "description": "Queue data structure.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "QuickLru": {
        "benchmark": true,
        "dependencies": [
            "isUndef",
            "Class"
        ],
        "description": "LRU implementation without linked list.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.4.5",
        "test": [
            "node",
            "browser"
        ]
    },
    "Readiness": {
        "dependencies": [
            "Class",
            "toArr",
            "each",
            "map",
            "noop",
            "some"
        ],
        "description": "Readiness manager.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.32.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "ReduceStore": {
        "dependencies": [
            "Class",
            "clone",
            "remove"
        ],
        "description": "Simplified redux like state container.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "ResizeSensor": {
        "demo": true,
        "dependencies": [
            "SingleEmitter",
            "h",
            "$event",
            "$css",
            "contain",
            "extend",
            "root"
        ],
        "description": "Detect if element's size has changed.",
        "env": [
            "browser"
        ],
        "since": "1.29.0",
        "test": [
            "browser"
        ]
    },
    "Select": {
        "dependencies": [
            "Class",
            "isStr",
            "each",
            "mergeArr"
        ],
        "description": "Simple wrapper of querySelectorAll to make dom selection easier.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "Semaphore": {
        "dependencies": [
            "Class",
            "Queue"
        ],
        "description": "Limit simultaneous access to a resource.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.20.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "SessionStore": {
        "dependencies": [
            "Store",
            "safeStorage",
            "isEmpty",
            "stringify",
            "defaults",
            "isObj"
        ],
        "description": "SessionStorage wrapper.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "SingleEmitter": {
        "dependencies": [
            "Class",
            "clone",
            "each",
            "toArr"
        ],
        "description": "Event emitter with single event type.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.29.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "Socket": {
        "dependencies": [
            "defaults",
            "Emitter"
        ],
        "description": "Tiny WebSocket wrapper.",
        "env": [
            "browser"
        ],
        "since": "1.22.0",
        "test": []
    },
    "Stack": {
        "dependencies": [
            "Class",
            "reverse"
        ],
        "description": "Stack data structure.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "State": {
        "dependencies": [
            "Emitter",
            "each",
            "some",
            "toArr"
        ],
        "description": "Simple state machine.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "Store": {
        "dependencies": [
            "Emitter",
            "isStr",
            "isObj",
            "each",
            "toArr"
        ],
        "description": "Memory storage.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "Trace": {
        "dependencies": [
            "Class",
            "each",
            "map"
        ],
        "description": "Parse, manipulate and generate chrome tracing data.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.33.0",
        "test": [
            "node"
        ]
    },
    "Tracing": {
        "dependencies": [
            "Class",
            "Trace",
            "perfNow",
            "extend",
            "isNode",
            "Stack",
            "map",
            "trim",
            "isEmpty",
            "intersect",
            "convertBase"
        ],
        "description": "Easily create chrome tracing data.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.33.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "Trie": {
        "dependencies": [
            "Class",
            "each"
        ],
        "description": "Trie data structure.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.25.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "Tween": {
        "demo": true,
        "dependencies": [
            "Emitter",
            "State",
            "easing",
            "now",
            "each",
            "raf",
            "isFn"
        ],
        "description": "Tween engine for JavaScript animations.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "Url": {
        "dependencies": [
            "Class",
            "extend",
            "trim",
            "query",
            "isEmpty",
            "each",
            "isArr",
            "toArr",
            "isBrowser",
            "isObj",
            "toStr"
        ],
        "description": "Simple url manipulator.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "Validator": {
        "dependencies": [
            "Class",
            "keys",
            "safeGet",
            "isFn",
            "isUndef",
            "isNum",
            "isStr",
            "isBool"
        ],
        "description": "Object values validation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "Wrr": {
        "dependencies": [
            "Class",
            "max",
            "map",
            "reduce",
            "gcd",
            "filter"
        ],
        "description": "Weighted Round Robin implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.21.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "abbrev": {
        "dependencies": [
            "restArgs",
            "isSorted"
        ],
        "description": "Calculate the set of unique abbreviations for a given set of strings.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "after": {
        "dependencies": [],
        "description": "Create a function that invokes once it's called n or more times.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "ajax": {
        "dependencies": [
            "isFn",
            "noop",
            "defaults",
            "isObj",
            "query"
        ],
        "description": "Perform an asynchronous HTTP request.",
        "env": [
            "browser"
        ],
        "test": [
            "node"
        ]
    },
    "allKeys": {
        "dependencies": [
            "keys",
            "getProto",
            "unique"
        ],
        "description": "Retrieve all the names of object's own and inherited properties.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "ansiColor": {
        "dependencies": [],
        "description": "Ansi colors.",
        "env": [
            "node"
        ],
        "since": "1.4.1",
        "test": [
            "node"
        ]
    },
    "arrToMap": {
        "dependencies": [
            "each",
            "isUndef",
            "isFn"
        ],
        "description": "Make an object map using array of strings.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "atob": {
        "dependencies": [
            "root",
            "isNode",
            "base64",
            "map"
        ],
        "description": "Use Buffer to emulate atob when running in node.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "average": {
        "dependencies": [],
        "description": "Get average value of given numbers.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "base64": {
        "dependencies": [],
        "description": "Basic base64 encoding and decoding.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "before": {
        "dependencies": [],
        "description": "Create a function that invokes less than n times.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "binarySearch": {
        "dependencies": [
            "isSorted"
        ],
        "description": "Binary search implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.4.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "bind": {
        "dependencies": [
            "restArgs"
        ],
        "description": "Create a function bound to a given object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "btoa": {
        "dependencies": [
            "root",
            "isNode",
            "base64",
            "map"
        ],
        "description": "Use Buffer to emulate btoa when running in node.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "bubbleSort": {
        "dependencies": [
            "swap",
            "isSorted"
        ],
        "description": "Bubble sort implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "bytesToStr": {
        "dependencies": [
            "utf8",
            "hex",
            "base64"
        ],
        "description": "Convert bytes to string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.1.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "bytesToWords": {
        "dependencies": [],
        "description": "Convert bytes to 32-bit words.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.16.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "cacheRequire": {
        "benchmark": true,
        "dependencies": [
            "defaults",
            "md5",
            "safeGet",
            "FileStore",
            "FileBlobStore",
            "mkdir"
        ],
        "description": "Cache everything in module require to speed up app load.",
        "env": [
            "node"
        ],
        "since": "1.32.0",
        "test": []
    },
    "callbackify": {
        "dependencies": [
            "restArgs"
        ],
        "description": "Convert a function that returns a Promise to a function following the error-first callback style.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "camelCase": {
        "dependencies": [
            "splitCase"
        ],
        "description": "Convert string to \"camelCase\".",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "capitalize": {
        "dependencies": [],
        "description": "Convert the first character to upper case and the remaining to lower case.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "castPath": {
        "dependencies": [
            "has",
            "isArr"
        ],
        "description": "Cast value into a property path array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "centerAlign": {
        "dependencies": [
            "longest",
            "isArr",
            "isUndef",
            "map",
            "lpad"
        ],
        "description": "Center align text in a string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "cgroup": {
        "dependencies": [
            "memoize",
            "each",
            "trim",
            "toNum",
            "contain",
            "concat",
            "range",
            "startWith"
        ],
        "description": "Read cgroup metrics inside container.",
        "env": [
            "node"
        ],
        "since": "1.35.0",
        "test": []
    },
    "char": {
        "dependencies": [],
        "description": "Return string representing a character whose Unicode code point is the given integer.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "chunk": {
        "dependencies": [],
        "description": "Split array into groups the length of given size.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "clamp": {
        "dependencies": [
            "isUndef"
        ],
        "description": "Clamp number within the inclusive lower and upper bounds.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "className": {
        "dependencies": [
            "each",
            "isStr",
            "isNum",
            "isArr",
            "isObj"
        ],
        "description": "Utility for conditionally joining class names.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "cliHelp": {
        "dependencies": [
            "template",
            "each",
            "map",
            "rpad",
            "ansiColor",
            "toArr",
            "cloneDeep",
            "strWidth",
            "max"
        ],
        "description": "Output cli help.",
        "env": [
            "node",
            "browser"
        ],
        "since": "1.27.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "clone": {
        "dependencies": [
            "isObj",
            "isArr",
            "extend"
        ],
        "description": "Create a shallow-copied clone of the provided plain object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "cloneDeep": {
        "dependencies": [
            "isObj",
            "isFn",
            "isArr",
            "mapObj"
        ],
        "description": "Recursively clone value.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "cmpVersion": {
        "dependencies": [
            "toInt",
            "max"
        ],
        "description": "Compare version strings.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "combine": {
        "dependencies": [],
        "description": "Create an array by using one array for keys and another for its values.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.1.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "compact": {
        "dependencies": [
            "filter"
        ],
        "description": "Return a copy of the array with all falsy values removed.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "compose": {
        "dependencies": [
            "restArgs"
        ],
        "description": "Compose a list of functions.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "compressImg": {
        "demo": true,
        "dependencies": [
            "isFn",
            "loadImg",
            "noop",
            "defaults",
            "createUrl",
            "isStr"
        ],
        "description": "Compress image using canvas.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "concat": {
        "dependencies": [
            "toArr"
        ],
        "description": "Concat multiple arrays into a single array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "contain": {
        "dependencies": [
            "idxOf",
            "isStr",
            "isArrLike",
            "values"
        ],
        "description": "Check if the value is present in the list.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "container": {
        "dependencies": [
            "cgroup",
            "perfNow",
            "sleep",
            "memoize",
            "each",
            "isEmpty",
            "sum",
            "isNaN"
        ],
        "description": "Get container stats inside container.",
        "env": [
            "node"
        ],
        "since": "1.35.0",
        "test": []
    },
    "convertBase": {
        "dependencies": [],
        "description": "Convert base of a number.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "convertBin": {
        "dependencies": [
            "isStr",
            "base64",
            "isArrBuffer",
            "isArr",
            "isBuffer",
            "type",
            "lowerCase"
        ],
        "description": "Convert binary data type.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "cookie": {
        "dependencies": [
            "defaults",
            "isNum",
            "isUndef",
            "decodeUriComponent"
        ],
        "description": "Simple api for handling browser cookies.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "copy": {
        "demo": true,
        "dependencies": [
            "extend",
            "noop"
        ],
        "description": "Copy text to clipboard using document.execCommand.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "crc1": {
        "dependencies": [
            "isStr",
            "strToBytes"
        ],
        "description": "CRC1 implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.7",
        "test": [
            "node",
            "browser"
        ]
    },
    "crc16": {
        "dependencies": [
            "isStr",
            "strToBytes"
        ],
        "description": "CRC16 implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.9",
        "test": [
            "node",
            "browser"
        ]
    },
    "crc32": {
        "dependencies": [
            "isStr",
            "strToBytes"
        ],
        "description": "CRC32 implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.9",
        "test": [
            "node",
            "browser"
        ]
    },
    "crc8": {
        "dependencies": [
            "isStr",
            "strToBytes"
        ],
        "description": "CRC8 implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.9",
        "test": [
            "node",
            "browser"
        ]
    },
    "create": {
        "dependencies": [
            "isObj"
        ],
        "description": "Create new object using given object as prototype.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.16.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "createAssigner": {
        "dependencies": [
            "isUndef",
            "each"
        ],
        "description": "Used to create extend, extendOwn and defaults.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "createUrl": {
        "dependencies": [
            "defaults",
            "isBlob",
            "isFile",
            "Blob",
            "toArr"
        ],
        "description": "CreateObjectURL wrapper.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "css": {
        "dependencies": [
            "Class",
            "trim",
            "repeat",
            "defaults",
            "camelCase"
        ],
        "description": "Css parser and serializer.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.14.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "cssPriority": {
        "dependencies": [
            "selector",
            "each",
            "startWith",
            "contain",
            "cmpVersion"
        ],
        "description": "Calculate and compare priority of css selector/rule.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.29.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "cssSupports": {
        "dependencies": [
            "memoize",
            "isUndef",
            "camelCase"
        ],
        "description": "Check if browser supports a given CSS feature.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "curry": {
        "dependencies": [
            "toArr"
        ],
        "description": "Function currying.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "dataUrl": {
        "dependencies": [
            "isDataUrl",
            "trim",
            "endWith",
            "startWith",
            "contain",
            "decodeUriComponent",
            "defaults",
            "isStr",
            "convertBin"
        ],
        "description": "Parse and stringify data urls.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.41.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "dateFormat": {
        "dependencies": [
            "isStr",
            "isDate",
            "toStr",
            "lpad"
        ],
        "description": "Simple but extremely useful date format function.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "debounce": {
        "dependencies": [],
        "description": "Return a new debounced version of the passed function.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "debug": {
        "demo": true,
        "dependencies": [
            "toArr",
            "now",
            "format",
            "ms",
            "isBrowser",
            "strHash",
            "ansiColor"
        ],
        "description": "A tiny JavaScript debugging utility.",
        "env": [
            "node",
            "browser"
        ],
        "test": []
    },
    "deburr": {
        "dependencies": [],
        "description": "Convert Latin-1 Supplement and Latin Extended-A letters to basic Latin letters and remove combining diacritical marks.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.6.1",
        "test": [
            "node",
            "browser"
        ]
    },
    "decodeUriComponent": {
        "dependencies": [
            "each",
            "ucs2",
            "map",
            "utf8"
        ],
        "description": "Better decodeURIComponent that does not throw if input is invalid.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "defaults": {
        "dependencies": [
            "createAssigner",
            "allKeys"
        ],
        "description": "Fill in undefined properties in object with the first value present in the following list of defaults objects.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "define": {
        "dependencies": [
            "toArr"
        ],
        "description": "Define a module, should be used along with use.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "defineProp": {
        "dependencies": [
            "castPath",
            "isStr",
            "isObj",
            "each"
        ],
        "description": "Shortcut for Object.defineProperty(defineProperties).",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "defined": {
        "dependencies": [
            "isUndef"
        ],
        "description": "Return the first argument that is not undefined.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.16.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "delRequireCache": {
        "dependencies": [
            "stackTrace",
            "each",
            "contain"
        ],
        "description": "Delete node.js require cache.",
        "env": [
            "node"
        ],
        "since": "1.5.4",
        "test": []
    },
    "delay": {
        "dependencies": [
            "restArgs"
        ],
        "description": "Invoke function after certain milliseconds.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "delegate": {
        "dependencies": [
            "Class",
            "contain"
        ],
        "description": "Event delegation.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "deprecate": {
        "demo": true,
        "dependencies": [
            "isNode",
            "root",
            "memStorage"
        ],
        "description": "Node.js util.deprecate with browser support.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "detectBrowser": {
        "dependencies": [
            "isBrowser",
            "toInt",
            "keys"
        ],
        "description": "Detect browser info using ua.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "detectMocha": {
        "dependencies": [
            "root"
        ],
        "description": "Detect if mocha is running.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "detectOs": {
        "dependencies": [
            "isBrowser",
            "isNode"
        ],
        "description": "Detect operating system using ua.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "difference": {
        "dependencies": [
            "restArgs",
            "flatten",
            "filter",
            "contain"
        ],
        "description": "Create an array of unique array values not included in the other given array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "dotCase": {
        "dependencies": [
            "splitCase"
        ],
        "description": "Convert string to \"dotCase\".",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "download": {
        "demo": true,
        "dependencies": [
            "createUrl"
        ],
        "description": "Trigger a file download on client side.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "durationFormat": {
        "dependencies": [
            "toInt",
            "lpad",
            "toStr"
        ],
        "description": "Simple duration format function.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.18.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "each": {
        "benchmark": true,
        "dependencies": [
            "isArrLike",
            "keys",
            "optimizeCb"
        ],
        "description": "Iterate over elements of collection and invokes iterator for each element.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "easing": {
        "dependencies": [
            "each",
            "upperFirst"
        ],
        "description": "Easing functions adapted from http://jqueryui.com/ .",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "emulateTouch": {
        "demo": true,
        "dependencies": [
            "trigger",
            "root"
        ],
        "description": "Emulate touch events on desktop browsers.",
        "env": [
            "browser"
        ],
        "since": "1.9.0",
        "test": [
            "browser"
        ]
    },
    "endWith": {
        "dependencies": [],
        "description": "Check if string ends with the given target string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "escape": {
        "dependencies": [
            "keys"
        ],
        "description": "Escapes a string for insertion into HTML, replacing &, <, >, \", `, and ' characters.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "escapeJsStr": {
        "dependencies": [
            "toStr"
        ],
        "description": "Escape string to be a valid JavaScript string literal between quotes.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "escapeRegExp": {
        "dependencies": [],
        "description": "Escape special chars to be used as literals in RegExp constructors.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "evalCss": {
        "dependencies": [],
        "description": "Load css into page.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "evalJs": {
        "benchmark": true,
        "dependencies": [
            "root"
        ],
        "description": "Execute js in given context.",
        "env": [
            "node",
            "browser"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "every": {
        "dependencies": [
            "safeCb",
            "isArrLike",
            "keys"
        ],
        "description": "Check if predicate return truthy for all elements.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "extend": {
        "dependencies": [
            "createAssigner",
            "allKeys"
        ],
        "description": "Copy all of the properties in the source objects over to the destination object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "extendDeep": {
        "dependencies": [
            "isPlainObj",
            "each",
            "cloneDeep"
        ],
        "description": "Recursive object extending.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "extendOwn": {
        "dependencies": [
            "keys",
            "createAssigner"
        ],
        "description": "Like extend, but only copies own properties over to the destination object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "extractBlockCmts": {
        "dependencies": [
            "map",
            "trim"
        ],
        "description": "Extract block comments from source code.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "extractUrls": {
        "dependencies": [
            "unique",
            "trim",
            "map",
            "toArr"
        ],
        "description": "Extract urls from plain text.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "fetch": {
        "dependencies": [
            "each",
            "defaults",
            "noop",
            "has",
            "root"
        ],
        "description": "Turn XMLHttpRequest into promise like.",
        "env": [
            "browser"
        ],
        "test": [
            "node"
        ]
    },
    "fibonacci": {
        "dependencies": [
            "memoize"
        ],
        "description": "Calculate fibonacci number.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "fileSize": {
        "dependencies": [],
        "description": "Turn bytes into human readable file size.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "fileType": {
        "dependencies": [
            "type",
            "mime",
            "isFn"
        ],
        "description": "Detect file type using magic number.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.1",
        "test": [
            "node",
            "browser"
        ]
    },
    "fileUrl": {
        "dependencies": [
            "normalizePath"
        ],
        "description": "Convert a file path to a file URL.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.36.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "fill": {
        "dependencies": [
            "isUndef"
        ],
        "description": "Fill elements of array with value.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "filter": {
        "dependencies": [
            "safeCb",
            "each"
        ],
        "description": "Iterates over elements of collection, returning an array of all the values that pass a truth test.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "find": {
        "dependencies": [
            "findKey",
            "findIdx",
            "isArrLike",
            "isUndef"
        ],
        "description": "Find the first value that passes a truth test in a collection.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "findIdx": {
        "dependencies": [
            "safeCb"
        ],
        "description": "Return the first index where the predicate truth test passes.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "findKey": {
        "dependencies": [
            "safeCb",
            "keys"
        ],
        "description": "Return the first key where the predicate truth test passes.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "findLastIdx": {
        "dependencies": [
            "findIdx"
        ],
        "description": "Return the last index where the predicate truth test passes.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "flatten": {
        "dependencies": [
            "isArr"
        ],
        "description": "Recursively flatten an array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "fnArgs": {
        "dependencies": [
            "startWith",
            "last",
            "lowerCase",
            "isObj",
            "type"
        ],
        "description": "Validate function arguments.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.3",
        "test": [
            "node",
            "browser"
        ]
    },
    "fnParams": {
        "dependencies": [
            "toSrc",
            "stripCmt",
            "startWith",
            "isStr"
        ],
        "description": "Get a function parameter's names.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "fnv1a": {
        "dependencies": [],
        "description": "Simple FNV-1a implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.10.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "format": {
        "dependencies": [
            "restArgs",
            "toInt",
            "toNum",
            "toStr"
        ],
        "description": "Format string in a printf-like format.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "fraction": {
        "dependencies": [
            "gcd",
            "precision"
        ],
        "description": "Convert number to fraction.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "freeze": {
        "dependencies": [
            "keys"
        ],
        "description": "Shortcut for Object.freeze.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "freezeDeep": {
        "dependencies": [
            "freeze",
            "keys",
            "isObj"
        ],
        "description": "Recursively use Object.freeze.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "fs": {
        "dependencies": [
            "promisify",
            "root",
            "each",
            "toArr"
        ],
        "description": "Promised version of node.js fs module.",
        "env": [
            "node"
        ],
        "test": [
            "node"
        ]
    },
    "fullscreen": {
        "demo": true,
        "dependencies": [
            "Emitter",
            "toBool"
        ],
        "description": "Fullscreen api wrapper.",
        "env": [
            "browser"
        ],
        "since": "1.4.0",
        "test": [
            "browser"
        ]
    },
    "fuzzySearch": {
        "dependencies": [
            "filter",
            "map",
            "isStr",
            "safeGet",
            "levenshtein",
            "pluck"
        ],
        "description": "Simple fuzzy search.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "gcd": {
        "dependencies": [],
        "description": "Compute the greatest common divisor using Euclid's algorithm.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "getPort": {
        "dependencies": [
            "toArr"
        ],
        "description": "Get an available TCP port.",
        "env": [
            "node"
        ],
        "since": "1.1.0",
        "test": [
            "node"
        ]
    },
    "getProto": {
        "dependencies": [
            "isObj",
            "isFn"
        ],
        "description": "Get prototype of an object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.5",
        "test": [
            "node",
            "browser"
        ]
    },
    "getUrlParam": {
        "dependencies": [
            "Url"
        ],
        "description": "Get url param.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "golangify": {
        "dependencies": [
            "isFn",
            "restArgs"
        ],
        "description": "Handle errors like golang.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.4",
        "test": [
            "node",
            "browser"
        ]
    },
    "h": {
        "dependencies": [
            "isEl",
            "isStr",
            "startWith",
            "$class",
            "$css",
            "each",
            "isFn"
        ],
        "description": "Create html with JavaScript.",
        "env": [
            "browser"
        ],
        "since": "1.5.1",
        "test": [
            "browser"
        ]
    },
    "has": {
        "dependencies": [],
        "description": "Checks if key is a direct property.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "heapSort": {
        "dependencies": [
            "Heap",
            "isSorted"
        ],
        "description": "Heap sort implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.11.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "hex": {
        "dependencies": [
            "isOdd"
        ],
        "description": "Hex encoding and decoding.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.15.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "highlight": {
        "demo": true,
        "dependencies": [
            "each",
            "defaults"
        ],
        "description": "Highlight code.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.6",
        "test": [
            "node",
            "browser"
        ]
    },
    "hookFn": {
        "dependencies": [
            "noop",
            "defaults",
            "toArr",
            "isArr",
            "isErr"
        ],
        "description": "Monitor, change function arguments and result.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.34.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "hotkey": {
        "demo": true,
        "dependencies": [
            "Emitter",
            "keyCode",
            "each",
            "unique",
            "trim",
            "map",
            "isFn"
        ],
        "description": "Capture keyboard input to trigger given events.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "hslToRgb": {
        "dependencies": [],
        "description": "Convert hsl to rgb.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "html": {
        "dependencies": [
            "parseHtml",
            "Stack",
            "isArr",
            "each",
            "isStr",
            "mapObj"
        ],
        "description": "Html parser and serializer.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.6.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "identity": {
        "dependencies": [],
        "description": "Return the first argument given.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "idxOf": {
        "dependencies": [],
        "description": "Get the index at which the first occurrence of value.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "indent": {
        "dependencies": [
            "isNum",
            "isUndef",
            "repeat"
        ],
        "description": "Indent each line in a string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "inherits": {
        "dependencies": [
            "create"
        ],
        "description": "Inherit the prototype methods from one constructor into another.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "ini": {
        "dependencies": [
            "each",
            "trim",
            "safeSet",
            "safeGet",
            "endWith",
            "isArr",
            "isObj"
        ],
        "description": "Ini parser and serializer.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.4",
        "test": [
            "node",
            "browser"
        ]
    },
    "insertionSort": {
        "dependencies": [
            "swap",
            "isSorted"
        ],
        "description": "Insertion sort implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "intersect": {
        "dependencies": [
            "contain",
            "toArr"
        ],
        "description": "Compute the list of values that are the intersection of all the arrays.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "intersectRange": {
        "dependencies": [],
        "description": "Intersect two ranges.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "invariant": {
        "dependencies": [
            "root"
        ],
        "description": "Facebook's invariant.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.17.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "invert": {
        "dependencies": [
            "each"
        ],
        "description": "Create an object composed of the inverted keys and values of object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isAbsoluteUrl": {
        "dependencies": [],
        "description": "Check if an url is absolute.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isArgs": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is classified as an arguments object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isArr": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is an `Array` object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isArrBuffer": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is an ArrayBuffer.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isArrLike": {
        "dependencies": [
            "isNum",
            "isFn"
        ],
        "description": "Check if value is array-like.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isAsyncFn": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is an async function.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.17.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "isBlob": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is a Blob.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "isBool": {
        "dependencies": [],
        "description": "Check if value is a boolean primitive.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isBrowser": {
        "dependencies": [],
        "description": "Check if running in a browser.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isBuffer": {
        "dependencies": [
            "isFn"
        ],
        "description": "Check if value is a buffer.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node"
        ]
    },
    "isClose": {
        "dependencies": [
            "isNum"
        ],
        "description": "Check if values are close(almost equal) to each other.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isCyclic": {
        "benchmark": true,
        "dependencies": [
            "Class",
            "keys",
            "isObj"
        ],
        "description": "Detect cyclic object reference.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.30.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "isDarkMode": {
        "dependencies": [
            "MediaQuery"
        ],
        "description": "Detect dark mode.",
        "env": [
            "browser"
        ],
        "since": "1.19.0",
        "test": [
            "browser"
        ]
    },
    "isDataUrl": {
        "dependencies": [
            "trim"
        ],
        "description": "Check if a string is a valid data url.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isDate": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is classified as a Date object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isDir": {
        "dependencies": [
            "root"
        ],
        "description": "Check if a path is directory.",
        "env": [
            "node"
        ],
        "since": "1.28.0",
        "test": [
            "node"
        ]
    },
    "isDocker": {
        "dependencies": [
            "memoize",
            "contain"
        ],
        "description": "Check if the process is running inside a docker container.",
        "env": [
            "node"
        ],
        "since": "1.35.0",
        "test": [
            "node"
        ]
    },
    "isEl": {
        "dependencies": [],
        "description": "Check if value is a DOM element.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "isEmail": {
        "dependencies": [],
        "description": "Loosely validate an email address.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isEmpty": {
        "dependencies": [
            "isArrLike",
            "isArr",
            "isStr",
            "isArgs",
            "keys"
        ],
        "description": "Check if value is an empty object or array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isEqual": {
        "dependencies": [
            "isFn",
            "has",
            "keys"
        ],
        "description": "Performs an optimized deep comparison between the two objects, to determine if they should be considered equal.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isErr": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is an error.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isEven": {
        "dependencies": [
            "isInt"
        ],
        "description": "Check if number is even.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isFile": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is a file.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "isFinite": {
        "dependencies": [
            "root"
        ],
        "description": "Check if value is a finite primitive number.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isFn": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is a function.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isFullWidth": {
        "dependencies": [
            "isInt"
        ],
        "description": "Check if character is full width.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.24.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "isGeneratorFn": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is a generator function.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isHidden": {
        "dependencies": [
            "root"
        ],
        "description": "Check if element is hidden.",
        "env": [
            "browser"
        ],
        "since": "1.18.0",
        "test": [
            "browser"
        ]
    },
    "isInt": {
        "dependencies": [
            "isNum"
        ],
        "description": "Checks if value is classified as a Integer.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isIp": {
        "dependencies": [],
        "description": "Check if value is an IP address.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.1",
        "test": [
            "node",
            "browser"
        ]
    },
    "isJson": {
        "dependencies": [],
        "description": "Check if value is a valid JSON.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isLeapYear": {
        "dependencies": [],
        "description": "Check if a year is a leap year.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isMac": {
        "dependencies": [
            "detectOs"
        ],
        "description": "Check if platform is mac.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.40.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "isMap": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is a Map object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isMatch": {
        "dependencies": [
            "keys"
        ],
        "description": "Check if keys and values in src are contained in obj.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isMiniProgram": {
        "dependencies": [
            "isFn"
        ],
        "description": "Check if running in wechat mini program.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isMobile": {
        "dependencies": [
            "isBrowser",
            "memoize"
        ],
        "description": "Check whether client is using a mobile browser using ua.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isNaN": {
        "dependencies": [
            "isNum"
        ],
        "description": "Check if value is an NaN.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isNative": {
        "dependencies": [
            "isObj",
            "isFn",
            "toSrc"
        ],
        "description": "Check if value is a native function.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isNil": {
        "dependencies": [],
        "description": "Check if value is null or undefined, the same as value == null.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isNode": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if running in node.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isNull": {
        "dependencies": [],
        "description": "Check if value is an Null.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isNum": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is classified as a Number primitive or object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isNumeric": {
        "dependencies": [
            "isStr",
            "isNaN",
            "isFinite",
            "isArr"
        ],
        "description": "Check if value is numeric.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isObj": {
        "dependencies": [],
        "description": "Check if value is the language type of Object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isOdd": {
        "dependencies": [
            "isInt"
        ],
        "description": "Check if number is odd.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isPlainObj": {
        "dependencies": [
            "isObj",
            "isArr",
            "isFn",
            "has"
        ],
        "description": "Check if value is an object created by Object constructor.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isPortFree": {
        "dependencies": [],
        "description": "Check if a TCP port is free.",
        "env": [
            "node"
        ],
        "since": "1.5.2",
        "test": [
            "node"
        ]
    },
    "isPrime": {
        "dependencies": [],
        "description": "Check if the provided integer is a prime number.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.2.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "isPrimitive": {
        "dependencies": [],
        "description": "Check if value is string, number, boolean or null.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isPromise": {
        "dependencies": [
            "isObj",
            "isFn"
        ],
        "description": "Check if value looks like a promise.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isRegExp": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is a regular expression.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isRelative": {
        "dependencies": [],
        "description": "Check if path appears to be relative.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isRetina": {
        "dependencies": [
            "isBrowser"
        ],
        "description": "Determine if running on a high DPR device or not.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "isRunning": {
        "dependencies": [],
        "description": "Check if process is running.",
        "env": [
            "node"
        ],
        "since": "1.22.0",
        "test": [
            "node"
        ]
    },
    "isSet": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is a Set object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isShadowRoot": {
        "dependencies": [],
        "description": "Check if value is a ShadowRoot object.",
        "env": [
            "browser"
        ],
        "since": "1.43.0",
        "test": [
            "browser"
        ]
    },
    "isSorted": {
        "dependencies": [],
        "description": "Check if an array is sorted.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isStr": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is a string primitive.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isStrBlank": {
        "benchmark": true,
        "dependencies": [],
        "description": "Check if string is blank.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.39.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "isStream": {
        "dependencies": [
            "isObj",
            "isFn"
        ],
        "description": "Check if value is a Node.js stream.",
        "env": [
            "node"
        ],
        "test": [
            "node"
        ]
    },
    "isSymbol": {
        "dependencies": [],
        "description": "Check if value is a symbol.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.5",
        "test": [
            "node",
            "browser"
        ]
    },
    "isTypedArr": {
        "dependencies": [
            "objToStr",
            "each"
        ],
        "description": "Check if value is a typed array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isUndef": {
        "dependencies": [],
        "description": "Check if value is undefined.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isUrl": {
        "dependencies": [],
        "description": "Loosely validate an url.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isWeakMap": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is a WeakMap object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isWeakSet": {
        "dependencies": [
            "objToStr"
        ],
        "description": "Check if value is a WeakSet object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "isWindows": {
        "dependencies": [
            "detectOs"
        ],
        "description": "Check if platform is windows.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "jsonClone": {
        "dependencies": [],
        "description": "Use JSON parse and stringify to clone object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.12.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "jsonp": {
        "dependencies": [
            "loadJs",
            "defaults",
            "noop",
            "uniqId",
            "query"
        ],
        "description": "A simple jsonp implementation.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "kebabCase": {
        "dependencies": [
            "splitCase"
        ],
        "description": "Convert string to \"kebabCase\".",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "keyCode": {
        "dependencies": [
            "isStr",
            "invert"
        ],
        "description": "Key codes and key names conversion.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "keys": {
        "dependencies": [
            "has"
        ],
        "description": "Create an array of the own enumerable property names of object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "kill": {
        "dependencies": [
            "isWindows"
        ],
        "description": "Kill process.",
        "env": [
            "node"
        ],
        "since": "1.4.4",
        "test": [
            "node"
        ]
    },
    "last": {
        "dependencies": [],
        "description": "Get the last element of array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "lazyImport": {
        "dependencies": [
            "stackTrace",
            "splitPath",
            "startWith",
            "endWith",
            "defineProp",
            "isStr",
            "has",
            "objToStr",
            "unique",
            "concat",
            "keys",
            "isArr",
            "toBool"
        ],
        "description": "Import modules lazily, Proxy is used.",
        "env": [
            "node"
        ],
        "since": "1.31.0",
        "test": [
            "node"
        ]
    },
    "lazyRequire": {
        "dependencies": [],
        "description": "Require modules lazily.",
        "env": [
            "node"
        ],
        "test": [
            "node"
        ]
    },
    "levenshtein": {
        "dependencies": [],
        "description": "Levenshtein distance implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.4.8",
        "test": [
            "node",
            "browser"
        ]
    },
    "linkify": {
        "dependencies": [
            "extractUrls",
            "each",
            "escapeRegExp"
        ],
        "description": "Hyperlink urls in a string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "loadCss": {
        "dependencies": [
            "noop"
        ],
        "description": "Inject link tag into page with given href value.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "loadImg": {
        "dependencies": [
            "noop"
        ],
        "description": "Load image with given src.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "loadJs": {
        "dependencies": [],
        "description": "Inject script tag into page with given src value.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "longest": {
        "dependencies": [
            "size"
        ],
        "description": "Get the longest item in an array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "lowerCase": {
        "dependencies": [
            "toStr"
        ],
        "description": "Convert string to lower case.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "lpad": {
        "dependencies": [
            "repeat",
            "toStr"
        ],
        "description": "Pad string on the left side if it's shorter than length.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "ltrim": {
        "dependencies": [],
        "description": "Remove chars or white-spaces from beginning of string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "map": {
        "dependencies": [
            "safeCb",
            "keys",
            "isArrLike"
        ],
        "description": "Create an array of values by running each element in collection through iteratee.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "mapObj": {
        "dependencies": [
            "safeCb",
            "keys"
        ],
        "description": "Map for objects.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "matcher": {
        "dependencies": [
            "extendOwn",
            "isMatch"
        ],
        "description": "Return a predicate function that checks if attrs are contained in an object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "max": {
        "dependencies": [],
        "description": "Get maximum value of given numbers.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "md5": {
        "benchmark": true,
        "dependencies": [
            "isStr",
            "strToBytes",
            "hex",
            "bytesToWords",
            "wordsToBytes",
            "isNode",
            "isArr"
        ],
        "description": "MD5 implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.1.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "memStorage": {
        "dependencies": [
            "keys"
        ],
        "description": "Memory-backed implementation of the Web Storage API.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "memoize": {
        "dependencies": [
            "has"
        ],
        "description": "Memoize a given function by caching the computed result.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "mergeArr": {
        "dependencies": [
            "restArgs"
        ],
        "description": "Merge the contents of arrays together into the first array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.24.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "mergeSort": {
        "dependencies": [
            "isSorted"
        ],
        "description": "Merge sort implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "meta": {
        "dependencies": [
            "each",
            "isStr",
            "isUndef",
            "contain",
            "isArr",
            "isObj",
            "toArr"
        ],
        "description": "Document meta manipulation, turn name and content into key value pairs.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "methods": {
        "dependencies": [
            "isFn"
        ],
        "description": "Return a sorted list of the names of every method in an object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "mime": {
        "dependencies": [
            "each"
        ],
        "description": "Common mime types.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "min": {
        "dependencies": [],
        "description": "Get minimum value of given numbers.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "mkdir": {
        "dependencies": [
            "isFn",
            "noop"
        ],
        "description": "Recursively create directories.",
        "env": [
            "node"
        ],
        "test": [
            "node"
        ]
    },
    "moment": {
        "dependencies": [
            "Class",
            "toDate",
            "dateFormat",
            "isLeapYear",
            "extend",
            "toStr",
            "isNil",
            "ms"
        ],
        "description": "Tiny moment.js like implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": []
    },
    "morphDom": {
        "dependencies": [
            "toEl",
            "isStr",
            "h",
            "isNull",
            "each"
        ],
        "description": "Morph a dom tree to match a target dom tree.",
        "env": [
            "browser"
        ],
        "since": "1.25.0",
        "test": [
            "browser"
        ]
    },
    "morse": {
        "dependencies": [
            "upperCase",
            "invert"
        ],
        "description": "Morse code encoding and decoding.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.19.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "ms": {
        "dependencies": [
            "toNum",
            "isStr"
        ],
        "description": "Convert time string formats to milliseconds.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "naturalSort": {
        "dependencies": [
            "startWith",
            "root",
            "toStr"
        ],
        "description": "Sort values in natural order.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.30.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "negate": {
        "dependencies": [],
        "description": "Create a function that negates the result of the predicate function.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "nextTick": {
        "dependencies": [],
        "description": "Next tick for both node and browser.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "noop": {
        "dependencies": [],
        "description": "A no-operation function.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "normalizeHeader": {
        "dependencies": [
            "map",
            "capitalize"
        ],
        "description": "Normalize http header name.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.2.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "normalizePath": {
        "dependencies": [],
        "description": "Normalize file path slashes.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "normalizePhone": {
        "dependencies": [
            "trim"
        ],
        "description": "Normalize phone numbers into E.164 format.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.13.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "notify": {
        "demo": true,
        "dependencies": [
            "Emitter",
            "root",
            "each"
        ],
        "description": "Wrapper for the Web Notifications API.",
        "env": [
            "browser"
        ],
        "since": "1.14.0",
        "test": [
            "browser"
        ]
    },
    "now": {
        "dependencies": [],
        "description": "Gets the number of milliseconds that have elapsed since the Unix epoch.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "objToStr": {
        "dependencies": [],
        "description": "Alias of Object.prototype.toString.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "omit": {
        "dependencies": [
            "pick"
        ],
        "description": "Opposite of pick.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "once": {
        "dependencies": [
            "partial",
            "before"
        ],
        "description": "Create a function that invokes once.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "open": {
        "dependencies": [
            "isWindows"
        ],
        "description": "Open stuff like url, files.",
        "env": [
            "node"
        ],
        "since": "1.2.0",
        "test": []
    },
    "openFile": {
        "demo": true,
        "dependencies": [],
        "description": "Open file dialog to select file in browser.",
        "env": [
            "browser"
        ],
        "since": "1.3.0",
        "test": [
            "browser"
        ]
    },
    "optimizeCb": {
        "dependencies": [
            "isUndef"
        ],
        "description": "Used for function context binding.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "ordinal": {
        "dependencies": [],
        "description": "Add ordinal indicator to number.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.2",
        "test": [
            "node",
            "browser"
        ]
    },
    "orientation": {
        "demo": true,
        "dependencies": [
            "Emitter",
            "safeGet"
        ],
        "description": "Screen orientation helper.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "pad": {
        "dependencies": [
            "repeat",
            "toStr"
        ],
        "description": "Pad string on the left and right sides if it's shorter than length.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "pairs": {
        "dependencies": [
            "keys"
        ],
        "description": "Convert an object into a list of [key, value] pairs.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "parallel": {
        "dependencies": [
            "noop",
            "each",
            "nextTick"
        ],
        "description": "Run an array of functions in parallel.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "parseArgs": {
        "dependencies": [
            "defaults",
            "toNum",
            "invert",
            "toBool"
        ],
        "description": "Parse command line argument options, the same as minimist.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "parseHtml": {
        "dependencies": [
            "last",
            "arrToMap",
            "startWith",
            "lowerCase"
        ],
        "description": "Simple html parser.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.6.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "partial": {
        "dependencies": [
            "restArgs",
            "toArr"
        ],
        "description": "Partially apply a function by filling in given arguments.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "pascalCase": {
        "dependencies": [
            "camelCase",
            "upperFirst"
        ],
        "description": "Convert string to \"pascalCase\".",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "perfNow": {
        "dependencies": [
            "now",
            "root"
        ],
        "description": "High resolution time up to microsecond precision.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "pick": {
        "dependencies": [
            "isStr",
            "isArr",
            "contain",
            "each"
        ],
        "description": "Return a filtered copy of an object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "pipe": {
        "dependencies": [
            "reduce"
        ],
        "description": "Pipe all streams together.",
        "env": [
            "node"
        ],
        "since": "1.23.0",
        "test": [
            "node"
        ]
    },
    "pluck": {
        "dependencies": [
            "map",
            "property"
        ],
        "description": "Extract a list of property values.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "pointerEvent": {
        "dependencies": [
            "root"
        ],
        "description": "Get the pointer event name, use touch and mouse events as a fallback if not supported.",
        "env": [
            "browser"
        ],
        "since": "1.42.0",
        "test": [
            "browser"
        ]
    },
    "precision": {
        "dependencies": [],
        "description": "Find decimal precision of a given number.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "prefetch": {
        "demo": true,
        "dependencies": [],
        "description": "Fetch a given url.",
        "env": [
            "browser"
        ],
        "since": "1.4.0",
        "test": [
            "browser"
        ]
    },
    "prefix": {
        "dependencies": [
            "memoize",
            "camelCase",
            "upperFirst",
            "has",
            "kebabCase"
        ],
        "description": "Add vendor prefixes to a CSS attribute.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "promisify": {
        "dependencies": [
            "restArgs",
            "root"
        ],
        "description": "Convert callback based functions into Promises.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "property": {
        "dependencies": [
            "isArr",
            "safeGet"
        ],
        "description": "Return a function that will itself return the key property of any passed-in object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "query": {
        "dependencies": [
            "trim",
            "each",
            "isUndef",
            "isArr",
            "map",
            "isEmpty",
            "filter",
            "isObj"
        ],
        "description": "Parse and stringify url query strings.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "quickSort": {
        "benchmark": true,
        "dependencies": [
            "swap",
            "isSorted"
        ],
        "description": "Quick sort implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "raf": {
        "dependencies": [
            "now",
            "isBrowser"
        ],
        "description": "Shortcut for requestAnimationFrame.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "random": {
        "dependencies": [],
        "description": "Produces a random number between min and max(inclusive).",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "randomBytes": {
        "dependencies": [
            "random",
            "isBrowser",
            "isNode"
        ],
        "description": "Random bytes generator.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "randomColor": {
        "demo": true,
        "dependencies": [
            "defaults",
            "random",
            "Color",
            "seedRandom",
            "isFn"
        ],
        "description": "Random color generator.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.12.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "randomId": {
        "dependencies": [
            "randomBytes"
        ],
        "description": "A tiny id generator, similar to nanoid.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.4.8",
        "test": [
            "node",
            "browser"
        ]
    },
    "randomItem": {
        "dependencies": [
            "random"
        ],
        "description": "Get a random item from an array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "range": {
        "dependencies": [],
        "description": "Create flexibly-numbered lists of integers.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "rc4": {
        "dependencies": [
            "base64",
            "bytesToStr",
            "strToBytes"
        ],
        "description": "RC4 symmetric encryption implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.1.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "ready": {
        "dependencies": [],
        "description": "Invoke callback when dom is ready, similar to jQuery ready.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "reduce": {
        "benchmark": true,
        "dependencies": [
            "optimizeCb",
            "isArrLike",
            "isUndef",
            "keys"
        ],
        "description": "Turn a list of values into a single value.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "reduceRight": {
        "dependencies": [
            "reduce"
        ],
        "description": "Right-associative version of reduce.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "reject": {
        "dependencies": [
            "safeCb",
            "negate",
            "filter"
        ],
        "description": "Opposite of filter.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "remove": {
        "dependencies": [
            "safeCb"
        ],
        "description": "Remove all elements from array that predicate returns truthy for and return an array of the removed elements.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "repeat": {
        "dependencies": [],
        "description": "Repeat string n-times.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "replaceAll": {
        "dependencies": [
            "escapeRegExp"
        ],
        "description": "Replace all instance in a string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.23.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "restArgs": {
        "dependencies": [],
        "description": "This accumulates the arguments passed into an array, after a given index.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "reverse": {
        "benchmark": true,
        "dependencies": [],
        "description": "Reverse array without mutating it.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.16.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "rgbToHsl": {
        "dependencies": [],
        "description": "Convert rgb to hsl.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "ric": {
        "dependencies": [
            "root",
            "now"
        ],
        "description": "Shortcut for requestIdleCallback.",
        "env": [
            "browser"
        ],
        "since": "1.4.0",
        "test": []
    },
    "rmCookie": {
        "dependencies": [
            "cookie"
        ],
        "description": "Loop through all possible path and domain to remove cookie.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "rmdir": {
        "dependencies": [
            "noop",
            "parallel"
        ],
        "description": "Recursively remove directories.",
        "env": [
            "node"
        ],
        "test": [
            "node"
        ]
    },
    "root": {
        "dependencies": [
            "isBrowser"
        ],
        "description": "Root object reference, `global` in nodeJs, `window` in browser.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "rpad": {
        "dependencies": [
            "repeat",
            "toStr"
        ],
        "description": "Pad string on the right side if it's shorter than length.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "rtrim": {
        "dependencies": [],
        "description": "Remove chars or white-spaces from end of string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "safeCb": {
        "dependencies": [
            "isFn",
            "isObj",
            "isArr",
            "optimizeCb",
            "matcher",
            "identity",
            "property"
        ],
        "description": "Create callback based on input value.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "safeDel": {
        "dependencies": [
            "isUndef",
            "castPath"
        ],
        "description": "Delete object property.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "safeGet": {
        "dependencies": [
            "isUndef",
            "castPath"
        ],
        "description": "Get object property, don't throw undefined error.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "safeSet": {
        "dependencies": [
            "castPath",
            "isUndef",
            "toStr",
            "isSymbol",
            "isStr"
        ],
        "description": "Set value at path of object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "safeStorage": {
        "dependencies": [
            "memStorage"
        ],
        "description": "Use storage safely in safari private browsing and older browsers.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "sameOrigin": {
        "dependencies": [
            "Url"
        ],
        "description": "Check if two urls pass the same origin policy.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.26.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "sample": {
        "dependencies": [
            "isArrLike",
            "clone",
            "values",
            "random",
            "swap"
        ],
        "description": "Sample random values from a collection.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "scrollTo": {
        "demo": true,
        "dependencies": [
            "Tween",
            "defaults",
            "noop",
            "isNum",
            "$offset"
        ],
        "description": "Scroll to a target with animation.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "seedRandom": {
        "dependencies": [],
        "description": "Seeded random number generator.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.12.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "selectionSort": {
        "dependencies": [
            "swap",
            "isSorted"
        ],
        "description": "Selection sort implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "selector": {
        "dependencies": [
            "trim",
            "each",
            "identity",
            "map"
        ],
        "description": "Css selector parser and serializer.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.14.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "shebang": {
        "dependencies": [
            "trim"
        ],
        "description": "Get command from a shebang.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.23.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "shellSort": {
        "dependencies": [
            "swap",
            "isSorted"
        ],
        "description": "Shell sort implementation.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "shuffle": {
        "dependencies": [
            "sample"
        ],
        "description": "Randomize the order of the elements in a given array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "size": {
        "dependencies": [
            "isArrLike",
            "keys"
        ],
        "description": "Get size of object or length of array like object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "sizeof": {
        "dependencies": [
            "isArr",
            "keys",
            "isBuffer",
            "isNull"
        ],
        "description": "Get approximate size of a js object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.14.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "sleep": {
        "dependencies": [],
        "description": "Resolve a promise after a specified timeout.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.4.1",
        "test": [
            "node",
            "browser"
        ]
    },
    "slice": {
        "dependencies": [],
        "description": "Create slice of source array or array-like object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "slugify": {
        "dependencies": [
            "defaults",
            "each",
            "reduce"
        ],
        "description": "Slugify a string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.7.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "snakeCase": {
        "dependencies": [
            "splitCase"
        ],
        "description": "Convert string to \"snakeCase\".",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "some": {
        "dependencies": [
            "safeCb",
            "isArrLike",
            "keys"
        ],
        "description": "Check if predicate return truthy for any element.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "sortBy": {
        "dependencies": [
            "safeCb",
            "pluck",
            "map",
            "isUndef"
        ],
        "description": "Return an array of elements sorted in ascending order by results of running each element through iteratee.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "sortKeys": {
        "dependencies": [
            "isSorted",
            "defaults",
            "keys",
            "isArr",
            "isObj"
        ],
        "description": "Sort keys of an object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.17.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "spaceCase": {
        "dependencies": [
            "splitCase"
        ],
        "description": "Convert string to \"spaceCase\".",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "splitCase": {
        "dependencies": [],
        "description": "Split different string case to an array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "splitPath": {
        "dependencies": [],
        "description": "Split path into dir, name and ext.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "stackTrace": {
        "dependencies": [],
        "description": "Get CallSite objects in v8.",
        "env": [
            "node",
            "browser"
        ],
        "since": "1.5.3",
        "test": [
            "node",
            "browser"
        ]
    },
    "startWith": {
        "dependencies": [],
        "description": "Check if string starts with the given target string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "strHash": {
        "dependencies": [],
        "description": "String hash function using djb2.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "strToBytes": {
        "dependencies": [
            "utf8",
            "hex",
            "base64"
        ],
        "description": "Convert string into bytes.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.1.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "strTpl": {
        "dependencies": [
            "safeGet",
            "toStr"
        ],
        "description": "Simple string template.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.23.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "strWidth": {
        "dependencies": [
            "stripAnsi",
            "isFullWidth"
        ],
        "description": "Get string's visual width.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.24.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "stringify": {
        "dependencies": [
            "type",
            "upperFirst",
            "toStr",
            "isUndef",
            "isFn",
            "isRegExp"
        ],
        "description": "JSON stringify with support for circular object, function etc.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "stringifyAll": {
        "demo": true,
        "dependencies": [
            "escapeJsStr",
            "type",
            "toStr",
            "endWith",
            "toSrc",
            "keys",
            "each",
            "Class",
            "getProto",
            "difference",
            "extend",
            "isPromise",
            "filter",
            "now",
            "allKeys",
            "contain",
            "isObj",
            "isMiniProgram",
            "create",
            "startWith",
            "safeSet",
            "defineProp",
            "pick",
            "isArrLike"
        ],
        "description": "Stringify object into json with types.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.5",
        "test": [
            "node",
            "browser"
        ]
    },
    "stripAnsi": {
        "dependencies": [],
        "description": "Strip ansi codes from a string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "stripBom": {
        "dependencies": [],
        "description": "Strip UTF-8 byte order mark.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.38.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "stripCmt": {
        "dependencies": [],
        "description": "Strip comments from source code.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "stripColor": {
        "dependencies": [],
        "description": "Strip ansi color codes from a string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "stripHtmlTag": {
        "dependencies": [],
        "description": "Strip html tags from a string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "stripIndent": {
        "dependencies": [
            "isStr",
            "toArr",
            "min",
            "map",
            "trim"
        ],
        "description": "Strip indentation from multi-line strings.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.5.4",
        "test": [
            "node",
            "browser"
        ]
    },
    "stripNum": {
        "dependencies": [],
        "description": "Strip number to a specified precision.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.15.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "sum": {
        "dependencies": [],
        "description": "Compute sum of given numbers.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "swap": {
        "dependencies": [],
        "description": "Swap two items in an array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "table": {
        "dependencies": [
            "each",
            "strWidth",
            "map",
            "repeat",
            "cloneDeep"
        ],
        "description": "Output table string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.24.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "template": {
        "dependencies": [
            "escape",
            "defaults",
            "escapeJsStr"
        ],
        "description": "Compile JavaScript template into function that can be evaluated for rendering.",
        "env": [
            "node",
            "browser"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "throttle": {
        "dependencies": [
            "debounce"
        ],
        "description": "Return a new throttled version of the passed function.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "through": {
        "dependencies": [
            "isFn",
            "extend",
            "inherits"
        ],
        "description": "Tiny wrapper of stream Transform.",
        "env": [
            "node"
        ],
        "test": [
            "node"
        ]
    },
    "tildify": {
        "dependencies": [
            "startWith"
        ],
        "description": "Convert absolute path to tilde path.",
        "env": [
            "node"
        ],
        "since": "1.40.0",
        "test": [
            "node"
        ]
    },
    "timeAgo": {
        "dependencies": [
            "isDate",
            "toInt"
        ],
        "description": "Format datetime with *** time ago statement.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "timeTaken": {
        "dependencies": [
            "perfNow"
        ],
        "description": "Get execution time of a function.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "times": {
        "dependencies": [
            "optimizeCb"
        ],
        "description": "Invoke given function n times.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.2.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "toArr": {
        "dependencies": [
            "isArrLike",
            "map",
            "isArr",
            "isStr"
        ],
        "description": "Convert value to an array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "toAsync": {
        "dependencies": [
            "toArr",
            "isGeneratorFn",
            "isPromise",
            "toStr"
        ],
        "description": "Use generator like async/await.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.8.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "toBool": {
        "dependencies": [
            "isStr"
        ],
        "description": "Convert value to a boolean.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "toDate": {
        "dependencies": [
            "isDate",
            "isStr"
        ],
        "description": "Convert value to a Date.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "toEl": {
        "dependencies": [],
        "description": "Convert html string to dom elements.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "toInt": {
        "dependencies": [
            "toNum"
        ],
        "description": "Convert value to an integer.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "toNum": {
        "dependencies": [
            "isNum",
            "isObj",
            "isFn",
            "isStr"
        ],
        "description": "Convert value to a number.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "toSrc": {
        "dependencies": [
            "isNil"
        ],
        "description": "Convert function to its source code.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "toStr": {
        "dependencies": [],
        "description": "Convert value to a string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "topoSort": {
        "dependencies": [],
        "description": "Topological sorting algorithm.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "trigger": {
        "dependencies": [
            "isStr",
            "defaults",
            "extend"
        ],
        "description": "Trigger browser events.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "trim": {
        "benchmark": true,
        "dependencies": [
            "ltrim",
            "rtrim"
        ],
        "description": "Remove chars or white-spaces from beginning end of string.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "truncate": {
        "dependencies": [
            "defaults",
            "isUndef"
        ],
        "description": "Truncate a string to a specific width.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.20.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "tryIt": {
        "dependencies": [
            "noop"
        ],
        "description": "Run function in a try catch.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "type": {
        "dependencies": [
            "objToStr",
            "isNaN",
            "lowerCase",
            "isBuffer"
        ],
        "description": "Determine the internal JavaScript [[Class]] of an object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "types": {
        "dependencies": [],
        "description": "Used for typescript definitions only.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": []
    },
    "ucs2": {
        "dependencies": [
            "chunk",
            "map"
        ],
        "description": "UCS-2 encoding and decoding.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "uncaught": {
        "demo": true,
        "dependencies": [
            "isBrowser",
            "SingleEmitter"
        ],
        "description": "Handle global uncaught errors and promise rejections.",
        "env": [
            "node",
            "browser"
        ],
        "since": "1.2.0",
        "test": []
    },
    "unescape": {
        "dependencies": [
            "escape",
            "keys",
            "invert"
        ],
        "description": "Convert HTML entities back, the inverse of escape.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "union": {
        "dependencies": [
            "restArgs",
            "unique",
            "flatten"
        ],
        "description": "Create an array of unique values, in order, from all given arrays.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "uniqId": {
        "dependencies": [],
        "description": "Generate a globally-unique id.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "unique": {
        "dependencies": [
            "filter"
        ],
        "description": "Create duplicate-free version of an array.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "universalify": {
        "dependencies": [
            "promisify",
            "callbackify",
            "last",
            "isFn"
        ],
        "description": "Make an async function support both promises and callbacks.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.7.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "unzip": {
        "dependencies": [
            "map",
            "pluck",
            "max"
        ],
        "description": "Opposite of zip.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "upperCase": {
        "dependencies": [
            "toStr"
        ],
        "description": "Convert string to upper case.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "upperFirst": {
        "dependencies": [],
        "description": "Convert the first character of string to upper case.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "use": {
        "dependencies": [
            "map",
            "define",
            "has",
            "toArr"
        ],
        "description": "Use modules that is created by define.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "utf8": {
        "dependencies": [
            "ucs2"
        ],
        "description": "UTF-8 encoding and decoding.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "uuid": {
        "benchmark": true,
        "dependencies": [
            "randomBytes"
        ],
        "description": "RFC4122 version 4 compliant uuid generator.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "values": {
        "dependencies": [
            "each"
        ],
        "description": "Create an array of the own enumerable property values of object.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "viewportScale": {
        "dependencies": [
            "meta",
            "clamp",
            "trim",
            "each",
            "map",
            "isNaN"
        ],
        "description": "Get viewport scale.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "vlq": {
        "dependencies": [
            "toArr"
        ],
        "description": "Variable-length quantity encoding and decoding.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.4.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "waitUntil": {
        "dependencies": [
            "now"
        ],
        "description": "Wait until function returns a truthy value.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.4.3",
        "test": [
            "node",
            "browser"
        ]
    },
    "waterfall": {
        "dependencies": [
            "noop",
            "nextTick",
            "restArgs"
        ],
        "description": "Run an array of functions in series.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "wordWrap": {
        "dependencies": [
            "map",
            "reduce",
            "concat",
            "last",
            "trim"
        ],
        "description": "Wrap a string to a given length.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.27.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "wordsToBytes": {
        "dependencies": [],
        "description": "Convert 32-bit words to bytes.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "since": "1.16.0",
        "test": [
            "node",
            "browser"
        ]
    },
    "workerize": {
        "demo": true,
        "dependencies": [
            "restArgs",
            "uniqId",
            "toSrc",
            "createUrl",
            "isStr",
            "root"
        ],
        "description": "Move a stand-alone function to a worker thread.",
        "env": [
            "browser"
        ],
        "test": [
            "browser"
        ]
    },
    "wrap": {
        "dependencies": [
            "partial"
        ],
        "description": "Wrap the function inside a wrapper function, passing it as the first argument.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    },
    "wx": {
        "dependencies": [
            "each",
            "arrToMap",
            "startWith",
            "endWith",
            "extend"
        ],
        "description": "Promised version of mini program wx object.",
        "env": [
            "miniprogram"
        ],
        "since": "1.4.6",
        "test": []
    },
    "xpath": {
        "dependencies": [],
        "description": "Select elements using xpath, IE is not supported.",
        "env": [
            "browser"
        ],
        "since": "1.10.0",
        "test": [
            "browser"
        ]
    },
    "zip": {
        "dependencies": [
            "restArgs",
            "unzip"
        ],
        "description": "Merge together the values of each of the arrays with the values at the corresponding position.",
        "env": [
            "node",
            "browser",
            "miniprogram"
        ],
        "test": [
            "node",
            "browser"
        ]
    }
}