ripple 0.2.115 → 0.2.118

package/tests/client/url-search-params/url-search-params.retrieval.test.ripple

@@ -0,0 +1,160 @@
+import { flushSync, track, TrackedURLSearchParams } from 'ripple';
+
+describe('TrackedURLSearchParams > retrieval', () => {
+	it('handles get operation with reactivity', () => {
+		component URLTest() {
+			const params = new TrackedURLSearchParams('foo=bar&baz=qux');
+			let foo = track(() => params.get('foo'));
+			let baz = track(() => params.get('baz'));
+
+			<button onClick={() => params.set('foo', 'updated')}>{'update foo'}</button>
+			<pre>{@foo}</pre>
+			<pre>{@baz}</pre>
+		}
+
+		render(URLTest);
+
+		const button = container.querySelector('button');
+
+		// Initial state
+		expect(container.querySelectorAll('pre')[0].textContent).toBe('bar');
+		expect(container.querySelectorAll('pre')[1].textContent).toBe('qux');
+
+		// Test update
+		button.click();
+		flushSync();
+
+		expect(container.querySelectorAll('pre')[0].textContent).toBe('updated');
+		expect(container.querySelectorAll('pre')[1].textContent).toBe('qux');
+	});
+
+	it('handles get for nonexistent key', () => {
+		component URLTest() {
+			const params = new TrackedURLSearchParams('foo=bar');
+			let nonexistent = track(() => params.get('nonexistent'));
+
+			<pre>{String(@nonexistent)}</pre>
+		}
+
+		render(URLTest);
+
+		expect(container.querySelector('pre').textContent).toBe('null');
+	});
+
+	it('handles getAll operation with reactivity', () => {
+		component URLTest() {
+			const params = new TrackedURLSearchParams('foo=bar&foo=baz');
+			let allFoo = track(() => params.getAll('foo'));
+
+			<button onClick={() => params.append('foo', 'qux')}>{'append foo'}</button>
+			<pre>{JSON.stringify(@allFoo)}</pre>
+		}
+
+		render(URLTest);
+
+		const button = container.querySelector('button');
+
+		// Initial state
+		expect(container.querySelector('pre').textContent).toBe('["bar","baz"]');
+
+		// Test append
+		button.click();
+		flushSync();
+
+		expect(container.querySelector('pre').textContent).toBe('["bar","baz","qux"]');
+	});
+
+	it('handles has operation with reactivity', () => {
+		component URLTest() {
+			const params = new TrackedURLSearchParams('foo=bar');
+			let hasFoo = track(() => params.has('foo'));
+			let hasBaz = track(() => params.has('baz'));
+
+			<button onClick={() => params.append('baz', 'qux')}>{'add baz'}</button>
+			<button onClick={() => params.delete('foo')}>{'delete foo'}</button>
+			<pre>{@hasFoo.toString()}</pre>
+			<pre>{@hasBaz.toString()}</pre>
+		}
+
+		render(URLTest);
+
+		const addButton = container.querySelectorAll('button')[0];
+		const deleteButton = container.querySelectorAll('button')[1];
+
+		// Initial state
+		expect(container.querySelectorAll('pre')[0].textContent).toBe('true');
+		expect(container.querySelectorAll('pre')[1].textContent).toBe('false');
+
+		// Test add
+		addButton.click();
+		flushSync();
+
+		expect(container.querySelectorAll('pre')[0].textContent).toBe('true');
+		expect(container.querySelectorAll('pre')[1].textContent).toBe('true');
+
+		// Test delete
+		deleteButton.click();
+		flushSync();
+
+		expect(container.querySelectorAll('pre')[0].textContent).toBe('false');
+		expect(container.querySelectorAll('pre')[1].textContent).toBe('true');
+	});
+
+	it('handles has with specific value', () => {
+		component URLTest() {
+			const params = new TrackedURLSearchParams('foo=bar&foo=baz');
+			let hasBarValue = track(() => params.has('foo', 'bar'));
+			let hasQuxValue = track(() => params.has('foo', 'qux'));
+
+			<button onClick={() => params.append('foo', 'qux')}>{'add qux'}</button>
+			<pre>{@hasBarValue.toString()}</pre>
+			<pre>{@hasQuxValue.toString()}</pre>
+		}
+
+		render(URLTest);
+
+		const button = container.querySelector('button');
+
+		// Initial state
+		expect(container.querySelectorAll('pre')[0].textContent).toBe('true');
+		expect(container.querySelectorAll('pre')[1].textContent).toBe('false');
+
+		// Test add
+		button.click();
+		flushSync();
+
+		expect(container.querySelectorAll('pre')[0].textContent).toBe('true');
+		expect(container.querySelectorAll('pre')[1].textContent).toBe('true');
+	});
+
+	it('handles size property with reactivity', () => {
+		component URLTest() {
+			const params = new TrackedURLSearchParams('foo=bar');
+			let size = track(() => params.size);
+
+			<button onClick={() => params.append('baz', 'qux')}>{'add'}</button>
+			<button onClick={() => params.delete('foo')}>{'delete'}</button>
+			<pre>{@size}</pre>
+		}
+
+		render(URLTest);
+
+		const addButton = container.querySelectorAll('button')[0];
+		const deleteButton = container.querySelectorAll('button')[1];
+
+		// Initial state
+		expect(container.querySelector('pre').textContent).toBe('1');
+
+		// Test add
+		addButton.click();
+		flushSync();
+
+		expect(container.querySelector('pre').textContent).toBe('2');
+
+		// Test delete
+		deleteButton.click();
+		flushSync();
+
+		expect(container.querySelector('pre').textContent).toBe('1');
+	});
+});

