@umijs/utils 3.5.18 → 4.0.0-beta.2

package/compiled/cheerio/lib/index.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The main types of Cheerio objects.
+ *
+ * @category Cheerio
+ */
+export type { Cheerio } from './cheerio';
+/**
+ * Types used in signatures of Cheerio methods.
+ *
+ * @category Cheerio
+ */
+export * from './types';
+export type { CheerioOptions, HTMLParser2Options, Parse5Options, } from './options';
+/**
+ * Re-exporting all of the node types.
+ *
+ * @category DOM Node
+ */
+export type { Node, NodeWithChildren, Element, Document } from 'domhandler';
+export * from './load';
+declare const _default: import('./load').CheerioAPI;
+/**
+ * The default cheerio instance.
+ *
+ * @deprecated Use the function returned by `load` instead.
+ */
+export default _default;
+import * as staticMethods from './static';
+/**
+ * In order to promote consistency with the jQuery library, users are encouraged
+ * to instead use the static method of the same name.
+ *
+ * @deprecated
+ * @example
+ *
+ * ```js
+ * const $ = cheerio.load('<div><p></p></div>');
+ *
+ * $.contains($('div').get(0), $('p').get(0));
+ * //=> true
+ *
+ * $.contains($('p').get(0), $('div').get(0));
+ * //=> false
+ * ```
+ *
+ * @returns {boolean}
+ */
+export declare const contains: typeof staticMethods.contains;
+/**
+ * In order to promote consistency with the jQuery library, users are encouraged
+ * to instead use the static method of the same name.
+ *
+ * @deprecated
+ * @example
+ *
+ * ```js
+ * const $ = cheerio.load('');
+ *
+ * $.merge([1, 2], [3, 4]);
+ * //=> [1, 2, 3, 4]
+ * ```
+ */
+export declare const merge: typeof staticMethods.merge;
+/**
+ * In order to promote consistency with the jQuery library, users are encouraged
+ * to instead use the static method of the same name as it is defined on the
+ * "loaded" Cheerio factory function.
+ *
+ * @deprecated See {@link static/parseHTML}.
+ * @example
+ *
+ * ```js
+ * const $ = cheerio.load('');
+ * $.parseHTML('<b>markup</b>');
+ * ```
+ */
+export declare const parseHTML: typeof staticMethods.parseHTML;
+/**
+ * Users seeking to access the top-level element of a parsed document should
+ * instead use the `root` static method of a "loaded" Cheerio function.
+ *
+ * @deprecated
+ * @example
+ *
+ * ```js
+ * const $ = cheerio.load('');
+ * $.root();
+ * ```
+ */
+export declare const root: typeof staticMethods.root;
+//# sourceMappingURL=index.d.ts.map

package/compiled/cheerio/lib/load.d.ts

