@unicom-cloud/utils 0.1.10 → 0.1.12

package/types/screenfull/index.d.ts

@@ -0,0 +1,10 @@
+export default screenfull;
+declare namespace screenfull {
+    export function request(element: HTMLElement | undefined, options: any): Promise<any>;
+    export function exit(): Promise<any>;
+    export function toggle(element: any, options: any): any;
+    export function on(event: any, callback: any): void;
+    export function off(event: any, callback: any): void;
+    export { nativeAPI as raw };
+}
+declare const nativeAPI: {};

package/types/snapdom/index.d.ts

@@ -0,0 +1 @@
+export * from "./src";

package/types/snapdom/src/api/preCache.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Preloads images, background images, and optionally fonts into cache before DOM capture.
+ *
+ * @param {Document|Element} [root=document] - The root node to search for resources
+ * @param {Object} [options={}] - Pre-caching options
+ * @returns {Promise<void>} Resolves when all resources are pre-cached
+ */
+export function preCache(root?: Document | Element, options?: Object): Promise<void>;

package/types/snapdom/src/api/snapdom.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Main entry point: captures a DOM element and returns an object with export methods.
+ *
+ * @param {Element} element - DOM element to capture
+ * @param {Object} [options={}] - Capture options
+ * @returns {Promise<Object>} Object with export methods (toRaw, toImg, toCanvas, etc.)
+ */
+export function snapdom(element: Element, options?: Object): Promise<Object>;
+export namespace snapdom {
+    /**
+     * Captures a DOM element and returns an object with export methods (internal use).
+     *
+     * @param {Element} el - DOM element to capture
+     * @param {Object} [options={}] - Capture options
+     * @returns {Promise<Object>} Object with export methods
+     */
+    function capture(el: Element, options?: Object): Promise<Object>;
+    function toRaw(el: any, options: any): Promise<any>;
+    function toImg(el: any, options: any): Promise<any>;
+    function toCanvas(el: any, options: any): Promise<any>;
+    function toBlob(el: any, options: any): Promise<any>;
+    function toPng(el: any, options: any): Promise<any>;
+    function toJpg(el: any, options: any): Promise<any>;
+    function toWebp(el: any, options: any): Promise<any>;
+    function download(el: any, options?: {}): Promise<any>;
+}

package/types/snapdom/src/core/cache.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Caches for images, backgrounds, resources, and computed styles used during DOM capture.
+ * @module cache
+ */
+export const imageCache: Map<any, any>;
+export const bgCache: Map<any, any>;
+export const resourceCache: Map<any, any>;
+export const defaultStylesCache: Map<any, any>;
+export const baseCSSCache: Map<any, any>;
+export const computedStyleCache: WeakMap<WeakKey, any>;
+export const processedFontURLs: Set<any>;

package/types/snapdom/src/core/capture.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Captures an HTML element as an SVG data URL, inlining styles, images, backgrounds, and optionally fonts.
+ *
+ * @param {Element} element - DOM element to capture
+ * @param {Object} [options={}] - Capture options
+ * @param {boolean} [options.compress=true] - Whether to compress style keys
+ * @param {boolean} [options.embedFonts=false] - Whether to embed custom fonts
+ * @param {boolean} [options.fast=true] - Whether to skip idle delay for faster results
+ * @param {number} [options.scale=1] - Output scale multiplier
+ * @returns {Promise<string>} Promise that resolves to an SVG data URL
+ */
+export function captureDOM(element: Element, options?: {
+    compress?: boolean | undefined;
+    embedFonts?: boolean | undefined;
+    fast?: boolean | undefined;
+    scale?: number | undefined;
+}): Promise<string>;

package/types/snapdom/src/core/clone.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Creates a deep clone of a DOM node, including styles, shadow DOM, and special handling for excluded/placeholder/canvas nodes.
+ *
+ * @param {Node} node - Node to clone
+ * @param {Map} styleMap - Map to store element-to-style-key mappings
+ * @param {WeakMap} styleCache - Cache of computed styles
+ * @param {WeakMap} nodeMap - Map to track original-to-clone node relationships
+ * @param {boolean} compress - Whether to compress style keys
+ * @returns {Node|null} Cloned node with styles and shadow DOM content, or null for empty text nodes
+ */
+export function deepClone(node: Node, styleMap: Map<any, any>, styleCache: WeakMap<any, any>, nodeMap: WeakMap<any, any>, compress: boolean): Node | null;