package/tests/client/url-search-params/url-search-params.serialization.test.ripple

@@ -0,0 +1,53 @@
+import { flushSync, track, TrackedURLSearchParams } from 'ripple';
+
+describe('TrackedURLSearchParams > serialization', () => {
+	it('handles toString method with reactivity', () => {
+		component URLTest() {
+			const params = new TrackedURLSearchParams('foo=bar');
+			let string = track(() => params.toString());
+
+			<button onClick={() => params.append('baz', 'qux')}>{'add'}</button>
+			<pre>{@string}</pre>
+		}
+
+		render(URLTest);
+
+		const button = container.querySelector('button');
+
+		// Initial state
+		expect(container.querySelector('pre').textContent).toBe('foo=bar');
+
+		// Test add
+		button.click();
+		flushSync();
+
+		expect(container.querySelector('pre').textContent).toBe('foo=bar&baz=qux');
+	});
+
+	it('handles special characters encoding', () => {
+		component URLTest() {
+			const params = new TrackedURLSearchParams();
+
+			<button onClick={() => params.set('key', 'value with spaces')}>{'add spaces'}</button>
+			<button onClick={() => params.set('special', '!@#$%^&*()')}>{'add special'}</button>
+			<pre>{params.toString()}</pre>
+		}
+
+		render(URLTest);
+
+		const spacesButton = container.querySelectorAll('button')[0];
+		const specialButton = container.querySelectorAll('button')[1];
+
+		// Test spaces
+		spacesButton.click();
+		flushSync();
+
+		expect(container.querySelector('pre').textContent).toBe('key=value+with+spaces');
+
+		// Test special characters
+		specialButton.click();
+		flushSync();
+
+		expect(container.querySelector('pre').textContent).toContain('special');
+	});
+});

package/tests/client/url-search-params/url-search-params.tracked-url.test.ripple