@@ -0,0 +1,73 @@
+/// <reference types="node" />
+import { CheerioOptions, InternalOptions } from './options';
+import * as staticMethods from './static';
+import { Cheerio } from './cheerio';
+import type { Node, Document, Element } from '../domhandler';
+import type * as Load from './load';
+import { SelectorType, BasicAcceptedElems } from './types';
+declare type StaticType = typeof staticMethods;
+declare type LoadType = typeof Load;
+/**
+ * A querying function, bound to a document created from the provided markup.
+ *
+ * Also provides several helper methods for dealing with the document as a whole.
+ */
+export interface CheerioAPI extends StaticType, LoadType {
+    /**
+     * This selector method is the starting point for traversing and manipulating
+     * the document. Like jQuery, it's the primary method for selecting elements
+     * in the document.
+     *
+     * `selector` searches within the `context` scope which searches within the
+     * `root` scope.
+     *
+     * @example
+     *
+     * ```js
+     * $('.apple', '#fruits').text();
+     * //=> Apple
+     *
+     * $('ul .pear').attr('class');
+     * //=> pear
+     *
+     * $('li[class=orange]').html();
+     * //=> Orange
+     * ```
+     *
+     * @param selector - Either a selector to look for within the document, or the
+     *   contents of a new Cheerio instance.
+     * @param context - Either a selector to look for within the root, or the
+     *   contents of the document to query.
+     * @param root - Optional HTML document string.
+     */
+    <T extends Node, S extends string>(selector?: S | BasicAcceptedElems<T>, context?: BasicAcceptedElems<Node> | null, root?: BasicAcceptedElems<Document>, options?: CheerioOptions): Cheerio<S extends SelectorType ? Element : T>;
+    /**
+     * The root the document was originally loaded with.
+     *
+     * @private
+     */
+    _root: Document;
+    /**
+     * The options the document was originally loaded with.
+     *
+     * @private
+     */
+    _options: InternalOptions;
+    /** Mimic jQuery's prototype alias for plugin authors. */
+    fn: typeof Cheerio.prototype;
+}
+/**
+ * Create a querying function, bound to a document created from the provided
+ * markup. Note that similar to web browser contexts, this operation may
+ * introduce `<html>`, `<head>`, and `<body>` elements; set `isDocument` to
+ * `false` to switch to fragment mode and disable this.
+ *
+ * @param content - Markup to be loaded.
+ * @param options - Options for the created instance.
+ * @param isDocument - Allows parser to be switched to fragment mode.
+ * @returns The loaded document.
+ * @see {@link https://cheerio.js.org#loading} for additional usage information.
+ */
+export declare function load(content: string | Node | Node[] | Buffer, options?: CheerioOptions | null, isDocument?: boolean): CheerioAPI;
+export {};
+//# sourceMappingURL=load.d.ts.map

package/compiled/cheerio/lib/options.d.ts

@@ -0,0 +1,31 @@
+import type { DomHandlerOptions } from '../domhandler';
+import type { ParserOptions } from '../htmlparser2';
+/** Options accepted by htmlparser2, the default parser for XML. */
+export interface HTMLParser2Options extends DomHandlerOptions, ParserOptions {
+}
+/** Options for parse5, the default parser for HTML. */
+export interface Parse5Options {
+    /** Disable scripting in parse5, so noscript tags would be parsed. */
+    scriptingEnabled?: boolean;
+    /** Enable location support for parse5. */
+    sourceCodeLocationInfo?: boolean;
+}
+/** Internal options for Cheerio. */
+export interface InternalOptions extends HTMLParser2Options, Parse5Options {
+    _useHtmlParser2?: boolean;
+}
+/**
+ * Options accepted by Cheerio.
+ *
+ * Please note that parser-specific options are *only recognized* if the
+ * relevant parser is used.
+ */
+export interface CheerioOptions extends HTMLParser2Options, Parse5Options {
+    /** Suggested way of configuring htmlparser2 when wanting to parse XML. */
+    xml?: HTMLParser2Options | boolean;
+}
+declare const defaultOpts: CheerioOptions;
+/** Cheerio default options. */
+export default defaultOpts;
+export declare function flatten(options?: CheerioOptions | null): InternalOptions | undefined;
+//# sourceMappingURL=options.d.ts.map

package/compiled/cheerio/lib/static.d.ts

