@chocbite/ts-lib-form 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,901 @@
+
+import { AccessTypes, Base } from "@chocbite/ts-lib-base";
+import { ListField } from "@chocbite/ts-lib-list";
+import { State, StateEnumRelated, StateNumberRelated, StateStringRelated } from "@chocbite/ts-lib-state";
+
+//#region node_modules/@chocbite/ts-lib-result/dist/index.d.ts
+/**Symbol used to identify Result objects, can be used to create result compliant objects */
+declare const RESULT_KEY: unique symbol;
+/**Symbol used to identify Option objects, can be used to create option compliant objects */
+declare const OPTION_KEY: unique symbol;
+interface OptionBase<T> {
+  /**Unique symbol to identify Option objects */
+  readonly [OPTION_KEY]: true;
+  /**Is true when a value is available*/
+  readonly some: boolean;
+  /**Is true when no value is available*/
+  readonly none: boolean;
+  /**The value*/
+  readonly value?: T;
+  /**Returns the contained value, if exists. Throws an error if not.
+   * @param msg the message to throw if no value exists.*/
+  expect(msg: string): T;
+  /**Returns the contained value, if exists. Throws an error if not.*/
+  unwrap(): T;
+  /**Returns the contained value or a provided default.
+   * @param value value to use as default*/
+  unwrap_or<T2>(value: T2): T | T2;
+  /**Calls mapper if the Option is `Some`, otherwise returns `None`.
+   * This function can be used for control flow based on `Optional` values.*/
+  and_then<T2>(mapper: (value: T) => OptionSome<T2>): Option<T2>;
+  and_then(mapper: (value: T) => OptionNone): Option<T>;
+  and_then<T2>(mapper: (value: T) => Option<T2>): Option<T2>;
+  /**Calls mapper if the Option is `None`, otherwise returns `Some`.
+   * This function can be used for control flow based on `Optional` values.*/
+  or_else<T2>(mapper: () => OptionSome<T2>): Option<T2>;
+  or_else(mapper: () => OptionNone): Option<T>;
+  or_else<T2>(mapper: () => Option<T2>): Option<T2>;
+  /**Maps an `Optional<T>` to `Optional<U>` by applying a function to a contained `Some` value, leaving a `None` value untouched.
+   * This function can be used to compose the Options of two functions.*/
+  map<U>(mapper: (value: T) => U): Option<U>;
+  /**Compares two `Optional<T>` values for equality.
+   * @returns true if equal, false otherwise. */
+  compare(other: Option<T>): boolean;
+  /**Maps an `Optional<T>` to a `Result<T, E>`.*/
+  to_result<E>(error: E): Result<T, E>;
+}
+declare class OptionSome<T> implements OptionBase<T> {
+  get [OPTION_KEY](): true;
+  readonly value: T;
+  constructor(value: T);
+  get some(): true;
+  get none(): false;
+  expect(): T;
+  unwrap(): T;
+  unwrap_or(): T;
+  and_then<T2>(mapper: (value: T) => OptionSome<T2>): OptionSome<T2>;
+  and_then(mapper: (value: T) => OptionNone): OptionNone;
+  and_then<T2>(mapper: (value: T) => Option<T2>): Option<T2>;
+  or_else(): OptionSome<T>;
+  map<U>(mapper: (value: T) => U): OptionSome<U>;
+  compare(other: Option<T>): boolean;
+  to_result(): ResultOk<T>;
+}
+declare class OptionNone implements OptionBase<never> {
+  get [OPTION_KEY](): true;
+  get some(): false;
+  get none(): true;
+  expect(msg: string): never;
+  unwrap(): never;
+  unwrap_or<T2>(val: T2): T2;
+  and_then(): OptionNone;
+  or_else<T2>(mapper: () => OptionSome<T2>): OptionSome<T2>;
+  or_else(mapper: () => OptionNone): OptionNone;
+  or_else<T2>(mapper: () => Option<T2>): Option<T2>;
+  map(): OptionNone;
+  compare(other: Option<never>): boolean;
+  to_result<E>(error: E): ResultErr<E>;
+}
+interface ResultBase<T, E> {
+  /**Unique symbol to identify Result objects */
+  readonly [RESULT_KEY]: true;
+  /**Is true when the result is valid and false when it is invalid*/
+  readonly ok: boolean;
+  /**Is false when the result is valid and true when it is invalid*/
+  readonly err: boolean;
+  /**The value for the result, only exists when it is valid*/
+  readonly value?: T;
+  /**The error for the result, only exists when it is invalid*/
+  readonly error?: E;
+  /**Returns the contained valid value, if exists. Throws an error if not.
+   * @param msg the message to throw if the value is invalid.*/
+  expect(msg: string): T;
+  /**Returns the contained valid value, if does not exist. Throws an error if it does.
+   * @param msg the message to throw if the value is valid.*/
+  expect_err(msg: string): E;
+  /**Returns the contained valid value.
+   * Throws if the value is invalid, with a message provided by the error's value.*/
+  unwrap(): T;
+  /**Returns the contained valid value or a provided default.*/
+  unwrap_or<T2>(value: T2): T | T2;
+  /**Returns the contained error value.
+   * Throws if the value is valid, with the value.*/
+  unwrap_err(): E;
+  unwrap_err_or<E2>(error: E2): E | E2;
+  /**Calls mapper function if the result is valid, otherwise returns the error value of self.
+   * This function can be used for control flow based on `Result` values.*/
+  and_then<T2>(mapper: (value: T) => ResultOk<T2>): Result<T2, E>;
+  and_then<E2>(mapper: (value: T) => ResultErr<E2>): Result<T, E2>;
+  and_then<T2, E2>(mapper: (value: T) => Result<T2, E2>): Result<T2, E2>;
+  /**Calls mapper function if the result is an error, otherwise returns the value self.
+   * This function can be used for control flow based on `Result` values.*/
+  or_else<T2>(mapper: (error: E) => ResultOk<T2>): Result<T2, E>;
+  or_else<E2>(mapper: (error: E) => ResultErr<E2>): Result<T, E2>;
+  or_else<T2, E2>(mapper: (error: E) => Result<T2, E2>): Result<T2, E2>;
+  /**Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained valid value, leaving an error value untouched.
+   * This function can be used to compose the results of two functions.*/
+  map<U>(mapper: (value: T) => U): Result<U, E>;
+  /**Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained error value, leaving a valid value untouched.
+   * This function can be used to pass through a successful result while handling an error.*/
+  map_err<F>(mapper: (error: E) => F): Result<T, F>;
+  /**Compares two `Result<T, E>` values for equality.
+   * @returns true if equal, false otherwise. */
+  compare(other: Result<T, E>): boolean;
+  /**Converts from `Result<T, E>` to `Optional<T>`, discarding the error if any*/
+  to_option(): Option<T>;
+}
+declare class ResultOk<T> implements ResultBase<T, never> {
+  get [RESULT_KEY](): true;
+  readonly value: T;
+  constructor(value: T);
+  get ok(): true;
+  get err(): false;
+  expect(): T;
+  expect_err(msg: string): never;
+  unwrap(): T;
+  unwrap_or(): T;
+  unwrap_err(): never;
+  unwrap_err_or<E2>(error: E2): E2;
+  and_then<T2>(mapper: (value: T) => ResultOk<T2>): ResultOk<T2>;
+  and_then<E2>(mapper: (value: T) => ResultErr<E2>): ResultErr<E2>;
+  and_then<T2, E2>(mapper: (value: T) => Result<T2, E2>): Result<T2, E2>;
+  or_else(): ResultOk<T>;
+  map<U>(func: (value: T) => U): ResultOk<U>;
+  map_err(): ResultOk<T>;
+  compare(other: Result<T, any>): boolean;
+  to_option(): OptionSome<T>;
+}
+declare class ResultErr<E> implements ResultBase<never, E> {
+  get [RESULT_KEY](): true;
+  readonly error: E;
+  constructor(error: E);
+  get valid(): false;
+  get ok(): false;
+  get err(): true;
+  expect(msg: string): never;
+  expect_err(): E;
+  unwrap(): never;
+  unwrap_or<T2>(val: T2): T2;
+  unwrap_err(): E;
+  unwrap_err_or(): E;
+  and_then(): ResultErr<E>;
+  or_else<T2>(mapper: (error: E) => ResultOk<T2>): ResultOk<T2>;
+  or_else<E2>(mapper: (error: E) => ResultErr<E2>): ResultErr<E2>;
+  or_else<T2, E2>(mapper: (error: E) => Result<T2, E2>): Result<T2, E2>;
+  map(): ResultErr<E>;
+  map_err<F>(mapper: (error: E) => F): ResultErr<F>;
+  compare(other: Result<any, E>): boolean;
+  to_option(): OptionNone;
+}
+type Result<T, E> = ResultOk<T> | ResultErr<E>;
+type Option<T> = OptionSome<T> | OptionNone;
+//#endregion
+//#region node_modules/@chocbite/ts-lib-svg/dist/index.d.mts
+type SVGFunc = () => SVGSVGElement; //#endregion
+//#endregion
+//#region src/base.d.ts
+/**Colors for form elements that have selectable colors*/
+declare const FormColors: {
+  readonly None: "none";
+  readonly Black: "black";
+  readonly Green: "green";
+  readonly Red: "red";
+  readonly Blue: "blue";
+  readonly Yellow: "yellow";
+};
+type FormColors = (typeof FormColors)[keyof typeof FormColors];
+/**Shared component class for other components to inherit from*/
+declare abstract class FormElement extends Base {
+  static element_name(): string;
+  static element_name_space(): string;
+}
+interface FormValueOptions<RT, ID extends string | undefined> {
+  /**ID form form element */
+  id?: ID;
+  /**Value for form element */
+  value?: RT;
+  value_by_state?: State<RT, Option<{}>, RT>;
+  /**Longer description what form element does */
+  description?: string;
+  /**Change listener function*/
+  change?: (val: RT) => void;
+}
+/**Shared class for all components with values*/
+declare abstract class FormValue<RT, ID extends string | undefined> extends FormElement {
+  #private;
+  static element_name(): string;
+  static apply_options<RT, ID extends string | undefined>(element: FormValue<RT, ID>, options: FormValueOptions<RT, ID>): void;
+  readonly form_id: ID;
+  constructor(id?: ID);
+  protected _description?: string;
+  /**Sets the current label of the element*/
+  set description(text: string);
+  get description(): string;
+  protected _buffer?: RT;
+  get buffer(): RT | undefined;
+  protected _state?: State<RT, Option<{}>, RT>;
+  /**This sets the value of the component*/
+  set value_by_state(state: State<RT, Option<{}>, RT> | undefined);
+  /**This sets the value of the component*/
+  set value(val: RT);
+  /**Returns value of the component*/
+  get value(): Result<RT, string>;
+  set error(err: string | undefined);
+  /**Clears the value and error of the component if not state based*/
+  clear(): void;
+  /**Called when value is set by value setter or state*/
+  protected abstract new_value(val: RT): void;
+  /**Clears form element graphically*/
+  protected abstract clear_value(): void;
+  /**Called when error is set by error or state*/
+  protected abstract new_error(val: string): void;
+  /**Called when error is cleared by error or state*/
+  protected abstract clear_error(): void;
+  /**Called when state has related information */
+  protected abstract state_related(related: {}): void;
+}
+/**Shared class for all components with values*/
+declare abstract class FormValueWrite<RT, ID extends string | undefined> extends FormValue<RT, ID> {
+  #private;
+  static element_name(): string;
+  protected warn_input: HTMLInputElement;
+  constructor(id?: ID);
+  set change(func: (val: RT) => void);
+  get change(): ((val: RT) => void) | undefined;
+  /**Returns the value of the component if it has changed*/
+  get changed(): boolean;
+  warn(message: string): void;
+  /**Function to limit value entered */
+  protected limit_value(val: RT): PromiseLike<Result<RT, string>>;
+  /**Function to check value */
+  protected check_value(val: RT): PromiseLike<Result<RT, string>>;
+  /**Function to update value*/
+  protected set_value_limit(val: RT): Promise<Result<RT, string>>;
+  /**Function to update value*/
+  protected set_value_check(val: RT): Promise<Result<RT, string>>;
+}
+//#endregion
+//#region src/boolean/lamp/lamp.d.ts
+interface FormLampOptions<T extends boolean | number, C extends FormColors[], ID extends string | undefined> extends FormValueOptions<T, ID> {
+  /**Sets the lamp colors */
+  colors: C;
+  /**Lamp text */
+  text?: string;
+  /**Icon for lamp */
+  icon?: SVGFunc;
+}
+declare class FormLamp<T extends boolean | number, C extends FormColors[], ID extends string | undefined> extends FormValue<T, ID> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  /**Sets the current text of the lamp*/
+  set text(label: string);
+  get text(): string;
+  /**Changes the icon of the lamp*/
+  set icon(icon: SVGFunc | undefined);
+  /** Sets the background color of the lamp*/
+  set colors(colors: C);
+  /**Called when value is changed */
+  protected new_value(value: number | boolean): void;
+  protected clear_value(): void;
+  protected new_error(err: string): void;
+  protected clear_error(): void;
+  protected state_related(_related: Option<{}>): void;
+}
+//#endregion
+//#region src/boolean/button/button.d.ts
+interface FormButtonOptions<ID extends string | undefined> extends FormValueOptions<boolean, ID> {
+  /**Buttons text */
+  text?: string;
+  /**Icon for button */
+  icon?: SVGFunc;
+  /**Function to call on button click */
+  on_click?: () => void;
+  /**Set true to make button toggle on click instead of normal */
+  toggle?: boolean;
+  /**Changes the buttons color */
+  color?: FormColors;
+}
+declare class FormButton<ID extends string | undefined> extends FormValueWrite<boolean, ID> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  constructor(id?: ID);
+  /**Sets the current text of the button*/
+  set text(label: string);
+  get text(): string;
+  /**Changes the icon of the button*/
+  set icon(icon: SVGFunc | undefined);
+  /**Function to call on button click*/
+  set on_click(func: (() => void) | undefined);
+  get on_click(): (() => void) | undefined;
+  /**Changes the color of the button*/
+  set color(color: FormColors);
+  /**Called when value is changed */
+  protected new_value(value: boolean): void;
+  protected clear_value(): void;
+  protected new_error(err: string): void;
+  protected clear_error(): void;
+  protected state_related(_related: Option<{}>): void;
+  /**Changes whether the button is maintained or momentary*/
+  set toggle(toggle: boolean | undefined);
+  get toggle(): boolean | undefined;
+}
+/**Creates a button form element */
+declare function form_button<ID extends string | undefined>(options?: FormButtonOptions<ID>): FormButton<ID>;
+//#endregion
+//#region src/boolean/switch/switch.d.ts
+interface FormSwitchOptions<ID extends string | undefined> extends FormValueOptions<boolean, ID> {
+  /**Icon to use for left side*/
+  icon?: SVGFunc;
+  /**Color when switch is on */
+  on_color?: FormColors;
+  /**Color when switch is off */
+  off_color?: FormColors;
+}
+declare class FormSwitch<ID extends string | undefined> extends FormValueWrite<boolean, ID> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  constructor(id?: ID);
+  /**Changes the icon of the switch*/
+  set icon(icon: SVGFunc | undefined);
+  set on_color(color: FormColors);
+  set off_color(color: FormColors);
+  set error_color(color: FormColors);
+  /**Called when value is changed */
+  protected new_value(value: boolean): void;
+  protected clear_value(): void;
+  protected new_error(_err: string): void;
+  protected clear_error(): void;
+  protected state_related(_related: Option<{}>): void;
+}
+/**Creates a switch form element */
+declare function form_switch<ID extends string | undefined>(options?: FormSwitchOptions<ID>): FormSwitch<ID>;
+//#endregion
+//#region node_modules/@chocbite/ts-lib-common/dist/index.d.ts
+/**Event types for base*/
+declare const IPVersion: {
+  readonly V4: 4;
+  readonly V6: 6;
+};
+type IPVersion = (typeof IPVersion)[keyof typeof IPVersion];
+declare class IPAddress {
+  private readonly value;
+  readonly version: IPVersion;
+  constructor(input: string | number | bigint | number[]);
+  private parse_v4_string;
+  private parse_v6_string;
+  private from_array;
+  get is_v4(): boolean;
+  get is_v6(): boolean;
+  get as_big_int(): bigint;
+  get as_array(): number[];
+  to_string(): string;
+}
+/*** Gets the current cursor position (offset) within the contenteditable element.
+ * @param element The contenteditable HTML element.
+ * @returns The offset number, or -1 if the element is not focused or no selection exists.*/
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+/**Checks of the given object is empty only checks for objects own properties*/
+//#endregion
+//#region src/group/group.d.ts
+/**Different border styles for the component group*/
+declare const FormGroupBorderStyle: {
+  readonly None: "none";
+  readonly Inset: "inset";
+  readonly Outset: "outset";
+  readonly Line: "line";
+};
+type FormGroupBorderStyle = (typeof FormGroupBorderStyle)[keyof typeof FormGroupBorderStyle];
+type ExtractB<Arr extends any[]> = Arr extends [infer Head, ...infer Tail] ? Head extends FormValue<infer T, infer ID> ? [FormValue<T, ID>, ...ExtractB<Tail>] : [...ExtractB<Tail>] : [];
+type ToKeyVal<Arr extends FormValue<any, any>[]> = { [K in Arr[number] as K["form_id"]]: K extends FormValue<infer T, any> ? T : never };
+interface FormGroupOptions<L extends FormElement[], ID extends string | undefined, T> extends FormValueOptions<T, ID> {
+  /**Elements to add to the group*/
+  elements?: [...L];
+  /**Wether the group is collapsible, meaning it has a button to collapse and expand all content to the size of that button*/
+  collapsible?: boolean;
+  /**Wether the group is collapsed initially*/
+  collapsed?: boolean;
+  /**Text to show on the collapse button*/
+  collapse_text?: string;
+  /**Border style for group*/
+  border?: FormGroupBorderStyle;
+  /**Removes padding when true allows for putting groups in groups without padding building up */
+  embed?: boolean;
+  /**Group max height in rem, undefined means no limit*/
+  max_height?: number;
+}
+/**Component group class which allows to add elements and controls the flow of the elements*/
+declare class FormGroup<RT extends object, ID extends string | undefined> extends FormValue<RT, ID> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  set elements(elements: FormElement[]);
+  get elements(): FormElement[];
+  /**This places the group at an absolute position in one of the corners of the container*/
+  set border(border: FormGroupBorderStyle | undefined);
+  set collapsible(collapsible: boolean);
+  get collapsible(): boolean;
+  set collapsed(collapsed: boolean);
+  get collapsed(): boolean;
+  set collapse_text(text: string);
+  set max_height(height: number | undefined);
+  set embed(embed: boolean);
+  set value(val: RT);
+  /**Returns value of the component*/
+  get value(): Result<RT, string>;
+  protected new_value(val: RT): void;
+  protected clear_value(): void;
+  protected new_error(err: string): void;
+  protected clear_error(): void;
+  protected state_related(_related: Option<{}>): void;
+  protected on_access(access: AccessTypes): void;
+}
+/**Creates a dropdown form element */
+declare function form_group<L extends FormElement[], ID extends string | undefined, T extends object = Prettify<Partial<ToKeyVal<ExtractB<L>>>>>(options?: FormGroupOptions<L, ID, T>): FormGroup<T, ID>;
+//#endregion
+//#region src/list/list_field.d.ts
+declare class ListFormField<T extends FormElement> extends ListField {
+  static element_name(): string;
+  static element_name_space(): string;
+  set element(component: T);
+  get element(): T;
+}
+declare function form_list_field<T extends FormElement>(element: T): ListFormField<T>;
+//#endregion
+//#region src/number/number_base.d.ts
+interface FormNumberOptions<ID extends string | undefined, RT = number> extends FormValueOptions<RT, ID> {
+  /**Lower limit for slider value*/
+  min?: number;
+  /**Upper limit for slider value*/
+  max?: number;
+  /**Amount of decimals to show*/
+  decimals?: number;
+  /**Unit to use for slider*/
+  unit?: string;
+}
+interface FormNumberWriteOptions<ID extends string | undefined, RT = number> extends FormNumberOptions<ID, RT> {
+  /**Step size, use 0 for automatic step size*/
+  step?: number;
+  /**Start for step, use 0 for automatic */
+  start?: number;
+}
+interface FormStepperBaseOptions<ID extends string | undefined, RT = number> extends FormNumberWriteOptions<ID, RT> {
+  /**wether the events are live as the slider is moved or only when moving stops */
+  live?: boolean;
+  /**Icon to use for decreasing value*/
+  icon_decrease?: SVGFunc;
+  /**Icon to use for increasing value*/
+  icon_increase?: SVGFunc;
+}
+declare abstract class FormNumberWrite<ID extends string | undefined, RT = number> extends FormValueWrite<RT, ID> {
+  static apply_options<RT, ID extends string | undefined>(element: FormNumberWrite<ID, RT>, options: FormNumberWriteOptions<ID, RT>): void;
+  /**Set the minimum value*/
+  abstract set min(min: number | undefined);
+  /**Set the minimum value*/
+  abstract set max(max: number | undefined);
+  /**Sets the size of number change steps*/
+  abstract set step(step: number | undefined);
+  /**Sets the start offset for number steps*/
+  abstract set start(step: number | undefined);
+  /**Sets the amount of decimals the element can have*/
+  abstract set decimals(dec: number | undefined);
+  /**Sets the unit of the element*/
+  abstract set unit(unit: string | undefined);
+  protected state_related(related: Partial<StateNumberRelated>): void;
+}
+//#endregion
+//#region src/number/numberInput/number_input.d.ts
+/**Slide Selector, displays all options in a slider*/
+declare class NumberInput<ID extends string | undefined> extends FormNumberWrite<ID> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  constructor(id?: ID);
+  focus(options?: FocusOptions): void;
+  set unit(unit: string | undefined);
+  set decimals(dec: number | undefined);
+  set min(min: number | undefined);
+  set max(max: number | undefined);
+  set step(step: number | undefined);
+  set start(step: number | undefined);
+  protected new_value(val: number): void;
+  protected clear_value(): void;
+  protected new_error(_val: string): void;
+  protected clear_error(): void;
+  protected limit_value(val: number): PromiseLike<Result<number, string>>;
+  protected check_value(val: number): PromiseLike<Result<number, string>>;
+}
+/**Creates a dropdown form element */
+declare function form_number_input<ID extends string | undefined>(options?: FormNumberWriteOptions<ID>): NumberInput<ID>;
+//#endregion
+//#region src/number/progress/progress.d.ts
+declare class FormProgress<ID extends string | undefined> extends FormValue<number, ID> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  /**Set the minimum value*/
+  set min(min: number);
+  /**Set the minimum value*/
+  set max(max: number);
+  /**Sets the amount of decimals the element can have*/
+  set decimals(dec: number | undefined);
+  /**Sets the unit of the element*/
+  set unit(unit: string | undefined);
+  protected new_value(value: number): void;
+  protected clear_value(): void;
+  protected new_error(err: string): void;
+  protected clear_error(): void;
+  protected state_related(related: Partial<StateNumberRelated>): void;
+}
+/**Creates a progress form element */
+declare function form_progress<ID extends string | undefined>(options?: FormNumberOptions<ID>): FormProgress<ID>;
+//#endregion
+//#region src/number/slider/slider.d.ts
+/**Slide Selector, displays all options in a slider*/
+declare class FormSlider<ID extends string | undefined> extends FormNumberWrite<ID, number> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  constructor(id?: ID);
+  set unit(unit: string | undefined);
+  set min(min: number | undefined);
+  set max(max: number | undefined);
+  set decimals(dec: number | undefined);
+  set step(step: number | undefined);
+  set start(step: number | undefined);
+  /**Set wether the slider is in live mode*/
+  set live(live: boolean | undefined);
+  set icon_decrease(icon: SVGFunc | undefined);
+  set icon_increase(icon: SVGFunc | undefined);
+  protected new_value(value: number): void;
+  protected clear_value(): void;
+  protected new_error(err: string): void;
+  protected clear_error(): void;
+  protected limit_value(val: number): PromiseLike<Result<number, string>>;
+  protected check_value(val: number): PromiseLike<Result<number, string>>;
+}
+/**Creates a dropdown form element */
+declare function form_slider<ID extends string | undefined>(options?: FormStepperBaseOptions<ID>): FormSlider<ID>;
+//#endregion
+//#region src/number/stepper/stepper.d.ts
+/**Slide Selector, displays all options in a slider*/
+declare class FormStepper<ID extends string | undefined> extends FormNumberWrite<ID, number> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  constructor(id?: ID);
+  set unit(unit: string | undefined);
+  set decimals(dec: number | undefined);
+  set min(min: number | undefined);
+  set max(max: number | undefined);
+  set step(step: number | undefined);
+  set start(step: number | undefined);
+  /**Set wether the slider is in live mode*/
+  set live(live: boolean | undefined);
+  set icon_decrease(icon: SVGFunc | undefined);
+  set icon_increase(icon: SVGFunc | undefined);
+  protected new_value(value: number): void;
+  protected clear_value(): void;
+  protected new_error(err: string): void;
+  protected clear_error(): void;
+  protected limit_value(val: number): PromiseLike<Result<number, string>>;
+  protected check_value(val: number): PromiseLike<Result<number, string>>;
+}
+/**Creates a dropdown form element */
+declare function form_stepper<ID extends string | undefined>(options?: FormStepperBaseOptions<ID>): FormStepper<ID>;
+//#endregion
+//#region src/selectors/selector_base.d.ts
+interface FormSelectorOption<RT> {
+  /**Value to set when option is selected */
+  value: RT;
+  /**Text for selection */
+  text: string;
+  /**Icon to display for option*/
+  icon?: SVGFunc;
+}
+interface FormSelectorBaseOptions<T, ID extends string | undefined> extends FormValueOptions<T, ID> {
+  /**Options for selector*/
+  selections?: FormSelectorOption<T>[];
+}
+/**Base for number elements elements*/
+declare abstract class FormSelectorBase<RT, ID extends string | undefined> extends FormValueWrite<RT, ID> {
+  /**Sets the selection options for the selector */
+  abstract set selections(selections: FormSelectorOption<RT>[] | undefined);
+  static apply_options<RT, ID extends string | undefined>(element: FormSelectorBase<RT, ID>, options: FormSelectorBaseOptions<RT, ID>): void;
+  protected state_related(related: Partial<StateEnumRelated>): void;
+}
+//#endregion
+//#region src/selectors/drop_down/drop_down.d.ts
+interface FormDropDownOptions<RT, ID extends string | undefined> extends FormSelectorBaseOptions<RT, ID> {
+  /**Default text displayed*/
+  default?: string;
+  /**Default icon displayed*/
+  default_icon?: SVGFunc;
+}
+/**Dropdown box for selecting between multiple choices in a small space*/
+declare class FormDropdown<RT, ID extends string | undefined> extends FormSelectorBase<RT, ID> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  private is_open;
+  constructor(id?: ID);
+  /**Gets the default text displayed when nothing has been selected yet */
+  get default(): string;
+  /**Sets the default text displayed when nothing has been selected yet */
+  set default(def: string);
+  /**Sets the default text displayed when nothing has been selected yet */
+  set default_icon(def: SVGFunc | undefined);
+  set selections(selections: FormSelectorOption<RT>[] | undefined);
+  set open(open: boolean);
+  /**Called when Value is changed */
+  protected new_value(value: RT): void;
+  protected clear_value(): void;
+  protected new_error(_val: string): void;
+  protected clear_error(): void;
+  warn(message: string): void;
+}
+/**Creates a dropdown form element */
+declare function form_dropdown<RT, ID extends string | undefined>(options?: FormDropDownOptions<RT, ID>): FormDropdown<RT, ID>;
+//#endregion
+//#region src/selectors/toggle_button/toggle_button.d.ts
+/**Toggle buttons, displays all options in a multi toggler*/
+declare class FormToggleButton<RT, ID extends string | undefined> extends FormSelectorBase<RT, ID> {
+  #private;
+  /**Returns the name used to define the element*/
+  static element_name(): string;
+  static element_name_space(): string;
+  set selections(selections: FormSelectorOption<RT>[] | undefined);
+  protected new_value(value: RT): void;
+  protected clear_value(): void;
+  protected new_error(_val: string): void;
+  protected clear_error(): void;
+}
+/**Creates a toggle button form element */
+declare function form_toggle_button<RT, ID extends string | undefined>(options?: FormSelectorBaseOptions<RT, ID>): FormToggleButton<RT, ID>;
+//#endregion
+//#region src/spacing/spacer.d.ts
+interface FormSpacerOptions {
+  /**Spacing amount  */
+  space?: number;
+}
+declare class FormSpacer extends FormElement {
+  static element_name(): string;
+  static element_name_space(): string;
+  constructor();
+  /**Sets the amount of space, in rem */
+  set space(space: number);
+  get space(): number;
+}
+/**Creates a spacer form element */
+declare function form_spacer(options?: FormSpacerOptions): FormSpacer;
+//#endregion
+//#region src/special/color/color_input.d.ts
+interface FormColorInputOptions<ID extends string | undefined, RT = string> extends FormValueOptions<RT, ID> {
+  /**Whether the color input should update live*/
+  live?: boolean;
+}
+declare class FormColorInput<ID extends string | undefined> extends FormValueWrite<string, ID> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  constructor(id?: ID);
+  set live(val: boolean);
+  get live(): boolean;
+  protected new_value(val: string): void;
+  protected clear_value(): void;
+  protected new_error(_val: string): void;
+  protected clear_error(): void;
+  protected state_related(_related: Option<{}>): void;
+}
+/**Creates a color input form element */
+declare function form_color_input<ID extends string | undefined>(options?: FormColorInputOptions<ID, string>): FormColorInput<ID>;
+//#endregion
+//#region src/special/date_time/date_time_input.d.ts
+interface DateTimeInputOptions<RT, ID extends string | undefined> extends FormValueOptions<RT, ID> {
+  /**Type of date time*/
+  type?: FormDateTimeType;
+}
+declare const FormDateTimeType: {
+  readonly DATE: "date";
+  readonly TIME: "time";
+  readonly DATETIME: "datetime";
+};
+type FormDateTimeType = (typeof FormDateTimeType)[keyof typeof FormDateTimeType];
+declare class FormDateTimeInput<RT extends Date | string | number, ID extends string | undefined> extends FormValueWrite<RT, ID> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  constructor(id?: ID);
+  /**Returns the date time type*/
+  get type(): FormDateTimeType;
+  /**Sets the date time type*/
+  set type(type: FormDateTimeType);
+  /**Returns the date time type*/
+  get step(): number;
+  /**Sets the date time type*/
+  set step(step: number);
+  protected new_value(value: RT): void;
+  protected clear_value(): void;
+  protected new_error(_val: string): void;
+  protected clear_error(): void;
+  protected state_related(_related: Option<{}>): void;
+}
+/**Creates a color input form element */
+declare function form_date_time_input<RT extends Date | string | number, ID extends string | undefined>(options?: DateTimeInputOptions<RT, ID>): FormDateTimeInput<RT, ID>;
+//#endregion
+//#region src/special/ip/ip_input.d.ts
+interface IpInputOptions<ID extends string | undefined> extends FormValueOptions<IPAddress, ID> {
+  /**Ip address type, this is overwritten if supplied with an ipaddress with a different type*/
+  type: IPVersion;
+}
+declare class FormIpInput<ID extends string | undefined> extends FormValueWrite<IPAddress, ID> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  constructor(type: IPVersion, id?: ID);
+  get value_as_ip(): IPAddress;
+  set type(val: IPVersion);
+  protected new_value(val: IPAddress): void;
+  protected clear_value(): void;
+  protected new_error(_val: string): void;
+  protected clear_error(): void;
+  protected state_related(_related: Option<{}>): void;
+}
+/**Creates a color input form element */
+declare function form_ip_input<ID extends string | undefined>(options: IpInputOptions<ID>): FormIpInput<ID>;
+//#endregion
+//#region src/special/password/password_input.d.ts
+interface FormPasswordInputOptions<ID extends string | undefined> extends FormValueOptions<string, ID> {
+  /**Allowed characters for the password input */
+  filter?: RegExp;
+}
+declare class FormPasswordInput<ID extends string | undefined> extends FormValueWrite<string, ID> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  constructor(id?: ID);
+  set filter(val: RegExp | undefined);
+  protected new_value(val: string): void;
+  protected clear_value(): void;
+  protected new_error(_val: string): void;
+  protected clear_error(): void;
+  protected state_related(_related: Option<{}>): void;
+}
+/**Creates a dropdown form element */
+declare function form_password_input<ID extends string | undefined>(options?: FormPasswordInputOptions<ID>): FormPasswordInput<ID>;
+//#endregion
+//#region src/text/input/text_input.d.ts
+interface FormTextInputOptions$1<ID extends string | undefined, RT = string> extends FormValueOptions<RT, ID> {
+  /**Placeholder text when input is empty */
+  placeholder?: string;
+  /**Maximum length of the input */
+  max_length?: number;
+  /**Maximum bytes of the input */
+  max_bytes?: number;
+  /**Allowed characters for the text input */
+  filter?: RegExp;
+}
+declare class FormTextInput<ID extends string | undefined> extends FormValueWrite<string, ID> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  constructor(id?: ID);
+  set filter(val: RegExp | undefined);
+  get filter(): RegExp | undefined;
+  set placeholder(val: string);
+  get placeholder(): string;
+  set max_length(val: number | undefined);
+  get max_length(): number | undefined;
+  set max_bytes(val: number | undefined);
+  get max_bytes(): number | undefined;
+  protected new_value(val: string): void;
+  protected clear_value(): void;
+  protected new_error(_val: string): void;
+  protected clear_error(): void;
+  protected limit_value(val: string): PromiseLike<Result<string, string>>;
+  protected check_value(val: string): PromiseLike<Result<string, string>>;
+  protected state_related(related: Partial<StateStringRelated>): void;
+}
+/**Creates a single line text input form element */
+declare function form_text_input<ID extends string | undefined>(options?: FormTextInputOptions$1<ID>): FormTextInput<ID>;
+//#endregion
+//#region src/text/multiLine/text_multi_line.d.ts
+interface FormTextInputOptions<ID extends string | undefined, RT = string> extends FormValueOptions<RT, ID> {
+  /**Placeholder text when input is empty */
+  placeholder?: string;
+  /**Maximum length of the input */
+  max_length?: number;
+  /**Maximum bytes of the input */
+  max_bytes?: number;
+  /**Allowed characters for the text input */
+  filter?: RegExp;
+}
+declare class FormTextMultiline<ID extends string | undefined> extends FormValueWrite<string, ID> {
+  #private;
+  static element_name(): string;
+  static element_name_space(): string;
+  constructor(id?: ID);
+  set filter(val: RegExp | undefined);
+  get filter(): RegExp | undefined;
+  set placeholder(val: string);
+  get placeholder(): string;
+  set max_length(val: number | undefined);
+  get max_length(): number | undefined;
+  set max_bytes(val: number | undefined);
+  get max_bytes(): number | undefined;
+  protected new_value(val: string): void;
+  protected clear_value(): void;
+  protected new_error(_val: string): void;
+  protected clear_error(): void;
+  protected limit_value(val: string): PromiseLike<Result<string, string>>;
+  protected check_value(val: string): PromiseLike<Result<string, string>>;
+  protected state_related(related: Partial<StateStringRelated>): void;
+}
+/**Creates a multi line text input form element */
+declare function form_text_multiline<ID extends string | undefined>(options?: FormTextInputOptions<ID>): FormTextMultiline<ID>;
+//#endregion
+//#region src/text/text/text.d.ts
+interface FormTextOptions {
+  /**Buttons text */
+  text?: string;
+  /**Text size */
+  size?: number;
+}
+/**Component for simple text */
+declare class FormText extends FormElement {
+  static element_name(): string;
+  static element_name_space(): string;
+  constructor(options: FormTextOptions);
+  /**Sets the current text of the element*/
+  set text(text: string);
+  get text(): string;
+  /**Sets the current text of the element*/
+  set size(size: number);
+}
+/**Creates a button form element */
+declare function form_text(options: FormTextOptions): FormText;
+//#endregion
+//#region src/index.d.ts
+/**Form elements with label */
+declare const form: {
+  FormColors: {
+    readonly None: "none";
+    readonly Black: "black";
+    readonly Green: "green";
+    readonly Red: "red";
+    readonly Blue: "blue";
+    readonly Yellow: "yellow";
+  };
+  button: typeof form_button;
+  switch: typeof form_switch;
+  lamp: {
+    <ID extends string | undefined>(options?: FormLampOptions<number, [FormColors, FormColors, FormColors, ...FormColors[]], ID>): FormLamp<number, [FormColors, FormColors, FormColors, ...FormColors[]], ID>;
+    <ID extends string | undefined>(options?: FormLampOptions<boolean, [FormColors, FormColors], ID>): FormLamp<boolean, [FormColors, FormColors], ID>;
+  };
+  group: typeof form_group;
+  color_input: typeof form_color_input;
+  date_time_input: typeof form_date_time_input;
+  FormDateTimeType: {
+    readonly DATE: "date";
+    readonly TIME: "time";
+    readonly DATETIME: "datetime";
+  };
+  ip_input: typeof form_ip_input;
+  password_input: typeof form_password_input;
+  progress: typeof form_progress;
+  input_number: typeof form_number_input;
+  slider: typeof form_slider;
+  stepper: typeof form_stepper;
+  dropdown: typeof form_dropdown;
+  toggle_button: typeof form_toggle_button;
+  spacer: typeof form_spacer;
+  text: typeof form_text;
+  input_text: typeof form_text_input;
+  multiline_text: typeof form_text_multiline;
+  list_field: typeof form_list_field;
+};
+//#endregion
+export { FormColors, FormDateTimeType, form as default, form };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.d.mts","names":["RESULT_KEY","OPTION_KEY","OptionBase","T2","U","E","T","OptionSome","Option","OptionNone","Result","some","none","value","expect","msg","unwrap","unwrap_or","and_then","mapper","or_else","map","compare","other","to_result","error","ResultOk","constructor","ResultErr","val","ResultBase","E2","F","ok","err","expect_err","unwrap_err","unwrap_err_or","map_err","to_option","func","valid","ResultInferOk","RT","ResultInferErr","RE","OptionInfer","OT","result","is_result","r","is_option","default","SVGAttributes","T","SVGElement","private","constructor","elem","stroke","s","fill","f","stroke_width","width","sw","class_list","class_name","cl","attribute","name","value","a","translate","x","y","rotate","angle","cx","cy","scale","sx","sy","skewX","skewY","transform","circle","SVGCircleElement","center_x","center_y","radius","circle_arc","SVGPathElement","start_angle","end_angle","ellipse","SVGEllipseElement","radius_x","radius_y","ellipse_arc","group","SVGGElement","line","SVGLineElement","start_x","start_y","end_x","end_y","path","rectangle_from_center","SVGRectElement","height","corner_radius","rectangle_from_corner","SVGElements","SVGTextElement","SVGSVGElement","SVGForeignObjectElement","rect","text","g","svg","foreignObject","create_svg_element","K","svg$1","viewbox","SVGAnchorPoint","bottomLeft","middleLeft","topLeft","topCenter","topRight","middleRight","bottomRight","bottomCenter","middleCenter","size","anchor","multi_line_text","isosceles_triangle","create","attr","angle_to_anchor_point","SVGFunc","array_from_range","T","start","end","i","init","array_from_range_inclusive","array_from_length","len","prepend","append","is_promise_like","PromiseLike","value","sleep","Promise","ms","arg","sleep_lazy","sync_resolve","sync_reject","error","debounce","Parameters","args","func","wait","leading","any_equals_deep","any1","any2","object_equals_deep","object1","object2","array_equals_deep","array1","array2","IPVersion","V4","V6","IPAddress","version","constructor","input","parse_v4_string","parse_v6_string","from_array","is_v4","is_v6","as_big_int","as_array","to_string","get_cursor_position","HTMLElement","element","set_cursor_position","offset","set_cursor_end","set_selection_all","throttle","node_clone","Node","node","Prettify","K","object_empty","obj","array_diff","main","second","added","removed","object_key_diff","T1","T2"],"sources":["../node_modules/@chocbite/ts-lib-result/dist/index.d.ts","../node_modules/@chocbite/ts-lib-svg/dist/index.d.mts","../src/base.ts","../src/boolean/lamp/lamp.ts","../src/boolean/button/button.ts","../src/boolean/switch/switch.ts","../node_modules/@chocbite/ts-lib-common/dist/index.d.ts","../src/group/group.ts","../src/list/list_field.ts","../src/number/number_base.ts","../src/number/numberInput/number_input.ts","../src/number/progress/progress.ts","../src/number/slider/slider.ts","../src/number/stepper/stepper.ts","../src/selectors/selector_base.ts","../src/selectors/drop_down/drop_down.ts","../src/selectors/toggle_button/toggle_button.ts","../src/spacing/spacer.ts","../src/special/color/color_input.ts","../src/special/date_time/date_time_input.ts","../src/special/ip/ip_input.ts","../src/special/password/password_input.ts","../src/text/input/text_input.ts","../src/text/multiLine/text_multi_line.ts","../src/text/text/text.ts","../src/index.ts"],"sourcesContent":["/**Symbol used to identify Result objects, can be used to create result compliant objects */\ndeclare const RESULT_KEY: unique symbol;\n/**Symbol used to identify Option objects, can be used to create option compliant objects */\ndeclare const OPTION_KEY: unique symbol;\ninterface OptionBase<T> {\n    /**Unique symbol to identify Option objects */\n    readonly [OPTION_KEY]: true;\n    /**Is true when a value is available*/\n    readonly some: boolean;\n    /**Is true when no value is available*/\n    readonly none: boolean;\n    /**The value*/\n    readonly value?: T;\n    /**Returns the contained value, if exists. Throws an error if not.\n     * @param msg the message to throw if no value exists.*/\n    expect(msg: string): T;\n    /**Returns the contained value, if exists. Throws an error if not.*/\n    unwrap(): T;\n    /**Returns the contained value or a provided default.\n     * @param value value to use as default*/\n    unwrap_or<T2>(value: T2): T | T2;\n    /**Calls mapper if the Option is `Some`, otherwise returns `None`.\n     * This function can be used for control flow based on `Optional` values.*/\n    and_then<T2>(mapper: (value: T) => OptionSome<T2>): Option<T2>;\n    and_then(mapper: (value: T) => OptionNone): Option<T>;\n    and_then<T2>(mapper: (value: T) => Option<T2>): Option<T2>;\n    /**Calls mapper if the Option is `None`, otherwise returns `Some`.\n     * This function can be used for control flow based on `Optional` values.*/\n    or_else<T2>(mapper: () => OptionSome<T2>): Option<T2>;\n    or_else(mapper: () => OptionNone): Option<T>;\n    or_else<T2>(mapper: () => Option<T2>): Option<T2>;\n    /**Maps an `Optional<T>` to `Optional<U>` by applying a function to a contained `Some` value, leaving a `None` value untouched.\n     * This function can be used to compose the Options of two functions.*/\n    map<U>(mapper: (value: T) => U): Option<U>;\n    /**Compares two `Optional<T>` values for equality.\n     * @returns true if equal, false otherwise. */\n    compare(other: Option<T>): boolean;\n    /**Maps an `Optional<T>` to a `Result<T, E>`.*/\n    to_result<E>(error: E): Result<T, E>;\n}\ndeclare class OptionSome<T> implements OptionBase<T> {\n    get [OPTION_KEY](): true;\n    readonly value: T;\n    constructor(value: T);\n    get some(): true;\n    get none(): false;\n    expect(): T;\n    unwrap(): T;\n    unwrap_or(): T;\n    and_then<T2>(mapper: (value: T) => OptionSome<T2>): OptionSome<T2>;\n    and_then(mapper: (value: T) => OptionNone): OptionNone;\n    and_then<T2>(mapper: (value: T) => Option<T2>): Option<T2>;\n    or_else(): OptionSome<T>;\n    map<U>(mapper: (value: T) => U): OptionSome<U>;\n    compare(other: Option<T>): boolean;\n    to_result(): ResultOk<T>;\n}\ndeclare class OptionNone implements OptionBase<never> {\n    get [OPTION_KEY](): true;\n    get some(): false;\n    get none(): true;\n    expect(msg: string): never;\n    unwrap(): never;\n    unwrap_or<T2>(val: T2): T2;\n    and_then(): OptionNone;\n    or_else<T2>(mapper: () => OptionSome<T2>): OptionSome<T2>;\n    or_else(mapper: () => OptionNone): OptionNone;\n    or_else<T2>(mapper: () => Option<T2>): Option<T2>;\n    map(): OptionNone;\n    compare(other: Option<never>): boolean;\n    to_result<E>(error: E): ResultErr<E>;\n}\ninterface ResultBase<T, E> {\n    /**Unique symbol to identify Result objects */\n    readonly [RESULT_KEY]: true;\n    /**Is true when the result is valid and false when it is invalid*/\n    readonly ok: boolean;\n    /**Is false when the result is valid and true when it is invalid*/\n    readonly err: boolean;\n    /**The value for the result, only exists when it is valid*/\n    readonly value?: T;\n    /**The error for the result, only exists when it is invalid*/\n    readonly error?: E;\n    /**Returns the contained valid value, if exists. Throws an error if not.\n     * @param msg the message to throw if the value is invalid.*/\n    expect(msg: string): T;\n    /**Returns the contained valid value, if does not exist. Throws an error if it does.\n     * @param msg the message to throw if the value is valid.*/\n    expect_err(msg: string): E;\n    /**Returns the contained valid value.\n     * Throws if the value is invalid, with a message provided by the error's value.*/\n    unwrap(): T;\n    /**Returns the contained valid value or a provided default.*/\n    unwrap_or<T2>(value: T2): T | T2;\n    /**Returns the contained error value.\n     * Throws if the value is valid, with the value.*/\n    unwrap_err(): E;\n    unwrap_err_or<E2>(error: E2): E | E2;\n    /**Calls mapper function if the result is valid, otherwise returns the error value of self.\n     * This function can be used for control flow based on `Result` values.*/\n    and_then<T2>(mapper: (value: T) => ResultOk<T2>): Result<T2, E>;\n    and_then<E2>(mapper: (value: T) => ResultErr<E2>): Result<T, E2>;\n    and_then<T2, E2>(mapper: (value: T) => Result<T2, E2>): Result<T2, E2>;\n    /**Calls mapper function if the result is an error, otherwise returns the value self.\n     * This function can be used for control flow based on `Result` values.*/\n    or_else<T2>(mapper: (error: E) => ResultOk<T2>): Result<T2, E>;\n    or_else<E2>(mapper: (error: E) => ResultErr<E2>): Result<T, E2>;\n    or_else<T2, E2>(mapper: (error: E) => Result<T2, E2>): Result<T2, E2>;\n    /**Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained valid value, leaving an error value untouched.\n     * This function can be used to compose the results of two functions.*/\n    map<U>(mapper: (value: T) => U): Result<U, E>;\n    /**Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained error value, leaving a valid value untouched.\n     * This function can be used to pass through a successful result while handling an error.*/\n    map_err<F>(mapper: (error: E) => F): Result<T, F>;\n    /**Compares two `Result<T, E>` values for equality.\n     * @returns true if equal, false otherwise. */\n    compare(other: Result<T, E>): boolean;\n    /**Converts from `Result<T, E>` to `Optional<T>`, discarding the error if any*/\n    to_option(): Option<T>;\n}\ndeclare class ResultOk<T> implements ResultBase<T, never> {\n    get [RESULT_KEY](): true;\n    readonly value: T;\n    constructor(value: T);\n    get ok(): true;\n    get err(): false;\n    expect(): T;\n    expect_err(msg: string): never;\n    unwrap(): T;\n    unwrap_or(): T;\n    unwrap_err(): never;\n    unwrap_err_or<E2>(error: E2): E2;\n    and_then<T2>(mapper: (value: T) => ResultOk<T2>): ResultOk<T2>;\n    and_then<E2>(mapper: (value: T) => ResultErr<E2>): ResultErr<E2>;\n    and_then<T2, E2>(mapper: (value: T) => Result<T2, E2>): Result<T2, E2>;\n    or_else(): ResultOk<T>;\n    map<U>(func: (value: T) => U): ResultOk<U>;\n    map_err(): ResultOk<T>;\n    compare(other: Result<T, any>): boolean;\n    to_option(): OptionSome<T>;\n}\ndeclare class ResultErr<E> implements ResultBase<never, E> {\n    get [RESULT_KEY](): true;\n    readonly error: E;\n    constructor(error: E);\n    get valid(): false;\n    get ok(): false;\n    get err(): true;\n    expect(msg: string): never;\n    expect_err(): E;\n    unwrap(): never;\n    unwrap_or<T2>(val: T2): T2;\n    unwrap_err(): E;\n    unwrap_err_or(): E;\n    and_then(): ResultErr<E>;\n    or_else<T2>(mapper: (error: E) => ResultOk<T2>): ResultOk<T2>;\n    or_else<E2>(mapper: (error: E) => ResultErr<E2>): ResultErr<E2>;\n    or_else<T2, E2>(mapper: (error: E) => Result<T2, E2>): Result<T2, E2>;\n    map(): ResultErr<E>;\n    map_err<F>(mapper: (error: E) => F): ResultErr<F>;\n    compare(other: Result<any, E>): boolean;\n    to_option(): OptionNone;\n}\ntype Result<T, E> = ResultOk<T> | ResultErr<E>;\ntype Option<T> = OptionSome<T> | OptionNone;\ntype ResultInferOk<T extends Result<any, string>> = T extends ResultOk<infer RT> ? RT : never;\ntype ResultInferErr<T extends Result<string, any>> = T extends ResultErr<infer RE> ? RE : never;\ntype OptionInfer<T extends Option<any>> = T extends OptionSome<infer OT> ? OT : never;\n/**Creates an ok result with the given value */\ndeclare function ok<T>(value: T): ResultOk<T>;\n/**Creates an error result with the given error */\ndeclare function err<E>(error: E): ResultErr<E>;\n/**Creates a some option with the given value */\ndeclare function some<T>(value: T): OptionSome<T>;\n/**Creates a none option */\ndeclare function none(): OptionNone;\ndeclare const result: {\n    ok: typeof ok;\n    err: typeof err;\n    some: typeof some;\n    none: typeof none;\n    RESULT_KEY: symbol;\n    OPTION_KEY: symbol;\n    is_result(r: any): r is Result<any, any>;\n    is_option(r: any): r is Option<any>;\n};\n\nexport { OPTION_KEY, type Option, type OptionInfer, OptionNone, OptionSome, RESULT_KEY, type Result, ResultErr, type ResultInferErr, type ResultInferOk, ResultOk, result as default, err, none, ok, result, some };\n","//#region src/attributes.d.ts\ndeclare class SVGAttributes<T extends SVGElement> {\n  #private;\n  constructor(elem: T);\n  /**Returns the svg element */\n  get elem(): T;\n  /** Sets the stroke color of the SVG element */\n  stroke(stroke: string): this;\n  /** Sets the stroke color of the SVG element */\n  s(stroke: string): this;\n  /** Sets the fill color of the SVG element */\n  fill(fill: string): this;\n  /** Sets the fill color of the SVG element */\n  f(fill: string): this;\n  /** Sets the stroke width of the SVG element */\n  stroke_width(width: number): this;\n  /** Sets the stroke width of the SVG element */\n  sw(width: number): this;\n  /** Adds one or more class names to the SVG element */\n  class_list(...class_name: string[]): this;\n  /** Adds one or more class names to the SVG element */\n  cl(...class_name: string[]): this;\n  /** Sets an arbitrary attribute on the SVG element */\n  attribute(name: string, value: string): this;\n  /** Sets an arbitrary attribute on the SVG element */\n  a(name: string, value: string): this;\n  /** Applies a translation transform to the SVG element */\n  translate(x: number, y: number): this;\n  /** Applies a rotation transform to the SVG element */\n  rotate(angle: number, cx?: number, cy?: number): this;\n  /** Applies a scaling transform to the SVG element */\n  scale(sx: number, sy?: number): this;\n  /** Applies a skewX transform to the SVG element */\n  skewX(angle: number): this;\n  /** Applies a skewY transform to the SVG element */\n  skewY(angle: number): this;\n  /** Applies a custom transform to the SVG element */\n  transform(transform: string): this;\n}\n//#endregion\n//#region src/primitives/circle.d.ts\n/**This creates a svg circle\n * @param center_x x coordinate of center\n * @param center_y y coordinate of center\n * @param radius radius of circle*/\ndeclare function circle(center_x: number, center_y: number, radius: number): SVGAttributes<SVGCircleElement>;\n/**This draws parts of a circle/ellipse, the circle direction is reversed\n * @param center_x the center point on the x axis\n * @param center_y the center point on the y axis\n * @param radius radius in x axis\n * @param start_angle start angle in radians\n * @param end_angle end anglein  radians*/\ndeclare function circle_arc(center_x: number, center_y: number, radius: number, start_angle: number, end_angle: number): SVGAttributes<SVGPathElement>;\n//#endregion\n//#region src/primitives/ellipse.d.ts\n/**This creates a svg ellipse\n * @param center_x x coordinate of center\n * @param center_y y coordinate of center\n * @param radius_x x radius of circle\n * @param radius_y y radius of circle*/\ndeclare function ellipse(center_x: number, center_y: number, radius_x: number, radius_y: number): SVGAttributes<SVGEllipseElement>;\n/**This draws parts of a circle/ellipse, the circle direction is reversed\n * @param center_x the center point on the x axis\n * @param center_y the center point on the y axis\n * @param radius_x radius in x axis\n * @param radius_y radius in y axis\n * @param start_angle start angle in radians\n * @param end_angle end anglein  radians*/\ndeclare function ellipse_arc(center_x: number, center_y: number, radius_x: number, radius_y: number, start_angle: number, end_angle: number): SVGAttributes<SVGPathElement>;\n//#endregion\n//#region src/primitives/group.d.ts\n/**This draws a triangle*/\ndeclare function group(): SVGAttributes<SVGGElement>;\n//#endregion\n//#region src/primitives/line.d.ts\n/**This creates a line element\n * @param start_x start point on x axis\n * @param start_y start point on y axis\n * @param end_x end point on x axis\n * @param end_y end point on y axis*/\ndeclare function line(start_x: number, start_y: number, end_x: number, end_y: number): SVGAttributes<SVGLineElement>;\n//#endregion\n//#region src/primitives/path.d.ts\n/**This creates a path element*/\ndeclare function path(path: string): SVGAttributes<SVGPathElement>;\n//#endregion\n//#region src/primitives/rectangle.d.ts\n/**This creates a rectangle with teh center as origin\n * @param center_x x coordinate of center\n * @param center_y y coordinate of center\n * @param width width\n * @param height height\n * @param corner_radius radius of corner*/\ndeclare function rectangle_from_center(center_x: number, center_y: number, width: number, height: number, corner_radius: number): SVGAttributes<SVGRectElement>;\n/**This creates a rectangle with teh center as origin\n * @param start_x x coordinate of center\n * @param start_y y coordinate of center\n * @param width width\n * @param height height\n * @param corner_radius radius of corner*/\ndeclare function rectangle_from_corner(start_x: number, start_y: number, width: number, height: number, corner_radius: number): SVGAttributes<SVGRectElement>;\n//#endregion\n//#region src/primitives/shared.d.ts\ntype SVGElements = {\n  ellipse: SVGEllipseElement;\n  circle: SVGCircleElement;\n  path: SVGPathElement;\n  line: SVGLineElement;\n  rect: SVGRectElement;\n  text: SVGTextElement;\n  g: SVGGElement;\n  svg: SVGSVGElement;\n  foreignObject: SVGForeignObjectElement;\n};\ndeclare function create_svg_element<K extends keyof SVGElements>(name: K): SVGAttributes<SVGElements[K]>;\n//#endregion\n//#region src/primitives/svg.d.ts\n/** This returns an empty svg element\n * @param  width width of svg\n * @param  height height of svg\n * @param  viewbox viewbox of svg*/\ndeclare function svg$1(width: number, height: number, viewbox?: string): SVGAttributes<SVGSVGElement>;\n//#endregion\n//#region src/util/anchorPoint.d.ts\ndeclare const SVGAnchorPoint: {\n  readonly bottomLeft: 0;\n  readonly middleLeft: 1;\n  readonly topLeft: 2;\n  readonly topCenter: 3;\n  readonly topRight: 4;\n  readonly middleRight: 5;\n  readonly bottomRight: 6;\n  readonly bottomCenter: 7;\n  readonly middleCenter: 8;\n};\ntype SVGAnchorPoint = (typeof SVGAnchorPoint)[keyof typeof SVGAnchorPoint];\n//#endregion\n//#region src/primitives/text.d.ts\n/**Creates a text nodes for an svg\n * @param x x coordinate of text\n * @param y y coordinate of text\n * @param text text\n * @param size size of text in px\n * @param anchor anchor point of text*/\ndeclare function text(x: number, y: number, text: string, size: number, anchor: SVGAnchorPoint): SVGAttributes<SVGTextElement>;\n/**Creates a text nodes for an svg\n * @param x x coordinate of text\n * @param y y coordinate of text\n * @param width width of text\n * @param height height of text\n * @param text text\n * @param size size of text in px\n * @param anchor anchor point of */\ndeclare function multi_line_text(x: number, y: number, width: number, height: number, text: string, size: number, anchor: SVGAnchorPoint): SVGAttributes<SVGForeignObjectElement>;\n//#endregion\n//#region src/primitives/triangle.d.ts\n/**This draws a triangle\n * @param center_x x coordinate of center\n * @param center_y y coordinate of center\n * @param width width\n * @param height height*/\ndeclare function isosceles_triangle(center_x: number, center_y: number, width: number, height: number): SVGAttributes<SVGPathElement>;\n//#endregion\n//#region src/index.d.ts\ndeclare const svg: {\n  create: typeof create_svg_element;\n  attr: (elem: SVGElement) => SVGAttributes<SVGElement>;\n  circle: typeof circle;\n  circle_arc: typeof circle_arc;\n  ellipse: typeof ellipse;\n  ellipse_arc: typeof ellipse_arc;\n  group: typeof group;\n  line: typeof line;\n  path: typeof path;\n  rectangle_from_center: typeof rectangle_from_center;\n  rectangle_from_corner: typeof rectangle_from_corner;\n  svg: typeof svg$1;\n  text: typeof text;\n  multi_line_text: typeof multi_line_text;\n  isosceles_triangle: typeof isosceles_triangle;\n  angle_to_anchor_point: (angle: number) => 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;\n};\ntype SVGFunc = () => SVGSVGElement;\n//#endregion\nexport { SVGAnchorPoint, SVGFunc, svg };\n//# sourceMappingURL=index.d.mts.map","/** Creates an array of a specified range, populating it via an initializer function.\n * * @param start - The starting index.\n * @param end - The ending index (exclusive).\n * @param init - A callback that returns a value of type T for each index i.\n * @returns An array of type T[] containing the initialized values.*/\ndeclare function array_from_range<T>(start: number, end: number, init: (i: number) => T): T[];\n/** Generates an array of type T from an inclusive range [start, end].\n * * @param start - The starting integer index.\n * @param end - The ending integer index (inclusive).\n * @param init - A factory function that produces an element of type T given the current index i.\n * @returns An array of length (end - start + 1), or an empty array if end < start.*/\ndeclare function array_from_range_inclusive<T>(start: number, end: number, init: (i: number) => T): T[];\n/**Creates an array of a specified length, populating each index\n * using a provided initialization function.\n * * @param len - The desired number of elements in the array.\n * @param init - A function that takes the current index (i) and returns a value of type T.\n * @returns An array of length 'len', or an empty array if 'len' is zero or negative. */\ndeclare function array_from_length<T>(len: number, init: (i: number) => T, prepend?: T[], append?: T[]): T[];\n\n/**Returns true if the given value is promise like */\ndeclare function is_promise_like<T>(value: any): value is PromiseLike<T>;\n/**Returns a promise that resolves after the given number of milliseconds with the given argument (if any).*/\ndeclare function sleep<T = void>(ms: number, arg?: T): Promise<T>;\n/**Returns a promise that resolves after the given number of milliseconds with the result of the given function (if any).*/\ndeclare function sleep_lazy<T = void>(ms: number, arg?: () => T): Promise<T>;\n/**Returns a promise that executes synchronously when using .then() and resolves immediately with the given value.*/\ndeclare function sync_resolve<T>(value: T | PromiseLike<T>): PromiseLike<T>;\n/**Returns a promise that executes synchronously when using .catch() and rejects immediately with the given value.*/\ndeclare function sync_reject<T>(error: T | PromiseLike<T>): PromiseLike<T>;\n\n/** Creates a debounced version of a function that delays execution until after\n * 'wait' milliseconds have elapsed since the last time it was invoked.\n * @template A - The type of the arguments array.\n * @template T - The type of the function to debounce.\n * @param func - The function to debounce.\n * @param wait - The delay in milliseconds, when 0 or unspecified it only removes calls to the function in the same cycle.\n * @param leading - If true, triggers the function on the leading edge of the timeout.\n * @returns  A new debounced function. */\ndeclare function debounce<T extends (...args: any[]) => any>(func: T, wait?: number, leading?: boolean): (...args: Parameters<T>) => void;\n\n/**This compares two values of any type, returns true if they are equal\n * For any object type it will deep compare, with the exception of objects which have an objectEquals method, which can provide a custom comparisson\n * Will return true for NaN equal to NaN*/\ndeclare function any_equals_deep(any1: any, any2: any): boolean;\n/**This deep compares two objects, returns true if they are equal\n * It compares all keys in the object, with the exception of objects which have an objectEquals method, which can provide a custom comparisson*/\ndeclare function object_equals_deep(object1: object, object2: object): boolean;\n/**This deep compares two arrays, returns true if they are equal\n * It compares all indexes in the array, with the exception of arrays which have an objectEquals method, which can provide a custom comparisson*/\ndeclare function array_equals_deep(array1: unknown[], array2: unknown[]): boolean;\n\n/**Event types for base*/\ndeclare const IPVersion: {\n    readonly V4: 4;\n    readonly V6: 6;\n};\ntype IPVersion = (typeof IPVersion)[keyof typeof IPVersion];\ndeclare class IPAddress {\n    private readonly value;\n    readonly version: IPVersion;\n    constructor(input: string | number | bigint | number[]);\n    private parse_v4_string;\n    private parse_v6_string;\n    private from_array;\n    get is_v4(): boolean;\n    get is_v6(): boolean;\n    get as_big_int(): bigint;\n    get as_array(): number[];\n    to_string(): string;\n}\n\n/*** Gets the current cursor position (offset) within the contenteditable element.\n * @param element The contenteditable HTML element.\n * @returns The offset number, or -1 if the element is not focused or no selection exists.*/\ndeclare function get_cursor_position(element: HTMLElement): number;\n/** Sets the cursor position (caret) inside the contenteditable element based on a character offset.\n * @param element The contenteditable HTML element.\n * @param offset The character offset from the beginning of the element's text content.*/\ndeclare function set_cursor_position(element: HTMLElement, offset: number): void;\n/**Sets the cursor (caret) position at the very end of the contenteditable element.\n * @param element The contenteditable HTML element.*/\ndeclare function set_cursor_end(element: HTMLElement): void;\n/** Selects all content (text and elements) within the contenteditable element.\n * @param element The contenteditable HTML element.*/\ndeclare function set_selection_all(element: HTMLElement): void;\n\n/** Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds.\n * * Features:\n * - Immediate execution on the first call.\n * - Leading-edge and trailing-edge execution (ensures the last call is not lost).\n * * @param func - The function to throttle.\n * @param wait - The number of milliseconds to throttle invocations to.\n * @returns A new throttled function.*/\ndeclare function throttle<T extends (...args: any[]) => any>(func: T, wait?: number): (...args: Parameters<T>) => void;\n\ndeclare function node_clone<T extends Node>(node: T): T;\ntype Prettify<T> = {\n    [K in keyof T]: T[K];\n} & {};\n/**Checks of the given object is empty only checks for objects own properties*/\ndeclare const object_empty: (obj: object) => boolean;\ndeclare function array_diff<T>(main: T[], second: T[]): {\n    added: T[];\n    removed: T[];\n};\ndeclare function object_key_diff<T1 extends object, T2 extends object>(main: T1, second: T2): {\n    added: string[];\n    removed: string[];\n};\n\nexport { IPAddress, IPVersion, type Prettify, any_equals_deep, array_diff, array_equals_deep, array_from_length, array_from_range, array_from_range_inclusive, debounce, get_cursor_position, is_promise_like, node_clone, object_empty, object_equals_deep, object_key_diff, set_cursor_end, set_cursor_position, set_selection_all, sleep, sleep_lazy, sync_reject, sync_resolve, throttle };\n"],"x_google_ignoreList":[0,1,6],"mappings":"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"}