@@ -0,0 +1,55 @@
+import { flushSync, TrackedURL } from 'ripple';
+
+describe('TrackedURLSearchParams > TrackedURL integration', () => {
+	it('integrates with TrackedURL', () => {
+		component URLTest() {
+			const url = new TrackedURL('https://example.com?foo=bar');
+			const params = url.searchParams;
+
+			<button onClick={() => params.append('baz', 'qux')}>{'add param'}</button>
+			<pre>{url.href}</pre>
+			<pre>{params.toString()}</pre>
+		}
+
+		render(URLTest);
+
+		const button = container.querySelector('button');
+
+		// Initial state
+		expect(container.querySelectorAll('pre')[0].textContent).toBe('https://example.com/?foo=bar');
+		expect(container.querySelectorAll('pre')[1].textContent).toBe('foo=bar');
+
+		// Test add param - should update URL
+		button.click();
+		flushSync();
+
+		expect(container.querySelectorAll('pre')[0].textContent).toBe('https://example.com/?foo=bar&baz=qux');
+		expect(container.querySelectorAll('pre')[1].textContent).toBe('foo=bar&baz=qux');
+	});
+
+	it('handles empty search string in URL', () => {
+		component URLTest() {
+			const url = new TrackedURL('https://example.com');
+			const params = url.searchParams;
+
+			<button onClick={() => params.append('foo', 'bar')}>{'add first param'}</button>
+			<pre>{url.href}</pre>
+			<pre>{params.size}</pre>
+		}
+
+		render(URLTest);
+
+		const button = container.querySelector('button');
+
+		// Initial state - no search params
+		expect(container.querySelectorAll('pre')[0].textContent).toBe('https://example.com/');
+		expect(container.querySelectorAll('pre')[1].textContent).toBe('0');
+
+		// Test add first param
+		button.click();
+		flushSync();
+
+		expect(container.querySelectorAll('pre')[0].textContent).toBe('https://example.com/?foo=bar');
+		expect(container.querySelectorAll('pre')[1].textContent).toBe('1');
+	});
+});

package/tests/client.d.ts

@@ -0,0 +1,12 @@
+declare var container: HTMLDivElement;
+declare var error: string | undefined;
+declare function render(component: () => void): void;
+
+interface HTMLElement {
+	// We don't care about checking if it returned an element or null in tests
+	// because if it returned null, those tests will fail anyway. This
+	// typing drastically simplifies testing: you don't have to check if the
+	// query returned null or an actual element, and you don't have to do
+	// optional chaining everywhere (elem?.textContent)
+	querySelector(selectors: string): HTMLElement;
+}

package/tests/server/if.test.ripple

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import { render } from 'ripple/server';
+
+describe('if statements in SSR', () => {
+	it('renders if block when condition is true', async () => {
+		component App() {
+			let condition = true;
+
+			if (condition) {
+				<div>{'If block'}</div>
+			}
+		}
+
+		const { body } = await render(App);
+		expect(body).toBe('<div>If block</div>');
+	});
+
+	it('renders else block when condition is false', async () => {
+		component App() {
+			let condition = false;
+
+			if (condition) {
+				<div>{'If block'}</div>
+			} else {
+				<div>{'Else block'}</div>
+			}
+		}
+
+		const { body } = await render(App);
+		expect(body).toBe('<div>Else block</div>');
+	});
+
+	it('renders else if block when condition is true', async () => {
+		component App() {
+			let value = 'b';
+
+			if (value === 'a') {
+				<div>{'Case A'}</div>
+			} else if (value === 'b') {
+				<div>{'Case B'}</div>
+			} else {
+				<div>{'Default Case'}</div>
+			}
+		}
+
+		const { body } = await render(App);
+		expect(body).toBe('<div>Case B</div>');
+	});
+
+	it('renders final else block in an if-else if-else chain', async () => {
+		component App() {
+			let value = 'c';
+
+			if (value === 'a') {
+				<div>{'Case A'}</div>
+			} else if (value === 'b') {
+				<div>{'Case B'}</div>
+			} else {
+				<div>{'Default Case'}</div>
+			}
+		}
+
+		const { body } = await render(App);
+		expect(body).toBe('<div>Default Case</div>');
+	});
+});

package/tests/setup-client.js

@@ -0,0 +1,28 @@
+import { beforeEach, afterEach } from 'vitest';
+import { mount } from 'ripple';
+
+/**
+ * @param {() => void} component 
+ */
+globalThis.render = function render(component) {
+	mount(component, {
+		target: /** @type {HTMLDivElement} */ (globalThis.container)
+	});
+}
+
+beforeEach(() => {
+	globalThis.container = /** @type {HTMLDivElement} */ (document.createElement('div'));
+	document.body.appendChild(globalThis.container);
+
+	globalThis.error = undefined;
+});
+
+afterEach(() => {
+	// Container is guaranteed to exist in all tests, so it was easier to type it without undefined.
+	// And when we unset it, we just type-cast it to HTMLDivElement to avoid TS errors, because we
+	// know it's guaranteed to exist in the next test again.
+	document.body.removeChild(/** @type {HTMLDivElement} */ (globalThis.container));
+	globalThis.container = /** @type {HTMLDivElement} */ (/** @type {unknown} */(undefined));
+
+	globalThis.error = undefined;
+});