package/types/snapdom/src/core/prepare.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Prepares a clone of an element for capture, inlining pseudo-elements and generating CSS classes.
+ *
+ * @param {Element} element - Element to clone
+ * @param {boolean} [compress=false] - Whether to compress style keys
+ * @returns {Promise<Object>} Object containing the clone, generated CSS, and style cache
+ */
+export function prepareClone(element: Element, compress?: boolean, embedFonts?: boolean, useProxy?: string): Promise<Object>;

package/types/snapdom/src/index.browser.d.ts

@@ -0,0 +1 @@
+export {};

package/types/snapdom/src/index.d.ts

@@ -0,0 +1,2 @@
+export { preCache } from "./api/preCache.js";
+export { snapdom } from "./api/snapdom.js";

package/types/snapdom/src/modules/background.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Converts all background images in the cloned element tree to data URLs.
+ *
+ * @param {Element} source - Original element
+ * @param {Element} clone - Cloned element
+ * @param {WeakMap} styleCache - Cache of computed styles
+ * @param {Object} [options={}] - Options for image processing
+ * @returns {Promise<void>} Promise that resolves when all background images are processed
+ */
+export function inlineBackgroundImages(source: Element, clone: Element, styleCache: WeakMap<any, any>, options?: Object): Promise<void>;

package/types/snapdom/src/modules/fonts.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Converts a unicode character from an icon font into a data URL image.
+ *
+ * @export
+ * @param {string} unicodeChar - The unicode character to render
+ * @param {string} fontFamily - The font family name
+ * @param {string|number} fontWeight - The font weight
+ * @param {number} [fontSize=32] - The font size in pixels
+ * @param {string} [color="#000"] - The color to use
+ * @returns {Promise<string>} Data URL of the rendered icon
+ */
+export function iconToImage(unicodeChar: string, fontFamily: string, fontWeight: string | number, fontSize?: number, color?: string): Promise<string>;
+/**
+ * Embeds custom fonts found in the document as data URLs in CSS.
+ *
+ * @export
+ * @param {Object} options
+ * @param {boolean} [options.preCached=false] - Whether to use pre-cached resources
+ * @returns {Promise<string>} The inlined CSS for custom fonts
+ */
+export function embedCustomFonts({ preCached }?: {
+    preCached?: boolean | undefined;
+}): Promise<string>;

package/types/snapdom/src/modules/iconFonts.d.ts

@@ -0,0 +1,2 @@
+export function extendIconFonts(fonts: any): void;
+export function isIconFont(input: any): boolean;

package/types/snapdom/src/modules/images.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts all <img> elements in the clone to data URLs or replaces them with placeholders if loading fails.
+ *
+ * @param {Element} clone - Clone of the original element
+ * @param {Object} [options={}] - Options for image processing
+ * @returns {Promise<void>} Promise that resolves when all images are processed
+ */
+export function inlineImages(clone: Element, options?: Object): Promise<void>;

package/types/snapdom/src/modules/pseudo.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates elements to represent ::before, ::after, and ::first-letter pseudo-elements, inlining their styles and content.
+ *
+ * @param {Element} source - Original element
+ * @param {Element} clone - Cloned element
+ * @param {Map} styleMap - Map to store element-to-style-key mappings
+ * @param {WeakMap} styleCache - Cache of computed styles
+ * @param {boolean} compress - Whether to compress style keys
+ * @param {boolean} embedFonts - Whether to embed icon fonts as images
+ * @returns {Promise} Promise that resolves when all pseudo-elements are processed
+ */
+export function inlinePseudoElements(source: Element, clone: Element, styleMap: Map<any, any>, styleCache: WeakMap<any, any>, compress: boolean, embedFonts: boolean | undefined, useProxy: any): Promise<any>;

package/types/snapdom/src/modules/styles.d.ts

@@ -0,0 +1 @@
+export function inlineAllStyles(source: any, clone: any, styleMap: any, cache: any, compress: any): void;

package/types/snapdom/src/modules/svgDefs.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Inlines external `<defs>` used by `<use xlink:href="#...">` or `<use href="#...">` inside SVGs,
+ * copying only the necessary definitions into each individual cloned SVG.
+ *
+ * This is needed because cloned SVGs using `<use>` may reference elements like `<symbol>`, `<path>`, etc.,
+ * defined elsewhere in the document (e.g., in a shared `<defs>` block that is not part of the cloned subtree).
+ *
+ * The function finds all `<use>` elements within `root`, extracts the referenced IDs,
+ * and embeds the required definitions at the top of each SVG.
+ *
+ * @function inlineExternalDef
+ * @param {ParentNode} root - The root node containing cloned SVGs (usually the result of a DOM snapshot).
+ * @returns {void}
+ *
+ * @example
+ * const { clone } = await prepareClone(element);
+ * inlineExternalDef(clone);
+ */
+export function inlineExternalDef(root: ParentNode): void;