@@ -0,0 +1,88 @@
+import type { CheerioAPI, Cheerio } from '.';
+import { Node, Document } from '../domhandler';
+import { CheerioOptions } from './options';
+/**
+ * Renders the document.
+ *
+ * @param options - Options for the renderer.
+ * @returns The rendered document.
+ */
+export declare function html(this: CheerioAPI | void, options?: CheerioOptions): string;
+/**
+ * Renders the document.
+ *
+ * @param dom - Element to render.
+ * @param options - Options for the renderer.
+ * @returns The rendered document.
+ */
+export declare function html(this: CheerioAPI | void, dom?: string | ArrayLike<Node> | Node, options?: CheerioOptions): string;
+/**
+ * Render the document as XML.
+ *
+ * @param dom - Element to render.
+ * @returns THe rendered document.
+ */
+export declare function xml(this: CheerioAPI, dom?: string | ArrayLike<Node> | Node): string;
+/**
+ * Render the document as text.
+ *
+ * @param elements - Elements to render.
+ * @returns The rendered document.
+ */
+export declare function text(this: CheerioAPI | void, elements?: ArrayLike<Node>): string;
+/**
+ * Parses a string into an array of DOM nodes. The `context` argument has no
+ * meaning for Cheerio, but it is maintained for API compatibility with jQuery.
+ *
+ * @param data - Markup that will be parsed.
+ * @param context - Will be ignored. If it is a boolean it will be used as the
+ *   value of `keepScripts`.
+ * @param keepScripts - If false all scripts will be removed.
+ * @returns The parsed DOM.
+ * @alias Cheerio.parseHTML
+ * @see {@link https://api.jquery.com/jQuery.parseHTML/}
+ */
+export declare function parseHTML(this: CheerioAPI, data: string, context?: unknown | boolean, keepScripts?: boolean): Node[];
+export declare function parseHTML(this: CheerioAPI, data?: '' | null): null;
+/**
+ * Sometimes you need to work with the top-level root element. To query it, you
+ * can use `$.root()`.
+ *
+ * @example
+ *
+ * ```js
+ * $.root().append('<ul id="vegetables"></ul>').html();
+ * //=> <ul id="fruits">...</ul><ul id="vegetables"></ul>
+ * ```
+ *
+ * @returns Cheerio instance wrapping the root node.
+ * @alias Cheerio.root
+ */
+export declare function root(this: CheerioAPI): Cheerio<Document>;
+/**
+ * Checks to see if the `contained` DOM element is a descendant of the
+ * `container` DOM element.
+ *
+ * @param container - Potential parent node.
+ * @param contained - Potential child node.
+ * @returns Indicates if the nodes contain one another.
+ * @alias Cheerio.contains
+ * @see {@link https://api.jquery.com/jQuery.contains/}
+ */
+export declare function contains(container: Node, contained: Node): boolean;
+interface WritableArrayLike<T> extends ArrayLike<T> {
+    length: number;
+    [n: number]: T;
+}
+/**
+ * $.merge().
+ *
+ * @param arr1 - First array.
+ * @param arr2 - Second array.
+ * @returns `arr1`, with elements of `arr2` inserted.
+ * @alias Cheerio.merge
+ * @see {@link https://api.jquery.com/jQuery.merge/}
+ */
+export declare function merge<T>(arr1: WritableArrayLike<T>, arr2: ArrayLike<T>): ArrayLike<T> | undefined;
+export {};
+//# sourceMappingURL=static.d.ts.map

package/compiled/cheerio/lib/types.d.ts

@@ -0,0 +1,20 @@
+declare type LowercaseLetters = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+declare type AlphaNumeric = LowercaseLetters | Uppercase<LowercaseLetters> | `${number}`;
+declare type SelectorSpecial = '.' | '#' | ':' | '|' | '>' | '+' | '~' | '[';
+/**
+ * Type for identifying selectors. Allows us to "upgrade" queries using
+ * selectors to return `Element`s.
+ */
+export declare type SelectorType = `${SelectorSpecial}${AlphaNumeric}${string}` | `${AlphaNumeric}${string}`;
+import type { Cheerio } from './cheerio';
+import type { Node } from '../domhandler';
+/** Elements that can be passed to manipulation methods. */
+export declare type BasicAcceptedElems<T extends Node> = Cheerio<T> | T[] | T | string;
+/** Elements that can be passed to manipulation methods, including functions. */
+export declare type AcceptedElems<T extends Node> = BasicAcceptedElems<T> | ((this: T, i: number, el: T) => BasicAcceptedElems<T>);
+/** Function signature, for traversal methods. */
+export declare type FilterFunction<T> = (this: T, i: number, el: T) => boolean;
+/** Supported filter types, for traversal methods. */
+export declare type AcceptedFilters<T> = string | FilterFunction<T> | T | Cheerio<T>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/compiled/cheerio/package.json

@@ -0,0 +1 @@
+{"name":"cheerio","author":"Matt Mueller <mattmuelle@gmail.com>","license":"MIT","types":"lib/index.d.ts"}

package/compiled/color/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2012 Heather Arthur
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

package/compiled/color/color-convert/conversions.d.ts