package/tsconfig.json

@@ -10,7 +10,7 @@
 		"noErrorTruncation": true,
 		"allowSyntheticDefaultImports": true,
 		"verbatimModuleSyntax": true,
-		"types": ["node"],
+		"types": ["node", "vitest/globals"],
 		"jsx": "preserve",
 		"jsxImportSource": "ripple",
 		"strict": true,
@@ -23,6 +23,8 @@
 	"include": [
 		"./*.js",
 		"./src/",
-		"./tests/*/test.ripple",
+		"./tests/**/*.test.ripple",
+		"./tests/**/*.d.ts",
+		"./tests/**/*.js"
 	]
 }

package/types/index.d.ts

@@ -9,18 +9,18 @@ export declare function tick(): Promise<void>;
 
 export declare function untrack<T>(fn: () => T): T;
 
-export declare function flushSync<T>(fn: () => T): T;
+export declare function flushSync<T>(fn?: () => T): T;
 
 export declare function effect(fn: (() => void) | (() => () => void)): void;
 
 export interface TrackedArrayConstructor {
-	new <T>(...elements: T[]): TrackedArray<T>;   // must be used with `new`
+	new <T>(...elements: T[]): TrackedArray<T>; // must be used with `new`
 	from<T>(arrayLike: ArrayLike<T>): TrackedArray<T>;
 	of<T>(...items: T[]): TrackedArray<T>;
 	fromAsync<T>(iterable: AsyncIterable<T>): Promise<TrackedArray<T>>;
 }
 
-export interface TrackedArray<T> extends Array<T> { }
+export interface TrackedArray<T> extends Array<T> {}
 
 export declare const TrackedArray: TrackedArrayConstructor;
 