package/types/snapdom/src/utils/cssTools.d.ts

@@ -0,0 +1,38 @@
+export function precacheCommonTags(): void;
+/**
+ * Retrieves default CSS property values from a temporary element.
+ *
+ * @param {string} tagName - The tag name to get default styles for
+ * @returns {Object} Object containing default values for all CSS properties
+ */
+export function getDefaultStyleForTag(tagName: string): Object;
+/**
+ * Creates a unique key from an element's computed style that differs from defaults.
+ *
+ * @param {Object} snapshot - Computed style snapshot
+ * @param {string} tagName - The tag name of the element
+ * @param {boolean} [compress=false] - Whether to compress style keys
+ * @returns {string} Semi-colon separated list of non-default properties
+ */
+export function getStyleKey(snapshot: Object, tagName: string, compress?: boolean): string;
+/**
+ * Collects all unique tag names used in the DOM tree rooted at the given node.
+ *
+ * @param {Node} root - The root node to search
+ * @returns {string[]} Array of unique tag names
+ */
+export function collectUsedTagNames(root: Node): string[];
+/**
+ * Generates deduplicated base CSS for the given tag names.
+ *
+ * @param {string[]} usedTagNames - Array of tag names
+ * @returns {string} CSS string
+ */
+export function generateDedupedBaseCSS(usedTagNames: string[]): string;
+/**
+ * Generates CSS classes from a style map.
+ *
+ * @param {Map} styleMap - Map of elements to style keys
+ * @returns {Map} Map of style keys to class names
+ */
+export function generateCSSClasses(styleMap: Map<any, any>): Map<any, any>;

package/types/snapdom/src/utils/helpers.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Fetches and inlines a single background-image entry to a data URL (with caching).
+ * - If entry is a gradient or "none", returns unchanged.
+ * - If entry is a url(...), fetches the image as data URL and caches it.
+ *
+ * @param {string} entry - Single background-image entry (e.g., "url(...)").
+ * @param {Object} [options={}] - Options like crossOrigin.
+ * @param {boolean} [options.skipInline=false] - If true, only fetches & caches, doesn't return a replacement.
+ * @returns {Promise<string|void>} - The processed entry (unless skipInline is true).
+ */
+export function inlineSingleBackgroundEntry(entry: string, options?: {
+    skipInline?: boolean | undefined;
+}): Promise<string | void>;
+/**
+ * Creates a promise that resolves after the specified delay
+ * @param {number} [ms=0] - Milliseconds to delay
+ * @returns {Promise<void>} Promise that resolves after the delay
+ */
+export function idle(fn: any, { fast }?: {
+    fast?: boolean | undefined;
+}): Promise<void>;
+/**
+ * Gets the computed style for an element or pseudo-element, with caching.
+ *
+ * @param {Element} el - The element
+ * @param {string|null} [pseudo=null] - The pseudo-element
+ * @returns {CSSStyleDeclaration} The computed style
+ */
+export function getStyle(el: Element, pseudo?: string | null): CSSStyleDeclaration;
+/**
+ * Parses the CSS content property value, handling unicode escapes.
+ *
+ * @param {string} content - The CSS content value
+ * @returns {string} The parsed content
+ */
+export function parseContent(content: string): string;
+/**
+ * Extracts a URL from a CSS value like background-image.
+ *
+ * @param {string} value - The CSS value
+ * @returns {string|null} The extracted URL or null
+ */
+export function extractURL(value: string): string | null;
+/**
+ * Determines if a font family or URL is an icon font.
+ *
+ * @param {string} familyOrUrl - The font family or URL
+ * @returns {boolean} True if it is an icon font
+ */
+export function isIconFont(familyOrUrl: string): boolean;
+/**
+ *
+ *
+ * @export
+ * @param {*} src
+ * @param {number} [timeout=3000]
+ * @return {*}
+ */
+export function fetchImage(src: any, { timeout, useProxy }?: number): any;
+/**
+ *
+ *
+ * @export
+ * @param {*} style
+ * @return {*}
+ */
+export function snapshotComputedStyle(style: any): any;
+export function isSafari(): boolean;
+export function stripTranslate(transform: any): any;
+export function safeEncodeURI(uri: any): any;
+export function splitBackgroundImage(bg: any): any[];