@@ -0,0 +1,149 @@
+import colors = require('../color-name');
+
+export type RGB = [number, number, number];
+export type HSL = [number, number, number];
+export type HSV = [number, number, number];
+export type HWB = [number, number, number];
+export type CMYK = [number, number, number, number];
+export type XYZ = [number, number, number];
+export type LAB = [number, number, number];
+export type LCH = [number, number, number];
+export type HEX = string;
+export type KEYWORD = keyof typeof colors;
+export type ANSI16 = number;
+export type ANSI256 = number;
+export type HCG = [number, number, number];
+export type APPLE = [number, number, number];
+export type GRAY = [number];
+
+export namespace rgb {
+  const channels: 3;
+  const labels: 'rgb';
+  function hsl(rgb: RGB): HSL;
+  function hsl(...rgb: RGB): HSL;
+  function hsv(rgb: RGB): HSV;
+  function hsv(...rgb: RGB): HSV;
+  function hwb(rgb: RGB): HWB;
+  function hwb(...rgb: RGB): HWB;
+  function cmyk(rgb: RGB): CMYK;
+  function cmyk(...rgb: RGB): CMYK;
+  function keyword(rgb: RGB): KEYWORD;
+  function keyword(...rgb: RGB): KEYWORD;
+  function xyz(rgb: RGB): XYZ;
+  function xyz(...rgb: RGB): XYZ;
+  function lab(rgb: RGB): LAB;
+  function lab(...rgb: RGB): LAB;
+  function ansi16(rgb: RGB): ANSI16;
+  function ansi16(...rgb: RGB): ANSI16;
+  function ansi256(rgb: RGB): ANSI256;
+  function ansi256(...rgb: RGB): ANSI256;
+  function hex(rgb: RGB): HEX;
+  function hex(...rgb: RGB): HEX;
+  function hcg(rgb: RGB): HCG;
+  function hcg(...rgb: RGB): HCG;
+  function apple(rgb: RGB): APPLE;
+  function apple(...rgb: RGB): APPLE;
+  function gray(rgb: RGB): GRAY;
+  function gray(...rgb: RGB): GRAY;
+}
+
+export namespace hsl {
+  const channels: 3;
+  const labels: 'hsl';
+  function rgb(hsl: HSL): RGB;
+  function hsv(hsl: HSL): HSV;
+  function hcg(hsl: HSL): HCG;
+}
+
+export namespace hsv {
+  const channels: 3;
+  const labels: 'hsv';
+  function rgb(hsv: HSV): RGB;
+  function hsl(hsv: HSV): HSL;
+  function ansi16(hsv: HSV): ANSI16;
+  function hcg(hsv: HSV): HCG;
+}
+
+export namespace hwb {
+  const channels: 3;
+  const labels: 'hwb';
+  function rgb(hwb: HWB): RGB;
+  function hcg(hwb: HWB): HCG;
+}
+
+export namespace cmyk {
+  const channels: 4;
+  const labels: 'cmyk';
+  function rgb(cmyk: CMYK): RGB;
+}
+
+export namespace xyz {
+  const channels: 3;
+  const labels: 'xyz';
+  function rgb(xyz: XYZ): RGB;
+  function lab(xyz: XYZ): LAB;
+}
+
+export namespace lab {
+  const channels: 3;
+  const labels: 'lab';
+  function xyz(lab: LAB): XYZ;
+  function lch(lab: LAB): LCH;
+}
+
+export namespace lch {
+  const channels: 3;
+  const labels: 'lch';
+  function lab(lch: LCH): LAB;
+}
+
+export namespace hex {
+  const channels: 1;
+  const labels: ['hex'];
+  function rgb(hex: HEX): RGB;
+}
+
+export namespace keyword {
+  const channels: 1;
+  const labels: ['keyword'];
+  function rgb(keyword: KEYWORD): RGB;
+}
+
+export namespace ansi16 {
+  const channels: 1;
+  const labels: ['ansi16'];
+  function rgb(ansi16: ANSI16): RGB;
+}
+
+export namespace ansi256 {
+  const channels: 1;
+  const labels: ['ansi256'];
+  function rgb(ansi256: ANSI256): RGB;
+}
+
+export namespace hcg {
+  const channels: 3;
+  const labels: ['h', 'c', 'g'];
+  function rgb(hcg: HCG): RGB;
+  function hsv(hcg: HCG): HSV;
+  function hsl(hcg: HCG): HSL;
+  function hwb(hcg: HCG): HWB;
+}
+
+export namespace apple {
+  const channels: 3;
+  const labels: ['r16', 'g16', 'b16'];
+  function rgb(apple: APPLE): RGB;
+}
+
+export namespace gray {
+  const channels: 1;
+  const labels: ['gray'];
+  function rgb(gray: GRAY): RGB;
+  function hsl(gray: GRAY): HSL;
+  function hsv(gray: GRAY): HSV;
+  function hwb(gray: GRAY): HWB;
+  function cmyk(gray: GRAY): CMYK;
+  function lab(gray: GRAY): LAB;
+  function hex(gray: GRAY): HEX;
+}