@@ -74,7 +74,9 @@ declare global {
 export declare function createRefKey(): symbol;
 
 // Base Tracked interface - all tracked values have a '#v' property containing the actual value
-export interface Tracked<V> {	'#v': V; }
+export interface Tracked<V> {
+	'#v': V;
+}
 
 // Augment Tracked to be callable when V is a Component
 // This allows <@Something /> to work in JSX when Something is Tracked<Component>
@@ -84,32 +86,41 @@ export interface Tracked<V> {
 
 // Helper type to infer component type from a function that returns a component
 // If T is a function returning a Component, extract the Component type itself, not the return type (void)
-export type InferComponent<T> =
-	T extends () => infer R
-		? R extends Component<any>
-			? R
-			: T
-		: T;
+export type InferComponent<T> = T extends () => infer R ? (R extends Component<any> ? R : T) : T;
 
 export type Props<K extends PropertyKey = any, V = unknown> = Record<K, V>;
 export type PropsWithExtras<T extends object> = Props & T & Record<string, unknown>;
-export type PropsWithChildren<T extends object = {}> =
-	Expand<Omit<Props, 'children'> & { children: Component } & T>;
+export type PropsWithChildren<T extends object = {}> = Expand<
+	Omit<Props, 'children'> & { children: Component } & T
+>;
 
 type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
 
-type PickKeys<T, K extends readonly (keyof T)[]> =
-	{ [I in keyof K]: Tracked<T[K[I] & keyof T]> };
+type PickKeys<T, K extends readonly (keyof T)[]> = { [I in keyof K]: Tracked<T[K[I] & keyof T]> };
 
 type RestKeys<T, K extends readonly (keyof T)[]> = Expand<Omit<T, K[number]>>;
 
-type SplitResult<T extends Props, K extends readonly (keyof T)[]> =
-	[...PickKeys<T, K>, Tracked<RestKeys<T, K>>];
+type SplitResult<T extends Props, K extends readonly (keyof T)[]> = [
+	...PickKeys<T, K>,
+	Tracked<RestKeys<T, K>>,
+];
+
+export declare function get<V>(tracked: Tracked<V>): V;
+
+export declare function set<V>(tracked: Tracked<V>, value: V): void;
 
 // Overload for function values - infers the return type of the function
-export declare function track<V>(value: () => V, get?: (v: InferComponent<V>) => InferComponent<V>, set?: (next: InferComponent<V>, prev: InferComponent<V>) => InferComponent<V>): Tracked<InferComponent<V>>;
+export declare function track<V>(
+	value: () => V,
+	get?: (v: InferComponent<V>) => InferComponent<V>,
+	set?: (next: InferComponent<V>, prev: InferComponent<V>) => InferComponent<V>,
+): Tracked<InferComponent<V>>;
 // Overload for non-function values
-export declare function track<V>(value?: V, get?: (v: V) => V, set?: (next: V, prev: V) => V): Tracked<V>;
+export declare function track<V>(
+	value?: V,
+	get?: (v: V) => V,
+	set?: (next: V, prev: V) => V,
+): Tracked<V>;
 
 export declare function trackSplit<V extends Props, const K extends readonly (keyof V)[]>(
 	value: V,
@@ -120,60 +131,67 @@ export function on<Type extends keyof WindowEventMap>(
 	window: Window,
 	type: Type,
 	handler: (this: Window, event: WindowEventMap[Type]) => any,
-	options?: AddEventListenerOptions | undefined
+	options?: AddEventListenerOptions | undefined,
 ): () => void;
 
 export function on<Type extends keyof DocumentEventMap>(
 	document: Document,
 	type: Type,
 	handler: (this: Document, event: DocumentEventMap[Type]) => any,
-	options?: AddEventListenerOptions | undefined
+	options?: AddEventListenerOptions | undefined,
 ): () => void;
 
 export function on<Element extends HTMLElement, Type extends keyof HTMLElementEventMap>(
 	element: Element,
 	type: Type,
 	handler: (this: Element, event: HTMLElementEventMap[Type]) => any,
-	options?: AddEventListenerOptions | undefined
+	options?: AddEventListenerOptions | undefined,
 ): () => void;
 
 export function on<Element extends MediaQueryList, Type extends keyof MediaQueryListEventMap>(
 	element: Element,
 	type: Type,
 	handler: (this: Element, event: MediaQueryListEventMap[Type]) => any,
-	options?: AddEventListenerOptions | undefined
+	options?: AddEventListenerOptions | undefined,
 ): () => void;
 
 export function on(
 	element: EventTarget,
 	type: string,
 	handler: EventListener,
-	options?: AddEventListenerOptions | undefined
+	options?: AddEventListenerOptions | undefined,
 ): () => void;
 
 export type TrackedObjectShallow<T> = {
 	[K in keyof T]: T[K] | Tracked<T[K]>;
 };
 
-export type TrackedObjectDeep<T> =
-	T extends string | number | boolean | null | undefined | symbol | bigint
+export type TrackedObjectDeep<T> = T extends
+	| string
+	| number
+	| boolean
+	| null
+	| undefined
+	| symbol
+	| bigint
 	? T | Tracked<T>
 	: T extends TrackedArray<infer U>
-	? TrackedArray<U> | Tracked<TrackedArray<U>>
-	: T extends TrackedSet<infer U>
-	? TrackedSet<U> | Tracked<TrackedSet<U>>
-	: T extends TrackedMap<infer K, infer V>
-	? TrackedMap<K, V> | Tracked<TrackedMap<K, V>>
-	: T extends Array<infer U>
-	? Array<TrackedObjectDeep<U>> | Tracked<Array<TrackedObjectDeep<U>>>
-	: T extends Set<infer U>
-	? Set<TrackedObjectDeep<U>> | Tracked<Set<TrackedObjectDeep<U>>>
-	: T extends Map<infer K, infer V>
-	? Map<TrackedObjectDeep<K>, TrackedObjectDeep<V>> |
-	Tracked<Map<TrackedObjectDeep<K>, TrackedObjectDeep<V>>>
-	: T extends object
-	? { [K in keyof T]: TrackedObjectDeep<T[K]> | Tracked<TrackedObjectDeep<T[K]>> }
-	: T | Tracked<T>;
+		? TrackedArray<U> | Tracked<TrackedArray<U>>
+		: T extends TrackedSet<infer U>
+			? TrackedSet<U> | Tracked<TrackedSet<U>>
+			: T extends TrackedMap<infer K, infer V>
+				? TrackedMap<K, V> | Tracked<TrackedMap<K, V>>
+				: T extends Array<infer U>
+					? Array<TrackedObjectDeep<U>> | Tracked<Array<TrackedObjectDeep<U>>>
+					: T extends Set<infer U>
+						? Set<TrackedObjectDeep<U>> | Tracked<Set<TrackedObjectDeep<U>>>
+						: T extends Map<infer K, infer V>
+							?
+									| Map<TrackedObjectDeep<K>, TrackedObjectDeep<V>>
+									| Tracked<Map<TrackedObjectDeep<K>, TrackedObjectDeep<V>>>
+							: T extends object
+								? { [K in keyof T]: TrackedObjectDeep<T[K]> | Tracked<TrackedObjectDeep<T[K]>> }
+								: T | Tracked<T>;
 
 export type TrackedObject<T extends object> = T & {};
 
@@ -203,31 +221,59 @@ export class TrackedURL extends URL {
 export function createSubscriber(start: () => void | (() => void)): () => void;
 
 interface ReactiveValue<V> extends Tracked<V> {
-	new(fn: () => Tracked<V>, start: () => void | (() => void)): Tracked<V>;
+	new (fn: () => Tracked<V>, start: () => void | (() => void)): Tracked<V>;
 	/** @private */
 	_brand: void;
 }
 
 export interface MediaQuery extends Tracked<boolean> {
-	new(query: string, fallback?: boolean | undefined): Tracked<boolean>;
+	new (query: string, fallback?: boolean | undefined): Tracked<boolean>;
 	/** @private */
 	_brand: void;
 }
 
 export declare const MediaQuery: {
-	new(query: string, fallback?: boolean | undefined): Tracked<boolean>;
+	new (query: string, fallback?: boolean | undefined): Tracked<boolean>;
 };
 
-export function Portal<V = HTMLElement>({ target, children: Component }: { target: V, children?: Component }): void;
+export function Portal<V = HTMLElement>({
+	target,
+	children: Component,
+}: {
+	target: V;
+	children?: Component;
+}): void;
 
 /**
  * @param {Tracked<V>} tracked
  * @returns {(node: HTMLInputElement | HTMLSelectElement) => void}
  */
-export declare function bindValue<V>(tracked: Tracked<V>): (node: HTMLInputElement | HTMLSelectElement) => void;
+export declare function bindValue<V>(
+	tracked: Tracked<V>,
+): (node: HTMLInputElement | HTMLSelectElement) => void;
 
 /**
  * @param {Tracked<V>} tracked
  * @returns {(node: HTMLInputElement) => void}
  */
-export declare function bindChecked<V>(tracked: Tracked<V>): (node: HTMLInputElement) => void;
+export declare function bindChecked<V>(tracked: Tracked<V>): (node: HTMLInputElement) => void;
+
+export declare function bindClientWidth<V>(tracked: Tracked<V>): (node: HTMLElement) => void;
+
+export declare function bindClientHeight<V>(tracked: Tracked<V>): (node: HTMLElement) => void;
+
+export declare function bindContentRect<V>(tracked: Tracked<V>): (node: HTMLElement) => void;
+
+export declare function bindContentBoxSize<V>(tracked: Tracked<V>): (node: HTMLElement) => void;
+
+export declare function bindBorderBoxSize<V>(tracked: Tracked<V>): (node: HTMLElement) => void;
+
+export declare function bindDevicePixelContentBoxSize<V>(
+	tracked: Tracked<V>,
+): (node: HTMLElement) => void;
+
+export declare function bindInnerHTML<V>(tracked: Tracked<V>): (node: HTMLElement) => void;
+
+export declare function bindInnerText<V>(tracked: Tracked<V>): (node: HTMLElement) => void;
+
+export declare function bindTextContent<V>(tracked: Tracked<V>): (node: HTMLElement) => void;

package/LICENSE

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