package/types/tinycolor/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/public_api';
+export { TinyColor as default } from './src';

package/types/tinycolor/src/conversion.d.ts

@@ -0,0 +1,79 @@
+import { HSL, HSV, Numberify, RGB } from './interfaces.js';
+/**
+ * Handle bounds / percentage checking to conform to CSS color spec
+ * <http://www.w3.org/TR/css3-color/>
+ * *Assumes:* r, g, b in [0, 255] or [0, 1]
+ * *Returns:* { r, g, b } in [0, 255]
+ */
+export declare function rgbToRgb(r: number | string, g: number | string, b: number | string): Numberify<RGB>;
+/**
+ * Converts an RGB color value to HSL.
+ * *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]
+ * *Returns:* { h, s, l } in [0,1]
+ */
+export declare function rgbToHsl(r: number, g: number, b: number): Numberify<HSL>;
+/**
+ * Converts an HSL color value to RGB.
+ *
+ * *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
+ * *Returns:* { r, g, b } in the set [0, 255]
+ */
+export declare function hslToRgb(h: number | string, s: number | string, l: number | string): Numberify<RGB>;
+/**
+ * Converts an RGB color value to HSV
+ *
+ * *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
+ * *Returns:* { h, s, v } in [0,1]
+ */
+export declare function rgbToHsv(r: number, g: number, b: number): Numberify<HSV>;
+/**
+ * Converts an HSV color value to RGB.
+ *
+ * *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
+ * *Returns:* { r, g, b } in the set [0, 255]
+ */
+export declare function hsvToRgb(h: number | string, s: number | string, v: number | string): Numberify<RGB>;
+/**
+ * Converts an RGB color to hex
+ *
+ * *Assumes:* r, g, and b are contained in the set [0, 255]
+ * *Returns:* a 3 or 6 character hex
+ */
+export declare function rgbToHex(r: number, g: number, b: number, allow3Char: boolean): string;
+/**
+ * Converts an RGBA color plus alpha transparency to hex
+ *
+ * *Assumes:* r, g, b are contained in the set [0, 255] and a in [0, 1]
+ * *Returns:* a 4 or 8 character rgba hex
+ */
+export declare function rgbaToHex(r: number, g: number, b: number, a: number, allow4Char: boolean): string;
+/**
+ * Converts an RGBA color to an ARGB Hex8 string
+ * Rarely used, but required for "toFilter()"
+ *
+ * *Assumes:* r, g, b are contained in the set [0, 255] and a in [0, 1]
+ * *Returns:* a 8 character argb hex
+ */
+export declare function rgbaToArgbHex(r: number, g: number, b: number, a: number): string;
+/**
+ * Converts CMYK to RBG
+ * Assumes c, m, y, k are in the set [0, 100]
+ */
+export declare function cmykToRgb(c: number, m: number, y: number, k: number): {
+    r: number;
+    g: number;
+    b: number;
+};
+export declare function rgbToCmyk(r: number, g: number, b: number): {
+    c: number;
+    m: number;
+    y: number;
+    k: number;
+};
+/** Converts a decimal to a hex value */
+export declare function convertDecimalToHex(d: string | number): string;
+/** Converts a hex value to a decimal */
+export declare function convertHexToDecimal(h: string): number;
+/** Parse a base-16 hex value into a base-10 integer */
+export declare function parseIntFromHex(val: string): number;
+export declare function numberInputToObject(color: number): RGB;

package/types/tinycolor/src/css-color-names.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @hidden
+ */
+export declare const names: Record<string, string>;

package/types/tinycolor/src/format-input.d.ts