package/compiled/color/color-convert/index.d.ts

@@ -0,0 +1,113 @@
+// Type definitions for color-convert 2.0
+// Project: https://github.com/qix-/color-convert#readme
+// Definitions by: Junyoung Clare Jang <https://github.com/Airlun>
+//                 Piotr Błażejewicz <https://github.com/peterblazejewicz>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import conversions = require('./conversions');
+import route = require('./route');
+
+export const rgb: typeof conversions.rgb &
+  route.rgb & {
+    [F in keyof route.rgb]: {
+      raw: route.rgb[F];
+    };
+  };
+
+export const hsl: typeof conversions.hsl &
+  route.hsl & {
+    [F in keyof route.hsl]: {
+      raw: route.hsl[F];
+    };
+  };
+
+export const hsv: typeof conversions.hsv &
+  route.hsv & {
+    [F in keyof route.hsv]: {
+      raw: route.hsv[F];
+    };
+  };
+
+export const hwb: typeof conversions.hwb &
+  route.hwb & {
+    [F in keyof route.hwb]: {
+      raw: route.hwb[F];
+    };
+  };
+
+export const cmyk: typeof conversions.cmyk &
+  route.cmyk & {
+    [F in keyof route.cmyk]: {
+      raw: route.cmyk[F];
+    };
+  };
+
+export const xyz: typeof conversions.xyz &
+  route.xyz & {
+    [F in keyof route.xyz]: {
+      raw: route.xyz[F];
+    };
+  };
+
+export const lab: typeof conversions.lab &
+  route.lab & {
+    [F in keyof route.lab]: {
+      raw: route.lab[F];
+    };
+  };
+
+export const lch: typeof conversions.lch &
+  route.lch & {
+    [F in keyof route.lch]: {
+      raw: route.lch[F];
+    };
+  };
+
+export const hex: typeof conversions.hex &
+  route.hex & {
+    [F in keyof route.hex]: {
+      raw: route.hex[F];
+    };
+  };
+
+export const keyword: typeof conversions.keyword &
+  route.keyword & {
+    [F in keyof route.keyword]: {
+      raw: route.keyword[F];
+    };
+  };
+
+export const ansi16: typeof conversions.ansi16 &
+  route.ansi16 & {
+    [F in keyof route.ansi16]: {
+      raw: route.ansi16[F];
+    };
+  };
+
+export const ansi256: typeof conversions.ansi256 &
+  route.ansi256 & {
+    [F in keyof route.ansi256]: {
+      raw: route.ansi256[F];
+    };
+  };
+
+export const hcg: typeof conversions.hcg &
+  route.hcg & {
+    [F in keyof route.hcg]: {
+      raw: route.hcg[F];
+    };
+  };
+
+export const apple: typeof conversions.apple &
+  route.apple & {
+    [F in keyof route.apple]: {
+      raw: route.apple[F];
+    };
+  };
+
+export const gray: typeof conversions.gray &
+  route.gray & {
+    [F in keyof route.gray]: {
+      raw: route.gray[F];
+    };
+  };