@ixfx/components 0.4.3 → 0.4.4

package/dist/index-DgXpCg_G.d.ts

@@ -1,1244 +0,0 @@
-import { CSSResultGroup, LitElement, PropertyValues } from "lit";
-
-//#region src/colour-picker/types.d.ts
-/**
- * OKLCH colour value representation
- */
-type OklchValue = {
-  readonly l: number;
-  readonly c: number;
-  readonly h: number;
-  readonly a?: number;
-};
-/**
- * Event detail for colour picker input/change events
- */
-type ColourPickerEventDetail = OklchValue;
-/**
- * Colour picker custom events
- */
-type ColourPickerInputEvent = CustomEvent<ColourPickerEventDetail>;
-type ColourPickerChangeEvent = CustomEvent<ColourPickerEventDetail>;
-type Range = readonly [number, number];
-type RangeInput = readonly [number, number] | readonly number[];
-/**
- * Augment HTMLElementTagNameMap for the custom element
- */
-declare global {
-  interface HTMLElementTagNameMap {
-    'ixfx-colour-picker': ColourPicker;
-  }
-} //# sourceMappingURL=types.d.ts.map
-//#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/angles.d.ts
-/**
-* A angle with unit.
-* - [Degrees](https://en.wikipedia.org/wiki/Degree_(angle)): 0..360
-* - [Radians](https://en.wikipedia.org/wiki/Radian): 0...2Pi
-* - [Gradians](https://en.wikipedia.org/wiki/Gradian): 0..400
-* - [Turns](https://en.wikipedia.org/wiki/Turn_(angle)): 0..1
-*
-*
-* ```
-*             100 grad
-*             1/4 turn
-*              90 deg
-*             PI/2 rad
-*                |
-*  Pi rad        |        0 or 2PI rad
-*  180deg -------+------- 0 or 360 deg
-*  1/2 turn      |        0 or 1 turn
-*  200 grad      |        0 or 400 grad
-*                |
-*             270 deg
-*            3PI/2 rad
-*             3/4 turn
-*             300 grad
-* ```
-*/
-type Angle = {
-  value: number;
-  unit: `deg` | `rad` | `turn` | `grad`;
-};
-//#endregion
-//#region node_modules/.pnpm/@ixfx+random@0.56.13/node_modules/@ixfx/random/dist/index.d.ts
-//#region src/types.d.ts
-/**
-* A random source.
-*
-* Predefined sources: Math.random, {@link gaussianSource}, {@link weightedSource}
-*/
-type RandomSource = () => number;
-//#endregion
-//#region node_modules/.pnpm/@ixfx+visual@0.56.13/node_modules/@ixfx/visual/dist/index-a3KMyMEu.d.ts
-//#region src/colour/types.d.ts
-type HslBase = {
-  /**
-  * Hue
-  */
-  h: number;
-  /**
-  * Saturation
-  */
-  s: number;
-  /**
-  * Lightness
-  */
-  l: number;
-  /**
-  * Opacity
-  */
-  opacity?: number;
-  space?: `hsl`;
-};
-/**
-* [YCbCr format](https://en.wikipedia.org/wiki/YCbCr)
-*/
-type YCbCrBase = {
-  /**
-  * Luma
-  */
-  y: number;
-  /**
-  * Blue difference
-  */
-  cb: number;
-  /**
-  * Red difference
-  */
-  cr: number;
-  /**
-  * Opacity
-  */
-  opacity?: number;
-  space?: `ycbcr`;
-};
-/**
-* Scalar values use 0..1 for each field
-*/
-type YCbCrScalar = YCbCrBase & {
-  unit: `scalar`;
-};
-/**
-* Absolute colour use 0..255 for each field
-*/
-type YCbCr8bit = YCbCrBase & {
-  unit: `8bit`;
-};
-/**
-* [YCbCr format](https://en.wikipedia.org/wiki/YCbCr).
-*
-* By default assumes scalar coordinates (0..1) for each field.
-* Use '8bit' unit for 0..255 ranged values.
-*/
-type YCbCr = YCbCrScalar | YCbCr8bit;
-type ColourSpaces = `srgb` | `hsl` | `oklch` | `ycbcr`;
-/**
-* Scalar values use 0..1 for each field
-*/
-type HslScalar = HslBase & {
-  unit: `scalar`;
-};
-/**
-* Absolute values use hue:0..360, all other fields 0..100
-*/
-type HslAbsolute = HslBase & {
-  unit: `absolute`;
-};
-/**
-* HSL value.
-* By default assumes scalar coordinates (0..1) for each field.
-* Use 'absolute' unit for hue:0...360, all other fields on 0..100 scale.
-*/
-type Hsl = HslScalar | HslAbsolute;
-/**
-* Rgb.
-* Units determine how to interperet rgb values.
-* 'scalar': 0..1 range for RGB & opacity
-* '8bit': 0..255 range for RGB & opacity
-*/
-type RgbBase = {
-  r: number;
-  g: number;
-  b: number;
-  opacity?: number;
-  space?: `srgb`;
-};
-type RgbScalar = RgbBase & {
-  unit: `scalar`;
-};
-/**
-* RGB in 0...255 range, including opacity.
-*/
-type Rgb8Bit = RgbBase & {
-  unit: `8bit`;
-};
-/**
-* Rgb.
-* Units determine how to interperet rgb values.
-* 'scalar': 0..1 range for RGB & opacity
-* '8bit': 0..255 range for RGB & opacity
-*/
-type Rgb = RgbScalar | Rgb8Bit;
-type LchBase = {
-  /**
-  * Lightness/perceived brightnes
-  */
-  l: number;
-  /**
-  * Chroma ('amount of colour')
-  */
-  c: number;
-  /**
-  * Hue
-  */
-  h: number;
-  /**
-  * Opacity on 0..1 scale
-  */
-  opacity?: number;
-  space: `lch` | `oklch`;
-};
-type ColourInterpolator<T extends Colour> = (amount: number) => T;
-type OkLchBase = LchBase & {
-  space: `oklch`;
-};
-/**
-* Oklch colour expressed in 0..1 scalar values for LCH & opacity
-*/
-type OkLchScalar = OkLchBase & {
-  unit: `scalar`;
-};
-/**
-* Oklch colour expressed with:
-* l: 0..1
-* c: 0..4
-* h: 0..360 degrees
-* opacity: 0..1
-*/
-type OkLchAbsolute = OkLchBase & {
-  unit: `absolute`;
-};
-type OkLch = OkLchAbsolute | OkLchScalar;
-type Colour = {
-  opacity?: number;
-} & (Hsl | OkLch | Rgb | YCbCr);
-/**
-* A representation of colour. Eg: `blue`, `rgb(255,0,0)`, `hsl(20,100%,50%)`
-*/
-type Colourish = Colour | string;
-/**
-* Options for interpolation
-*/
-type ColourInterpolationOpts = {
-  direction: `longer` | `shorter`;
-  /**
-  * Space to do calculations in
-  */
-  space: ColourSpaces;
-  /**
-  * Destination of calculated colour
-  */
-  destination: ConvertDestinations;
-};
-type ColourStepOpts = ColourInterpolationOpts & {
-  /**
-  * If set, determines total number of steps, including colour stops.
-  * Use this _or_ `stepsBetween`.
-  */
-  stepsTotal?: number;
-  /**
-  * If set, determines number of steps between colour stops.
-  * Use this _or_ `stepsTotal`.
-  */
-  stepsBetween?: number;
-};
-type ParsingOptions<T> = Partial<{
-  scalar: boolean;
-  ensureSafe: boolean;
-  /**
-  * Value to use if input is invalid
-  */
-  fallbackString: string;
-  /**
-  * Fallback colour to use if value cannot be parsed
-  */
-  fallbackColour: T;
-}>;
-type ConvertDestinations = `hsl-scalar` | `hsl-absolute` | `oklch-scalar` | `oklch-absolute` | `srgb-8bit` | `srgb-scalar` | `ycbcr-scalar` | `ycbcr-8bit`; //#endregion
-//#region ../../node_modules/.pnpm/colorizr@4.0.1/node_modules/colorizr/dist/index.d.mts
-type ColorType = 'hex' | 'hsl' | 'oklab' | 'oklch' | 'rgb';
-type HEX = `#${string}`;
-interface Analysis {
-  brightnessDifference: number;
-  colorDifference: number;
-  compliant: number;
-  contrast: number;
-  largeAA: boolean;
-  largeAAA: boolean;
-  normalAA: boolean;
-  normalAAA: boolean;
-}
-interface HSL {
-  /** The alpha/opacity value (0-1). */
-  alpha?: number;
-  h: number;
-  l: number;
-  s: number;
-}
-interface LAB {
-  a: number;
-  /** The alpha/opacity value (0-1). */
-  alpha?: number;
-  b: number;
-  l: number;
-}
-interface LCH {
-  /** The alpha/opacity value (0-1). */
-  alpha?: number;
-  c: number;
-  h: number;
-  l: number;
-}
-interface RGB {
-  /** The alpha/opacity value (0-1). */
-  alpha?: number;
-  b: number;
-  g: number;
-  r: number;
-}
-interface ColorizrOptions {
-  /**
-   * Output color format.
-   *
-   * If not specified, the output will use the same format as the input color.
-   */
-  format?: ColorType;
-}
-declare class Colorizr {
-  /** The alpha/opacity value (0-1). */
-  alpha: number;
-  hex: HEX;
-  hsl: HSL;
-  oklab: LAB;
-  oklch: LCH;
-  rgb: RGB;
-  type: ColorType;
-  constructor(color: string | HSL | LAB | LCH | RGB, options?: ColorizrOptions);
-  /**
-   * Get CSS string
-   */
-  get css(): string;
-  /**
-   * Get the red value
-   */
-  get red(): number;
-  /**
-   * Get the green value
-   */
-  get green(): number;
-  /**
-   * Get the blue value
-   */
-  get blue(): number;
-  /**
-   * Get the hue value
-   */
-  get hue(): number;
-  /**
-   * Get the saturation value
-   */
-  get saturation(): number;
-  /**
-   * Get the lightness value
-   */
-  get lightness(): number;
-  /**
-   * Get the luminance value
-   */
-  get luminance(): number;
-  /**
-   * Get the chroma value
-   */
-  get chroma(): number;
-  get opacity(): number;
-  /**
-   * Get the most readable color (light or dark) for this color as a background.
-   */
-  get readableColor(): string;
-  private get currentColor();
-  /**
-   * Get the brightness difference between this color and another.
-   *
-   * @param input - The color to compare against.
-   * @returns The brightness difference value.
-   */
-  brightnessDifference(input: string): number;
-  /**
-   * Get the color difference between this color and another.
-   *
-   * @param input - The color to compare against.
-   * @returns The color difference value.
-   */
-  colorDifference(input: string): number;
-  /**
-   * Test 2 colors for WCAG compliance.
-   *
-   * @param input - The color to compare against.
-   * @returns Analysis object with compliance information.
-   */
-  compare(input: string): Analysis;
-  /**
-   * Get the contrast ratio between this color and another.
-   *
-   * @param input - The color to compare against.
-   * @returns The contrast ratio.
-   */
-  contrast(input: string): number;
-  /**
-   * Format the color to a specific type.
-   *
-   * @param type - The color format to convert to.
-   * @param precision - The decimal precision for the output.
-   * @returns The formatted color string.
-   */
-  format(type: ColorType, precision?: number): string;
-  /**
-   * Increase lightness.
-   *
-   * @param amount - A number between 0 and 100.
-   * @returns The lightened color string.
-   */
-  lighten(amount: number): string;
-  /**
-   * Decrease lightness.
-   *
-   * @param amount - A number between 0 and 100.
-   * @returns The darkened color string.
-   */
-  darken(amount: number): string;
-  /**
-   * Increase saturation.
-   *
-   * @param amount - A number between 0 and 100.
-   * @returns The saturated color string.
-   */
-  saturate(amount: number): string;
-  /**
-   * Decrease saturation.
-   *
-   * @param amount - A number between 0 and 100.
-   * @returns The desaturated color string.
-   */
-  desaturate(amount: number): string;
-  /**
-   * Convert to grayscale.
-   *
-   * @returns The grayscale color string.
-   */
-  grayscale(): string;
-  /**
-   * Invert color.
-   *
-   * @returns The inverted color string.
-   */
-  invert(): string;
-  /**
-   * Mix with another color.
-   *
-   * @param color - The color to mix with.
-   * @param ratio - A number between 0 and 1 (0 = this color, 1 = input color).
-   * @returns The mixed color string.
-   */
-  mix(color: string, ratio?: number): string;
-  /**
-   * Add opacity to the color.
-   *
-   * @param alpha - A number between 0 and 1.
-   * @returns The opacified color string.
-   */
-  opacify(alpha?: number): string;
-  /**
-   * Rotate color hue.
-   *
-   * @param degrees - A number between -360 and 360.
-   * @returns The rotated color string.
-   */
-  rotate(degrees: number): string;
-  /**
-   * Make the color more transparent.
-   *
-   * @param alpha - A number between -1 and 1.
-   * @returns The transparentized color string.
-   */
-  transparentize(alpha?: number): string;
-}
-/**
- * Check 2 colors for WCAG compliance.
- *
- * @param left - The first color string.
- * @param right - The second color string.
- * @returns Analysis object with WCAG compliance information.
- */
-//#endregion
-//#region src/colour/conversion.d.ts
-declare function convert<T extends ConvertDestinations>(colour: Colourish, destination: T): T extends `oklch-absolute` ? OkLchAbsolute : T extends `oklch-scalar` ? OkLchScalar : T extends `srgb-8bit` ? Rgb8Bit : T extends `srgb-scalar` ? RgbScalar : T extends `hsl-scalar` ? HslScalar : T extends `hsl-absolute` ? HslAbsolute : never;
-/**
-* Like {@link convert}, but result is a CSS colour string
-* @param colour
-* @param destination
-*/
-declare function convertToString(colour: Colourish, destination: ConvertDestinations): string;
-/**
-* Converts some kind of colour into a scalar representation. Supports oklch, hsl and srgb.
-* @param colour Colour to convert
-* @param destination Destination colour format
-*/
-declare function convertScalar<T extends ColourSpaces>(colour: Colourish, destination: T): T extends `oklch` ? OkLchScalar : T extends `hsl` ? HslScalar : T extends `srgb` ? RgbScalar : never;
-declare function toCssColour(colour: Colourish | object): string;
-declare function toHexColour(colour: Colourish | object): string;
-declare function toLibraryColour(colour: Colourish): Colorizr;
-declare function guard$4(colour: Colour): void;
-declare function toColour(colourish: any): Colour;
-/**
-* Returns a CSS-ready string
-* representation.
-* ```js
-* element.style.backgroundColor = resolveToString(`red`);
-* ```
-*
-* Tries each parameter in turn, returning the value
-* for the first that resolves. This can be useful for
-* having fallback values.
-*
-* ```js
-* // Try a CSS variable, a object property or finally fallback to red.
-* element.style.backgroundColor = toStringFirst('--some-var', opts.background, `red`);
-* ```
-* @param colours Array of colours to resolve
-*/
-declare function toStringFirst(...colours: Array<Colourish | undefined>): string;
-declare function rgbToHsl(rgb: Rgb, scalarResult: true): HslScalar;
-declare function rgbToHsl(rgb: Rgb, scalarResult: false): HslAbsolute; //#endregion
-//#region src/colour/css-colours.d.ts
-/**
-* Converts from some kind of colour that is legal in CSS
-* into a structured Colour type.
-* 
-* Handles: hex format, CSS variables, colour names
-* ```js
-* fromCssColour(`#ffffff`);
-* fromCssColour(`blue`);
-* fromCssColour(`--some-variable`);
-* fromCssColour(`hsl(50, 50%, 50%)`);
-* fromCssColour(`rgb(50, 100, 100)`);
-* ```
-* @param colour 
-* @returns 
-*/
-declare const fromCssColour: (colour: string) => Colour;
-/**
-* Resolves a named colour to a colour string.
-* 
-* ```js
-* resolveCss(`red`);
-* ```
-* @param colour CSS named colour
-* @returns 
-*/
-declare function resolveCss(colour: CssColourNames): string;
-type CssColourNames = keyof typeof cssDefinedHexColours;
-declare const cssDefinedHexColours: Record<string, string>; //#endregion
-//#region src/colour/generate.d.ts
-/**
-* Returns a full HSL colour string (eg `hsl(20,50%,75%)`) based on a index.
-* It's useful for generating perceptually different shades as the index increments.
-*
-* ```
-* el.style.backgroundColor = goldenAgeColour(10);
-* ```
-*
-* Saturation and lightness can be specified, as numeric ranges of 0-1.
-*
-* @param saturation Saturation (0-1), defaults to 0.5
-* @param lightness Lightness (0-1), defaults to 0.75
-* @param alpha Opacity (0-1), defaults to 1.0
-* @returns HSL colour string eg `hsl(20,50%,75%)`
-*/
-declare const goldenAngleColour: (index: number, saturation?: number, lightness?: number, alpha?: number) => string;
-/**
-* Returns a random hue component (0..359)
-* 
-* ```
-* // Generate hue
-* const h = randomHue(); // 0-359
-*
-* // Generate hue and assign as part of a HSL string
-* el.style.backgroundColor = `hsl(${randomHue(), 50%, 75%})`;
-* ```
-* @param rand
-* @returns
-*/
-declare const randomHue: (rand?: RandomSource) => number; //#endregion
-//#region src/colour/guards.d.ts
-declare function isHsl(v: any): v is Hsl;
-declare function isRgb(v: any): v is Rgb;
-/**
-* If the input object has r,g&b properties, it will return a fully-
-* formed Rgb type with `unit` and `space` properties.
-*
-* If it lacks these basic three properties or they are out of range,
-*  _undefined_ is returned.
-*
-* If RGB values are less than 1 assumes unit:scalar. Otherwise unit:8bit.
-* If RGB values exceed 255, _undefined_ returned.
-* @param v
-* @returns
-*/
-declare function tryParseObjectToRgb(v: any): Rgb | undefined;
-declare function tryParseObjectToHsl(v: any): Hsl | undefined;
-declare function isOkLch(v: any): v is OkLch;
-declare function isColourish(v: any): v is Colourish;
-declare namespace hsl_d_exports {
-  export { absolute$1 as absolute, changeLightness$1 as changeLightness, fromCss$3 as fromCss, fromHexString$3 as fromHexString, generateScalar$1 as generateScalar, guard$3 as guard, interpolator$3 as interpolator, parseCssHslFunction, scalar$3 as scalar, toAbsolute$1 as toAbsolute, toCssString$2 as toCssString, toHexString$3 as toHexString, toLibraryRgb, toScalar$3 as toScalar, withOpacity$3 as withOpacity };
-}
-/**
-* Scales the opacity value of an input HSL value
-* ```js
-* withOpacity()
-* ```
-* @param value Colour
-* @param fn Function that calcules opacity based on input scalar value
-*/
-declare function withOpacity$3<T extends Hsl>(value: T, fn: (opacityScalar: number, value: T) => number): T;
-/**
-* Increases or decreases lightness by this percentage, returning new colour
-*
-* Amount to change:
-* 'fixed': a fixed amount
-* 'delta': increase/decrease by this amount
-* 'pdelta': proportion of current value to change by ('percentage delta')
-*
-* ```
-* const colour = { h: 0.5, s: 0.5, l: 0.5, space: `hsl`, unit: `scalar` };
-* changeLightness(colour, { pdelta: 0.1 }); // l: 0.55
-* changeLightness(colour, { delta: 0.1 });  // l: 0.6
-* changeLightness(colour, { fixed: 0.5 });  // l: 0.5
-* ```
-*
-* Keep in mind the numerical value will depend on the unit of `value`. If it's scalar,
-* lightness is 0..1 scale, otherwise 0..100 scale.
-*
-* Use negative values to decrease (does not apply to 'fixed')
-* @param value Hsl colour
-* @param amount Amount to change
-*/
-declare function changeLightness$1(value: Hsl, amount: Partial<{
-  pdelta: number;
-  delta: number;
-  fixed: number;
-}>): Hsl;
-declare function fromHexString$3<T extends ParsingOptions<Hsl>>(hexString: string, scalar: T): T extends {
-  scalar: true;
-} ? HslScalar : HslAbsolute;
-declare function fromCss$3<T extends ParsingOptions<Hsl>>(value: string, options?: T): T extends {
-  scalar: true;
-} ? HslScalar : HslAbsolute;
-declare function toCssString$2(hsl: Hsl): string;
-declare function toHexString$3(hsl: Hsl): string;
-declare function toAbsolute$1(hslOrString: Hsl | Rgb | string): HslAbsolute;
-/**
-* Generates a {@link HslScalar} value.
-*
-* ```js
-* generateScaler(10); // 10deg, default to full saturation, half lightness and full opacity
-*
-* // Generate HSL value from radian angle and 50% saturation
-* generateScalar(`10rad`, 0.5);
-*
-* // Generate from numeric CSS variable
-* generateScalar(`--hue`);
-* ```
-* @param absoluteHslOrVariable Hue angle or CSS variable
-* @param saturation
-* @param lightness
-* @param opacity
-*/
-declare function generateScalar$1(absoluteHslOrVariable: string | number | Angle, saturation?: number, lightness?: number, opacity?: number): HslScalar;
-/**
-* Converts a {@link Hsl} value to scalar units, or parses a colour string
-* and converts it.
-*
-* ```js
-* toScalar({ h: 100, s: 50, l: 100, unit: `absolute` });
-* toScalar(`red`);
-* ```
-* @param colour
-*/
-declare function toScalar$3(colour: Rgb | Hsl | string): HslScalar;
-declare function guard$3(hsl: Hsl): void;
-declare function interpolator$3(a: Hsl | string, b: Hsl | string, direction?: `longer` | `shorter`): (amount: number) => HslScalar;
-/**
-* Creates a HslScalar value from scalar (0..1) values
-* @param hue
-* @param sat
-* @param lightness
-* @param opacity
-*/
-declare function scalar$3(hue?: number, sat?: number, lightness?: number, opacity?: number): HslScalar;
-declare function absolute$1(hue?: number, sat?: number, lightness?: number, opacity?: number): HslAbsolute;
-/**
-* It seems Colorizr can't handle 'deg' units
-* @param value
-*/
-declare function parseCssHslFunction(value: string): Hsl;
-/**
-* Converts a Hsl structure (or CSS string) to Colorizr's RGB format
-* @param hsl HSL colour
-*/
-declare function toLibraryRgb(hsl: Hsl | string): RGB; //#endregion
-//#region src/colour/interpolate.d.ts
-/**
-* Returns a function to interpolate between colours, with results as a structured {@link Colour} object.
-* ```js
-* const i = interpolator([`orange`, `yellow`, `red`]);
-*
-* // Get a random colour on the above spectrum
-* i(Math.random());
-* ```
-*
-* Results will vary depending on the colour space used, play with the options.
-* When using a hue-based colour space, the `hue` option sets the logic for how hue values wrap.
-*
-* ```js
-* interpolator([`orange`, `yellow`, `red`], { space: `hsl`, hue: `longer })
-* ```
-*
-* Example: Draw the interpolation as a spectrum on a canvas, where each pixel is one step
-* ```js
-* let v = 0;
-* let incrementBy = 0.01;
-* while (v <= 1) {
-*  // Get colour at this interpolation point 0..1
-*  const colour = fn(v);
-*  // Convert to a CSS string
-*  ctx.fillStyle = Colour.toCssColour(colour);
-*  // Draw a 1px wide rect, and shuffle along to the next x position
-*  ctx.fillRect(x, y, 1, h);
-*  x += 1;
-*  v += incrementBy;
-* }
-* ```
-* @param colours Colours to interpolate between
-* @param opts Options for interpolation
-* @returns Function that interpolates based on an amount, returning a structured Colour
-*/
-declare function interpolator$2(colours: Colourish[], opts?: Partial<ColourInterpolationOpts>): (amt: number) => Colour;
-/**
-* Returns a CSS `linear-gradient` with stops corresponding to the given list of `colours`.
-* ```js
-* element.style.background = Colour.cssLinearGradient(['red','green','blue']);
-* ```
-* @param colours
-* @returns A 'linear-gradient' string for use in CSS, eg for background.
-*/
-declare function cssLinearGradient(colours: Colourish[]): string;
-/**
-* Returns a function that interpolates between two colours. Returns string colour values.
-* If you want the result as a structured colour, use {@link interpolatorDual} instead.
-*
-* By default takes a shorter direction and uses the OkLCH colourspace.
-* ```js
-* const i = interpolator(`blue`, `red`);
-* i(0.5); // Get the colour at 50%, as a string.
-* ```
-*
-* To work with structured colour values, use one of the space's `interpolate` functions.
-*
-* If you want to create discrete steps, consider {@link createSteps} or {@link scale}.
-*
-* @param colourA First colour
-* @param colourB Second colour
-* @param options Interpolation options. By default uses shorter direction and OkLCH colour space.
-*/
-declare function interpolatorDualToString(colourA: Colourish, colourB: Colourish, options?: Partial<ColourInterpolationOpts>): ((amount: number) => string);
-/**
-* Returns a function that interpolates between two colours. Returns structured colour values.
-* If you want the result as a ready-to-use CSS string, use {@link interpolatorDualToString} instead.
-*
-* By default takes a shorter direction and uses the OkLCH colourspace.
-* ```js
-* const i = interpolator(`blue`, `red`);
-* i(0.5); // Get the colour at 50%, as a Colour structure.
-* ```
-*
-* If you want to create discrete steps, consider {@link createSteps} or {@link scale}.
-* @param colourA First colour
-* @param colourB Second colour
-* @param options Interpolation options. By default uses shorter direction and OkLCH colour space.
-* @returns Function that interpolates between two colours, returning a structured Colour
-*/
-declare function interpolatorDual(colourA: Colourish, colourB: Colourish, options?: Partial<ColourInterpolationOpts>): (amount: number) => Colour;
-/**
-* Produces a stepped scale of colours.
-*
-* Builds off {@link createSteps} which can only step between two colours.
-*
-* ```js
-* // A scale of from red to green, with three colours in-between
-* const steps = Colour.scale([ `red`, `green` ], { stepsBetween: 3 });
-* for (const step of steps) {
-*  // A CSS colour string
-* }
-* ```
-*
-* {@link cssLinearGradient} can produce a smooth gradient in CSS on the basis
-* of the stepped colours.
-* @param colours
-* @param opts
-* @returns Array of colours in string form
-*/
-declare function scale(colours: Colourish[], opts?: Partial<ColourStepOpts>): string[];
-type CreateStepsOptions = Partial<{
-  space: ColourSpaces;
-  steps: number;
-  direction: `longer` | `shorter`;
-  exclusive: boolean;
-}>;
-/**
-* Creates discrete colour steps between two colours.
-*
-* Use {@link scale} to create steps between any number of colours.
-*
-* Start and end colours are included (and counted as a step) unless `exclusive` is set to _true_
-*
-* ```js
-* // Array of five HslScalar
-* createSteps(`red`,`blue`, { steps: 5 });
-* ```
-*
-* Defaults to the oklch colour space, 5 steps and non-exclusive.
-* @param a Start colour
-* @param b End colour
-* @param options
-* @returns Colour steps
-*/
-declare function createSteps<T extends CreateStepsOptions>(a: Colourish | string, b: Colourish, options: T): T extends {
-  space: `oklch`;
-} ? OkLchScalar[] : T extends {
-  space: `srgb`;
-} ? RgbScalar[] : T extends {
-  space: `hsl`;
-} ? HslScalar[] : OkLchScalar[]; //#endregion
-//#region src/colour/math.d.ts
-declare function multiplyOpacity<T extends Colourish>(colourish: T, amount: number): T extends string ? string : T extends Hsl ? Hsl : T extends OkLch ? OkLch : T extends Rgb ? Rgb : never;
-/**
-* Does a computation with the opacity of a colour, returning colour string
-* @param colourish Colour
-* @param fn Function that takes original opacity as input and returns output opacity
-*/
-/**
-* Does a computation with the opacity of a colour in a HSL structure
-* @param hsl Colour
-* @param fn Function that takes original opacity as input and returns output opacity
-*/
-/**
-* Does a computation with the opacity of a colour in a RGB structure
-* @param colourish Colour
-* @param fn Function that takes original opacity as input and returns output opacity
-*/
-declare function withOpacity$2<T extends Colourish>(colourish: T, fn: (scalarOpacity: number) => number): T extends string ? string : T extends Hsl ? Hsl : T extends OkLch ? OkLch : T extends Rgb ? Rgb : never;
-declare function setOpacity<T extends Colourish>(colourish: T, amount: number): T extends string ? string : T extends Hsl ? Hsl : T extends OkLch ? OkLch : T extends Rgb ? Rgb : never;
-declare namespace oklch_d_exports {
-  export { OKLCH_CHROMA_MAX, absolute, fromCss$2 as fromCss, fromHexString$2 as fromHexString, fromLibrary, generateScalar, guard$2 as guard, interpolator$1 as interpolator, scalar$2 as scalar, toAbsolute, toCssString$1 as toCssString, toHexString$2 as toHexString, toScalar$2 as toScalar, withOpacity$1 as withOpacity };
-}
-declare const OKLCH_CHROMA_MAX = .4;
-declare function guard$2(lch: OkLch): void;
-/**
-* Coverts from the Colorizr library
-* Tests ranges:
-* l: 0..1
-* c: 0..1
-* h: 0..360
-* alpha: 0..1
-*
-* Default option: { scalar: true }
-* @param lch LCH value
-* @param parsingOptions Options for parsing
-*/
-declare function fromLibrary<T extends ParsingOptions<OkLch>>(lch: LCH, parsingOptions: T): T extends {
-  scalar: true;
-} ? OkLchScalar : OkLchAbsolute;
-/**
-* Parse a HEX-formatted colour into OkLch structured format
-* @param hexString
-* @param options
-*/
-declare function fromHexString$2(hexString: string, options?: ParsingOptions<OkLch>): OkLch;
-/**
-* Converts from some CSS-representation of colour to a structured OkLch format.
-*
-* ```js
-* fromCss(`yellow`);
-* fromCss(`rgb(100,200,90)`);
-* fromCss(`#ff00ff`);
-* ```
-*
-* By default returns a {@link OkLchScalar} (relative) representation. Use the flag 'scalar:true' to get back
-* {@link OkLchAbsolute}.
-* @param value
-* @param options
-*/
-declare function fromCss$2<T extends ParsingOptions<OkLch>>(value: string, options: T): T extends {
-  scalar: true;
-} ? OkLchScalar : OkLchAbsolute;
-/**
-* Returns a string or {@link OkLch} value to absolute form.
-*
-* This means ranges are:
-* lightness: 0..1
-* chroma: 0...CHROMA_MAX (0.4)
-* hue: 0..360
-* @param lchOrString
-*/
-declare function toAbsolute(lchOrString: OkLch | string): OkLchAbsolute;
-declare function toScalar$2(lchOrString: OkLch | string): OkLchScalar;
-/**
-* Returns the colour as a CSS colour string: `oklch(l c h / opacity)`.
-*
-* @param lch Colour
-* @param precision Set precision of numbers, defaults to 3
-* @returns CSS colour string
-*/
-declare function toCssString$1(lch: OkLch, precision?: number): string;
-declare function toHexString$2(lch: OkLch): string;
-declare function generateScalar(absoluteHslOrVariable: string | number | Angle, chroma?: number, lightness?: number, opacity?: number): OkLchScalar;
-/**
-* Scales the opacity value of an input Oklch value
-* ```js
-* withOpacity()
-* ```
-* @param value
-* @param fn
-*/
-declare function withOpacity$1<T extends OkLch>(value: T, fn: (opacityScalar: number, value: T) => number): T;
-declare function interpolator$1(a: OkLch | string, b: OkLch | string, direction?: `longer` | `shorter`): (amount: number) => OkLchScalar;
-declare function scalar$2(lightness?: number, chroma?: number, hue?: number, opacity?: number): OkLchScalar;
-/**
-* Create an LCH colour using absolute hue
-* @param l Lightness 0..1
-* @param c Chroma 0..4
-* @param h Hue 0..360
-* @param opacity
-*/
-declare function absolute(l: number, c: number, h: number, opacity?: number): OkLchAbsolute;
-declare namespace srgb_d_exports {
-  export { changeLightness, eightBit$1 as eightBit, fromCss$1 as fromCss, fromHexString$1 as fromHexString, guard$1 as guard, interpolator, lightness, parseCssRgbFunction, scalar$1 as scalar, to8bit$1 as to8bit, toCssString, toHexString$1 as toHexString, toLibraryHsl, toScalar$1 as toScalar, withOpacity };
-}
-declare function withOpacity<T extends Rgb>(value: T, fn: (opacityScalar: number, value: T) => number): T;
-declare function fromHexString$1<T extends boolean>(hexString: string, scalar: T): T extends true ? RgbScalar : Rgb8Bit;
-declare function fromCss$1<T extends ParsingOptions<Rgb>>(value: string, options: T): T extends {
-  scalar: true;
-} ? RgbScalar : Rgb8Bit;
-declare function toHexString$1(rgb: Rgb): string;
-declare function toCssString(rgb: Rgb): string;
-declare function to8bit$1(rgbOrString: Rgb | string): Rgb8Bit;
-declare function toScalar$1(rgbOrString: Rgb | Hsl | string): RgbScalar;
-declare function guard$1(rgb: Rgb): void;
-/**
-* Sets the lightness value.
-*
-* Amount to change:
-* 'fixed': a fixed amount
-* 'delta': increase/decrease by this amount
-* 'pdelta': proportion of current value to change by ('percentage delta')
-*
-* Use negative values to decrease
-* @param rgb Colour
-* @param amount Amount to change
-*/
-declare function changeLightness(rgb: Rgb, amount: Partial<{
-  pdelta: number;
-  delta: number;
-  fixed: number;
-}>): Rgb;
-/**
-* Returns a lightness value (0..1) for an RGB input
-*
-* Calculates lightness by converting to Oklab and using the 'L' value
-* @param rgb
-*/
-declare function lightness(rgb: Rgb): number;
-/**
-* Creates a Rgb8Bit value from 8bit (0..255) values
-* @param red
-* @param green
-* @param blue
-* @param opacity
-*/
-declare function eightBit$1(red?: number, green?: number, blue?: number, opacity?: number): Rgb8Bit;
-/**
-* Creates a RgbScalar value from scalar (0..1) values
-* @param red
-* @param green
-* @param blue
-* @param opacity
-*/
-declare function scalar$1(red?: number, green?: number, blue?: number, opacity?: number): RgbScalar;
-/**
-* It seems Colorizr can't handle % values properly :'(
-* @param value
-*/
-declare function parseCssRgbFunction(value: string): Rgb;
-/**
-* Interpolates colours in Srgb space. Probably
-* really ugly, use OkLch space isntead.
-*
-* ```js
-* const i = interpolator(`red`, `blue`);
-* i(0.5); // Get 50% between these colours
-* ```
-* @param colourA
-* @param colourB
-*/
-declare function interpolator(colourA: Rgb | string, colourB: Rgb | string): (amount: number) => RgbScalar;
-/**
-* Converts a Rgb structure (or CSS string) to Colorizr's HSL format
-* @param rgb
-*/
-declare function toLibraryHsl(rgb: Rgb | string): HSL; //#endregion
-//#region src/colour/to-integer.d.ts
-/**
-* Encode 8-bit RGB values into a 24-bit value (0...16_777_215)
-* 
-* Assumes RGB values are within 0..255 range
-* @param rgb 
-* @returns 
-*/
-declare function encodeRgbTo24Bit(rgb: Rgb8Bit | RgbBase): number;
-/**
-* Decode a 24-bit number (0...16_777_215) into 8-bit RGB
-* @param colour 
-* @returns 
-*/
-declare function decodeRgbFrom24Bit(colour: number): Rgb8Bit;
-/**
-* Encodes 8-bit RGB value into 16-bit RGB565 (0..65_535)
-* 5-bit are used for R & B channels, 6 bits for G
-* 
-* Read more: https://rgbcolorpicker.com/565
-* @param rgb 
-* @returns 
-*/
-declare function encodeRgbTo16Bit565(rgb: Rgb8Bit | RgbBase): number;
-/**
-* Decodes 8-bit RGB value from a 16-bit RGB565 value (0...65_535)
-* Read more: https://rgbcolorpicker.com/565
-* @param colour 
-* @returns 
-*/
-declare function decodeRgbFrom16Bit565(colour: number): Rgb8Bit;
-declare namespace ycbcr_d_exports {
-  export { eightBit, fromCss, fromHexString, fromSrgTo8bit, guard, scalar, to8bit, toHexString, toScalar, toSrgb8bit };
-}
-/**
-* Creates a YCbCr8bit value from 8bit (0..255) values
-* @param y Luma 0..255
-* @param cb Chroma blue 0..255
-* @param cr Chroma red 0..255
-* @param opacity 0..255
-* @returns YCbCr8bit
-*/
-declare function eightBit(y?: number, cb?: number, cr?: number, opacity?: number): YCbCr8bit;
-/**
-* Creates a YCbCr8bit value from scalar (0..1) values
-* @param y Luma 0..1
-* @param cb Chroma blue 0..1
-* @param cr Chroma red 0..1
-* @param opacity 0..1
-* @returns YCbCrScalar
-*/
-declare function scalar(y?: number, cb?: number, cr?: number, opacity?: number): YCbCrScalar;
-/**
-* Converts from scalar or 8bit RGB to YCbCr8bit
-* @param rgb
-* @returns
-*/
-declare function fromSrgTo8bit(rgb: Rgb): YCbCr8bit;
-declare function toSrgb8bit(ycbcr: YCbCr): Rgb8Bit;
-/**
-* Returns a YCbCr8bit format from either scalar or 8bit.
-* If the input is already 8bit, it is returned as-is.
-* @param ycbcr 8bit or scalar YCbCr value
-* @returns YCbCr8bit
-*/
-declare function to8bit(ycbcr: YCbCr): YCbCr8bit;
-declare function fromHexString<T extends ParsingOptions<YCbCr>>(hexString: string, scalar: T): T extends {
-  scalar: true;
-} ? YCbCrScalar : YCbCr8bit;
-declare function fromCss<T extends ParsingOptions<YCbCr>>(value: string, options: T): T extends {
-  scalar: true;
-} ? YCbCrScalar : YCbCr8bit;
-declare function toScalar(colour: YCbCr | Rgb | string): YCbCrScalar;
-declare function guard(rgb: YCbCr): void;
-/**
-* Converts a YCbCr colour to a RGB hex string.
-* @param ycbcr
-* @returns
-*/
-declare function toHexString(ycbcr: YCbCr): string;
-declare namespace index_d_exports {
-  export { Colour, ColourInterpolationOpts, ColourInterpolator, ColourSpaces, ColourStepOpts, Colourish, ConvertDestinations, CreateStepsOptions, CssColourNames, Hsl, HslAbsolute, HslBase, HslScalar, hsl_d_exports as HslSpace, LchBase, OkLch, OkLchAbsolute, OkLchBase, OkLchScalar, oklch_d_exports as OklchSpace, ParsingOptions, Rgb, Rgb8Bit, RgbBase, RgbScalar, srgb_d_exports as SrgbSpace, YCbCr, YCbCr8bit, YCbCrBase, YCbCrScalar, ycbcr_d_exports as YCbCrSpace, convert, convertScalar, convertToString, createSteps, cssDefinedHexColours, cssLinearGradient, decodeRgbFrom16Bit565, decodeRgbFrom24Bit, encodeRgbTo16Bit565, encodeRgbTo24Bit, fromCssColour, goldenAngleColour, guard$4 as guard, interpolator$2 as interpolator, interpolatorDual, interpolatorDualToString, isColourish, isHsl, isOkLch, isRgb, multiplyOpacity, randomHue, resolveCss, rgbToHsl, scale, setOpacity, toColour, toCssColour, toHexColour, toLibraryColour, toStringFirst, tryParseObjectToHsl, tryParseObjectToRgb, withOpacity$2 as withOpacity };
-} //#endregion
-//#endregion
-//#region src/colour-picker/colour-picker.d.ts
-declare class ColourPicker extends LitElement {
-  l: number;
-  c: number;
-  h: number;
-  a: number;
-  hidePreview: boolean;
-  hideH: boolean;
-  hideL: boolean;
-  hideC: boolean;
-  showA: boolean;
-  horizontal: boolean;
-  slidersVertical: boolean;
-  hideTooltips: boolean;
-  private _valueAttr;
-  rangeLAttr: string | null;
-  rangeCAttr: string | null;
-  rangeHAttr: string | null;
-  rangeAAttr: string | null;
-  private _ranges;
-  _sliderL: HTMLElement;
-  _sliderC: HTMLElement;
-  _sliderH: HTMLElement;
-  _sliderA: HTMLElement;
-  _previewEl: HTMLElement;
-  private _defaultL;
-  private _defaultC;
-  private _defaultH;
-  private _defaultA;
-  private readonly _userInitiated;
-  get value(): string;
-  set value(colourString: string);
-  /**
-   * Set the colour from any ixfx-compatible format (CSS string, OkLch object,
-   * HSL object, etc.). Also updates the double-click reset defaults for all
-   * sliders.
-   */
-  setColour(colour: index_d_exports.Colourish): void;
-  get rangeL(): Range;
-  set rangeL(range: RangeInput);
-  get rangeC(): Range;
-  set rangeC(range: RangeInput);
-  get rangeH(): Range;
-  set rangeH(range: RangeInput);
-  get rangeA(): Range;
-  set rangeA(range: RangeInput);
-  setRangeL(range: RangeInput): void;
-  setRangeC(range: RangeInput): void;
-  setRangeH(range: RangeInput): void;
-  setRangeA(range: RangeInput): void;
-  willUpdate(changedProperties: PropertyValues): void;
-  private _applyRangeInput;
-  private _coerceRangeInput;
-  private _setRangeFromAttribute;
-  private _setRange;
-  private _getRange;
-  private _parseRangeString;
-  private _normalizeRange;
-  private _clampToRange;
-  render(): import("lit").TemplateResult<1>;
-  firstUpdated(changedProperties: PropertyValues): void;
-  updated(changedProperties: PropertyValues): void;
-  _updateGradients(): void;
-  _onInput: (e: Event, channel: `l` | `c` | `h` | `a`) => void;
-  _onChange: (e: Event, channel: `l` | `c` | `h` | `a`) => void;
-  _dispatchInput(): void;
-  _dispatchChange(): void;
-  static styles: CSSResultGroup;
-}
-declare global {
-  interface HTMLElementTagNameMap {
-    'ixfx-colour-picker': ColourPicker;
-  }
-} //# sourceMappingURL=colour-picker.d.ts.map
-//#endregion
-//#region src/colour-picker/colour-picker-popup.d.ts
-declare const PICKER_SIZES: {
-  readonly small: {
-    readonly width: 130;
-    readonly height: 100;
-  };
-  readonly medium: {
-    readonly width: 100;
-    readonly height: 155;
-  };
-  readonly large: {
-    readonly width: 200;
-    readonly height: 180;
-  };
-  readonly huge: {
-    readonly width: 290;
-    readonly height: 240;
-  };
-};
-type PickerSize = keyof typeof PICKER_SIZES;
-declare class ColourPickerPopup extends LitElement {
-  mode: `fluid` | `confirm`;
-  l: number;
-  c: number;
-  h: number;
-  a: number;
-  showPreview: boolean;
-  hideH: boolean;
-  hideL: boolean;
-  hideC: boolean;
-  showA: boolean;
-  horizontal: boolean;
-  size: PickerSize;
-  private _isOpen;
-  private _everOpened;
-  _popupEl: HTMLElement;
-  _pickerEl: ColourPicker;
-  private readonly _uid;
-  private readonly _anchorName;
-  private readonly _popupId;
-  private _pendingL;
-  private _pendingC;
-  private _pendingH;
-  private _pendingA;
-  private _savedL;
-  private _savedC;
-  private _savedH;
-  private _savedA;
-  private _pendingConfirmed;
-  constructor();
-  get value(): string;
-  private get _innerHidePreview();
-  private get _pickerDimensions();
-  setColour(colour: index_d_exports.Colourish): void;
-  firstUpdated(changedProperties: PropertyValues): void;
-  updated(changedProperties: PropertyValues): void;
-  private _applyAnchorPositioning;
-  private _updateSwatchBackground;
-  private _onPopoverToggle;
-  private _onPickerInput;
-  private _onPickerChange;
-  private _onConfirm;
-  private _onSwatchClick;
-  private _dispatchInput;
-  private _dispatchChange;
-  render(): import("lit").TemplateResult<1>;
-  static styles: CSSResultGroup;
-}
-declare global {
-  interface HTMLElementTagNameMap {
-    'ixfx-colour-picker-popup': ColourPickerPopup;
-  }
-}
-//#endregion
-export { ColourPickerInputEvent as a, ColourPickerEventDetail as i, ColourPicker as n, OklchValue as o, ColourPickerChangeEvent as r, ColourPickerPopup as t };
-//# sourceMappingURL=index-DgXpCg_G.d.ts.map