@@ -0,0 +1,38 @@
+import { CMYK, HSL, HSLA, HSV, HSVA, RGB, RGBA } from './interfaces.js';
+/**
+ * Given a string or object, convert that input to RGB
+ *
+ * Possible string inputs:
+ * ```
+ * "red"
+ * "#f00" or "f00"
+ * "#ff0000" or "ff0000"
+ * "#ff000000" or "ff000000"
+ * "rgb 255 0 0" or "rgb (255, 0, 0)"
+ * "rgb 1.0 0 0" or "rgb (1, 0, 0)"
+ * "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1"
+ * "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1"
+ * "hsl(0, 100%, 50%)" or "hsl 0 100% 50%"
+ * "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
+ * "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
+ * "cmyk(0, 20, 0, 0)" or "cmyk 0 20 0 0"
+ * ```
+ */
+export declare function inputToRGB(color: string | RGB | RGBA | HSL | HSLA | HSV | HSVA | CMYK | any): {
+    ok: boolean;
+    format: any;
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+/**
+ * Permissive string parsing.  Take in a number of formats, and output an object
+ * based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}` or `{c, m, y, k}` or `{c, m, y, k, a}`
+ */
+export declare function stringInputToObject(color: string): any;
+/**
+ * Check to see if it looks like a CSS unit
+ * (see `matchers` above for definition).
+ */
+export declare function isValidCSSUnit(color: string | number): boolean;

package/types/tinycolor/src/from-ratio.d.ts

@@ -0,0 +1,14 @@
+import { TinyColor } from './index.js';
+export interface RatioInput {
+    r: number | string;
+    g: number | string;
+    b: number | string;
+    a?: number | string;
+}
+/**
+ * If input is an object, force 1 into "1.0" to handle ratios properly
+ * String input requires "1.0" as input, so 1 will be treated as 1
+ */
+export declare function fromRatio(ratio: RatioInput, opts?: any): TinyColor;
+/** old random function */
+export declare function legacyRandom(): TinyColor;

package/types/tinycolor/src/index.d.ts

@@ -0,0 +1,214 @@
+import { CMYK, HSL, HSLA, HSV, HSVA, Numberify, RGB, RGBA } from './interfaces.js';
+export interface TinyColorOptions {
+    format: string;
+    gradientType: string;
+}
+export type ColorInput = string | number | RGB | RGBA | HSL | HSLA | HSV | HSVA | CMYK | TinyColor | unknown;
+export type ColorFormats = 'rgb' | 'prgb' | 'hex' | 'hex3' | 'hex4' | 'hex6' | 'hex8' | 'name' | 'hsl' | 'hsv' | 'cmyk';
+export declare class TinyColor {
+    /** red */
+    r: number;
+    /** green */
+    g: number;
+    /** blue */
+    b: number;
+    /** alpha */
+    a: number;
+    /** the format used to create the tinycolor instance */
+    format: ColorFormats;
+    /** input passed into the constructer used to create the tinycolor instance */
+    originalInput: ColorInput;
+    /** the color was successfully parsed */
+    isValid: boolean;
+    gradientType?: string;
+    /** rounded alpha */
+    roundA: number;
+    constructor(color?: ColorInput, opts?: Partial<TinyColorOptions>);
+    get ok(): boolean;
+    isDark(): boolean;
+    isLight(): boolean;
+    /**
+     * Returns the perceived brightness of the color, from 0-255.
+     */
+    getBrightness(): number;
+    /**
+     * Returns the perceived luminance of a color, from 0-1.
+     */
+    getLuminance(): number;
+    /**
+     * Returns the alpha value of a color, from 0-1.
+     */
+    getAlpha(): number;
+    /**
+     * Sets the alpha value on the current color.
+     *
+     * @param alpha - The new alpha value. The accepted range is 0-1.
+     */
+    setAlpha(alpha?: string | number): this;
+    /**
+     * Returns whether the color is monochrome.
+     */
+    isMonochrome(): boolean;
+    /**
+     * Returns the object as a HSVA object.
+     */
+    toHsv(): Numberify<HSVA>;
+    toHsv_(): Numberify<HSVA>;
+    /**
+     * Returns the hsva values interpolated into a string with the following format:
+     * "hsva(xxx, xxx, xxx, xx)".
+     */
+    toHsvString(): string;
+    /**
+     * Returns the object as a HSLA object.
+     */
+    toHsl(): Numberify<HSLA>;
+    /**
+     * Returns the hsla values interpolated into a string with the following format:
+     * "hsla(xxx, xxx, xxx, xx)".
+     */
+    toHslString(): string;
+    /**
+     * Returns the hex value of the color.
+     * @param allow3Char will shorten hex value to 3 char if possible
+     */
+    toHex(allow3Char?: boolean): string;
+    /**
+     * Returns the hex value of the color -with a # prefixed.
+     * @param allow3Char will shorten hex value to 3 char if possible
+     */
+    toHexString(allow3Char?: boolean): string;
+    /**
+     * Returns the hex 8 value of the color.
+     * @param allow4Char will shorten hex value to 4 char if possible
+     */
+    toHex8(allow4Char?: boolean): string;
+    /**
+     * Returns the hex 8 value of the color -with a # prefixed.
+     * @param allow4Char will shorten hex value to 4 char if possible
+     */
+    toHex8String(allow4Char?: boolean): string;
+    /**
+     * Returns the shorter hex value of the color depends on its alpha -with a # prefixed.
+     * @param allowShortChar will shorten hex value to 3 or 4 char if possible
+     */
+    toHexShortString(allowShortChar?: boolean): string;
+    /**
+     * Returns the object as a RGBA object.
+     */
+    toRgb(): Numberify<RGBA>;
+    toRgba(): Numberify<RGBA>;
+    toRgbArray(): number[];
+    toRgbArrayString(): string;
+    /**
+     * Returns the RGBA values interpolated into a string with the following format:
+     * "RGBA(xxx, xxx, xxx, xx)".
+     */
+    toRgbString(): string;
+    toRgbaString(): string;
+    /**
+     * Returns the object as a RGBA object.
+     */
+    toPercentageRgb(): RGBA;
+    /**
+     * Returns the RGBA relative values interpolated into a string
+     */
+    toPercentageRgbString(): string;
+    toCmyk(): Numberify<CMYK>;
+    toCmykString(): string;
+    /**
+     * The 'real' name of the color -if there is one.
+     */
+    toName(): string | false;
+    /**
+     * String representation of the color.
+     *
+     * @param format - The format to be used when displaying the string representation.
+     */
+    toString<T extends 'name'>(format: T): boolean | string;
+    toString<T extends ColorFormats>(format?: T): string;
+    toNumber(): number;
+    clone(): TinyColor;
+    /**
+     * Lighten the color a given amount. Providing 100 will always return white.
+     * @param amount - valid between 1-100
+     */
+    lighten(amount?: number): TinyColor;
+    /**
+     * Brighten the color a given amount, from 0 to 100.
+     * @param amount - valid between 1-100
+     */
+    brighten(amount?: number): TinyColor;
+    /**
+     * Darken the color a given amount, from 0 to 100.
+     * Providing 100 will always return black.
+     * @param amount - valid between 1-100
+     */
+    darken(amount?: number): TinyColor;
+    /**
+     * Mix the color with pure white, from 0 to 100.
+     * Providing 0 will do nothing, providing 100 will always return white.
+     * @param amount - valid between 1-100
+     */
+    tint(amount?: number): TinyColor;
+    /**
+     * Mix the color with pure black, from 0 to 100.
+     * Providing 0 will do nothing, providing 100 will always return black.
+     * @param amount - valid between 1-100
+     */
+    shade(amount?: number): TinyColor;
+    /**
+     * Desaturate the color a given amount, from 0 to 100.
+     * Providing 100 will is the same as calling greyscale
+     * @param amount - valid between 1-100
+     */
+    desaturate(amount?: number): TinyColor;
+    /**
+     * Saturate the color a given amount, from 0 to 100.
+     * @param amount - valid between 1-100
+     */
+    saturate(amount?: number): TinyColor;
+    /**
+     * Completely desaturates a color into greyscale.
+     * Same as calling `desaturate(100)`
+     */
+    greyscale(): TinyColor;
+    /**
+     * Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.
+     * Values outside of this range will be wrapped into this range.
+     */
+    spin(amount: number): TinyColor;
+    /**
+     * Mix the current color a given amount with another color, from 0 to 100.
+     * 0 means no mixing (return current color).
+     */
+    mix(color: ColorInput, amount?: number): TinyColor;
+    analogous(results?: number, slices?: number): TinyColor[];
+    /**
+     * taken from https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js
+     */
+    complement(): TinyColor;
+    monochromatic(results?: number): TinyColor[];
+    splitcomplement(): TinyColor[];
+    /**
+     * Compute how the color would appear on a background
+     */
+    onBackground(background: ColorInput): TinyColor;
+    /**
+     * Alias for `polyad(3)`
+     */
+    triad(): TinyColor[];
+    /**
+     * Alias for `polyad(4)`
+     */
+    tetrad(): TinyColor[];
+    /**
+     * Get polyad colors, like (for 1, 2, 3, 4, 5, 6, 7, 8, etc...)
+     * monad, dyad, triad, tetrad, pentad, hexad, heptad, octad, etc...
+     */
+    polyad(n: number): TinyColor[];
+    /**
+     * compare color vs current color
+     */
+    equals(color?: ColorInput): boolean;
+}