@sanity/ui 4.0.0-static.9 → 5.0.0-alpha.1

package/src/props/zIndex.ts

@@ -0,0 +1,15 @@
+import type {PropDef} from '../types/PropDef'
+import type {Responsive} from '../types/Responsive'
+
+export type ZIndexProps = {
+  /** CSS z-index property */
+  zIndex?: Responsive<number>
+}
+
+export const zIndexProps: Record<string, PropDef> = {
+  zIndex: {
+    type: 'number',
+    className: 'z-index',
+    variable: '--z-index',
+  },
+}

package/src/styles.css.d.ts

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

package/src/styles.css.node.js

@@ -0,0 +1,2 @@
+// No-op shim for `styles.css` in runtimes that do not import `.css` file
+export default ''

package/src/styles.css.test.ts

@@ -0,0 +1,24 @@
+import {existsSync} from 'node:fs'
+import {createRequire} from 'node:module'
+import {dirname, join} from 'node:path'
+
+import {describe, expect, it} from 'vitest'
+
+const require = createRequire(import.meta.url)
+
+describe('@sanity/ui/styles.css', () => {
+  it('resolves to a Node-safe shim under the node condition', () => {
+    const path = require.resolve('@sanity/ui/styles.css')
+    expect(path).toMatch(/styles\.css\.node\.js$/)
+  })
+
+  it('imports without throwing in Node ESM', async () => {
+    const mod = await import('@sanity/ui/styles.css')
+    expect(mod.default).toBe('')
+  })
+
+  it('ships the real stylesheet for browser/style resolution', () => {
+    const pkgRoot = dirname(require.resolve('@sanity/ui/package.json'))
+    expect(existsSync(join(pkgRoot, 'dist/styles.css'))).toBe(true)
+  })
+})

package/src/types/Button.ts

@@ -0,0 +1,8 @@
+export const BUTTON_DENSITY = ['regular', 'loose'] as const
+export type ButtonDensity = (typeof BUTTON_DENSITY)[number]
+
+export const BUTTON_LEVEL = ['primary', 'secondary', 'tertiary'] as const
+export type ButtonLevel = (typeof BUTTON_LEVEL)[number]
+
+export const BUTTON_TONE = ['neutral', 'critical'] as const
+export type ButtonTone = (typeof BUTTON_TONE)[number]

package/src/types/Code.ts

@@ -0,0 +1,6 @@
+export const CODE_TAG = ['pre', 'span'] as const
+export type CodeTag = (typeof CODE_TAG)[number]
+
+export const CODE_SIZE = [0, 1, 2, 3, 4] as const
+/** @public */
+export type CodeSize = (typeof CODE_SIZE)[number]

package/src/types/Container.ts

@@ -0,0 +1,3 @@
+export const CONTAINER_SIZE = [0, 1, 2, 3, 4, 5] as const
+/** @public */
+export type ContainerSize = (typeof CONTAINER_SIZE)[number]

package/src/types/Density.ts

@@ -0,0 +1,3 @@
+export const DENSITY = ['compact', 'regular', 'loose'] as const
+/** @public */
+export type Density = (typeof DENSITY)[number]

package/src/types/Display.ts

@@ -0,0 +1,11 @@
+export const DISPLAY_BLOCK = ['block', 'inline-block', 'none'] as const
+/** @public */
+export type DisplayBlock = (typeof DISPLAY_BLOCK)[number]
+
+export const DISPLAY_FLEX = ['flex', 'inline-flex', 'none'] as const
+/** @public */
+export type DisplayFlex = (typeof DISPLAY_FLEX)[number]
+
+export const DISPLAY_GRID = ['grid', 'inline-grid', 'none'] as const
+/** @public */
+export type DisplayGrid = (typeof DISPLAY_GRID)[number]

package/src/types/Eyebrow.ts

@@ -0,0 +1,3 @@
+export const EYEBROW_SIZE = [0, 1, 2, 3, 4] as const
+/** @public */
+export type EyebrowSize = (typeof EYEBROW_SIZE)[number]

package/src/types/Flex.ts

@@ -0,0 +1,22 @@
+export const ALIGN_ITEMS = ['baseline', 'center', 'flex-end', 'flex-start', 'stretch'] as const
+/** @public */
+export type AlignItems = (typeof ALIGN_ITEMS)[number]
+
+export const JUSTIFY_CONTENT = [
+  'flex-start',
+  'flex-end',
+  'center',
+  'space-between',
+  'space-around',
+  'space-evenly',
+] as const
+/** @public */
+export type JustifyContent = (typeof JUSTIFY_CONTENT)[number]
+
+export const FLEX_DIRECTION = ['row', 'row-reverse', 'column', 'column-reverse'] as const
+/** @public */
+export type FlexDirection = (typeof FLEX_DIRECTION)[number]
+
+export const FLEX_WRAP = ['wrap', 'wrap-reverse', 'nowrap'] as const
+/** @public */
+export type FlexWrap = (typeof FLEX_WRAP)[number]

package/src/types/FontWeight.ts

@@ -0,0 +1,3 @@
+export const FONT_WEIGHT = ['regular', 'medium', 'semibold', 'bold'] as const
+/** @public */
+export type FontWeight = (typeof FONT_WEIGHT)[number]

package/src/types/Grid.ts

@@ -0,0 +1,3 @@
+export const GRID_AUTO_FLOW = ['row', 'column', 'row dense', 'column dense', 'dense'] as const
+/** @public */
+export type GridAutoFlow = (typeof GRID_AUTO_FLOW)[number]

package/src/types/Heading.ts

@@ -0,0 +1,6 @@
+export const HEADING_TAG = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] as const
+export type HeadingTag = (typeof HEADING_TAG)[number]
+
+export const HEADING_SIZE = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] as const
+/** @public */
+export type HeadingSize = (typeof HEADING_SIZE)[number]

package/src/types/Icon.ts

@@ -0,0 +1,3 @@
+export const ICON_SIZE = [0, 1, 2, 3, 4] as const
+/** @public */
+export type IconSize = (typeof ICON_SIZE)[number]

package/src/types/Interactive.ts

@@ -0,0 +1,8 @@
+export const INTERACTIVE_TAG = ['button', 'a'] as const
+export type InteractiveTag = (typeof INTERACTIVE_TAG)[number]
+
+export type InteractiveAs<T extends React.ElementType> = T extends InteractiveTag
+  ? T
+  : T extends string
+    ? never
+    : T

package/src/types/List.ts

@@ -0,0 +1,2 @@
+export const LIST_TAG = ['ol', 'ul'] as const
+export type ListTag = (typeof LIST_TAG)[number]

package/src/types/Overflow.ts

@@ -0,0 +1,3 @@
+export const OVERFLOW = ['visible', 'hidden', 'auto', 'scroll', 'clip'] as const
+/** @public */
+export type Overflow = (typeof OVERFLOW)[number]

package/src/types/Placement.ts

@@ -0,0 +1,16 @@
+export const PLACEMENT = [
+  'top',
+  'top-start',
+  'top-end',
+  'right',
+  'right-start',
+  'right-end',
+  'bottom',
+  'bottom-start',
+  'bottom-end',
+  'left',
+  'left-start',
+  'left-end',
+] as const
+/** @public */
+export type Placement = (typeof PLACEMENT)[number]

package/src/types/Position.ts

@@ -0,0 +1,3 @@
+export const POSITION = ['absolute', 'fixed', 'relative', 'static', 'sticky'] as const
+/** @public */
+export type Position = (typeof POSITION)[number]

package/src/types/PropDef.ts

@@ -0,0 +1,73 @@
+/**
+ * Prop is a boolean. If used for styling, provide a className
+ * to apply CSS and an inverseClassName to reset it.
+ */
+type BooleanPropDef = {
+  type: 'boolean'
+  className?: string
+  inverseClassName?: string
+}
+
+/**
+ * Prop is a number. If used for styling, provide a className
+ * that references the variable for dynamic values.
+ */
+type NumberPropDef = {
+  type: 'number'
+  className?: string
+  variable?: string
+}
+
+/**
+ * Prop is a string. If used for styling, provide a className
+ * that references the variable for dynamic values.
+ */
+type StringPropDef = {
+  type: 'string'
+  className?: string
+  variable?: string
+}
+
+/**
+ * Prop is a union of values. Values are always required. If
+ * used for styling, provide a className.
+ */
+type UnionPropDef<T> = {
+  type: 'union'
+  className?: string
+  values: readonly T[]
+}
+
+/**
+ * Prop is a composite of other props. Requires a union of values and
+ * a composition object which defines the props and their mappings.
+ * The values should map to the composition object's mapping keys.
+ */
+type CompositePropDef<T> = {
+  type: 'composite'
+  values: readonly T[]
+  composition: Record<
+    string,
+    {
+      propDef: PropDef
+      mapping: Record<T & PropertyKey, unknown>
+    }
+  >
+}
+
+/**
+ * Prop is a composite of other props. Requires a resolve callback with
+ * a value param that returns another prop def.
+ */
+type ConditionalPropDef<T> = {
+  type: 'conditional'
+  resolve: (value: T) => PropDef<T>
+}
+
+export type PropDef<T = unknown> =
+  | BooleanPropDef
+  | NumberPropDef
+  | StringPropDef
+  | UnionPropDef<T>
+  | CompositePropDef<T>
+  | ConditionalPropDef<T>

package/src/types/Radius.ts

@@ -0,0 +1,3 @@
+export const RADIUS = [0, 1, 2, 3, 4, 5, 6, 'full'] as const
+/** @public */
+export type Radius = (typeof RADIUS)[number]

package/src/types/Responsive.ts

@@ -0,0 +1,10 @@
+/** @public */
+export type Responsive<T> =
+  | T
+  | []
+  | ([T | undefined | null, ...(T | undefined | null)[]] & {length: 1})
+  | ([T | undefined | null, ...(T | undefined | null)[]] & {length: 2})
+  | ([T | undefined | null, ...(T | undefined | null)[]] & {length: 3})
+  | ([T | undefined | null, ...(T | undefined | null)[]] & {length: 4})
+  | ([T | undefined | null, ...(T | undefined | null)[]] & {length: 5})
+  | ([T | undefined | null, ...(T | undefined | null)[]] & {length: 6})

package/src/types/Shadow.ts

@@ -0,0 +1,3 @@
+export const SHADOW = [0, 1, 2, 3, 4, 5] as const
+/** @public */
+export type Shadow = (typeof SHADOW)[number]

package/src/types/Space.ts

@@ -0,0 +1,15 @@
+export const SPACE = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] as const
+/** @public */
+export type Space = (typeof SPACE)[number]
+
+export const SPACE_AUTO = [...SPACE, 'auto'] as const
+/** @public */
+export type SpaceAuto = (typeof SPACE_AUTO)[number]
+
+export const SPACE_INHERIT = [...SPACE, 'inherit'] as const
+/** @public */
+export type SpaceInherit = (typeof SPACE_INHERIT)[number]
+
+export const SPACE_AUTO_NEGATIVE = [-9, -8, -7, -6, -5, -4, -3, -2, -1, ...SPACE, 'auto'] as const
+/** @public */
+export type SpaceAutoNegative = (typeof SPACE_AUTO_NEGATIVE)[number]

package/src/types/Text.ts

@@ -0,0 +1,3 @@
+export const TEXT_SIZE = [0, 1, 2, 3, 4] as const
+/** @public */
+export type TextSize = (typeof TEXT_SIZE)[number]

package/src/types/TextAlign.ts

@@ -0,0 +1,3 @@
+export const TEXT_ALIGN = ['left', 'center', 'right', 'justify'] as const
+/** @public */
+export type TextAlign = (typeof TEXT_ALIGN)[number]

package/src/types/Tone.ts

@@ -0,0 +1,3 @@
+export const TONE = ['neutral', 'positive', 'suggest', 'caution', 'critical'] as const
+/** @public */
+export type Tone = (typeof TONE)[number]

package/src/utils/getProps.test.ts

@@ -0,0 +1,156 @@
+import {describe, expect, it} from 'vitest'
+
+import {cardProps} from '../components/card/card.props'
+import {layoutProps} from '../props/layout'
+import {typographyProps} from '../props/typography'
+import {getProps} from './getProps'
+
+describe('getProps', () => {
+  it('generates className based on an union', () => {
+    const result = getProps({padding: 1}, layoutProps)
+    expect(result.className).toBe('sui-p1')
+    expect(result.style).toEqual({})
+  })
+
+  it('does not generate className based on union if value is unsupported', () => {
+    const result = getProps({padding: 10}, layoutProps)
+    expect(result.className).toBe('')
+    expect(result.style).toEqual({})
+  })
+
+  it('merges existing className', () => {
+    const result = getProps({className: 'test', padding: 1}, layoutProps)
+    expect(result.className).toBe('test sui-p1')
+    expect(result.style).toEqual({})
+  })
+
+  it('generates className and style based on a string', () => {
+    const result = getProps({width: '100px'}, layoutProps)
+    expect(result.className).toBe('sui-width')
+    expect(result.style).toEqual({'--width': '100px'})
+  })
+
+  it('merges existing style', () => {
+    const result = getProps({width: '100px', style: {display: 'block'}}, layoutProps)
+    expect(result.className).toBe('sui-width')
+    expect(result.style).toEqual({'--width': '100px', 'display': 'block'})
+  })
+
+  it('generates className based on a boolean', () => {
+    const result = getProps({border: true}, layoutProps)
+    expect(result.className).toBe('sui-border')
+    expect(result.style).toEqual({})
+  })
+
+  it('generates className based on a number', () => {
+    const result = getProps({flexGrow: 1.5}, layoutProps)
+    expect(result.className).toBe('sui-flex-grow')
+    expect(result.style).toEqual({'--flex-grow': 1.5})
+  })
+
+  it('generates className based on a composite', () => {
+    const result = getProps({density: 'regular'}, cardProps)
+    expect(result.className).toBe('sui-gap3 sui-p4 sui-radius3')
+    expect(result.style).toEqual({})
+  })
+
+  it('generates multiple classNames', () => {
+    const result = getProps({border: true, padding: 1}, layoutProps)
+    expect(result.className).toBe('sui-border sui-p1')
+    expect(result.style).toEqual({})
+  })
+
+  it('preserves undefined props', () => {
+    const result = getProps({padding: 1, id: 'test'}, layoutProps)
+    expect(result.className).toBe('sui-p1')
+    expect(result['id']).toEqual('test')
+  })
+
+  it('preserves non-styling props', () => {
+    const result = getProps({padding: 1, as: 'div'}, layoutProps)
+    expect(result.className).toBe('sui-p1')
+    expect(result.style).toEqual({})
+    expect(result['as']).toEqual('div')
+  })
+
+  it('preserves non-styling responsive props', () => {
+    const result = getProps({padding: 1, items: [{label: 'One'}, {label: 'Two'}]}, layoutProps)
+    expect(result.className).toBe('sui-p1')
+    expect(result.style).toEqual({})
+    expect(result['items']).toEqual([{label: 'One'}, {label: 'Two'}])
+  })
+
+  it('generates responsive className based on unions', () => {
+    const result = getProps({padding: [1, 2, 3]}, layoutProps)
+    expect(result.className).toBe('sui-p1 sui-p2-bp-1 sui-p3-bp-2')
+    expect(result.style).toEqual({})
+  })
+
+  it('generates responsive className and style based on strings', () => {
+    const result = getProps({width: ['100px', '200px', '300px']}, layoutProps)
+    expect(result.className).toBe('sui-width sui-width-bp-1 sui-width-bp-2')
+    expect(result.style).toEqual({
+      '--width': '100px',
+      '--width-bp-1': '200px',
+      '--width-bp-2': '300px',
+    })
+  })
+
+  it('generates responsive className based on booleans', () => {
+    const result = getProps({border: [true, false, true]}, layoutProps)
+    expect(result.className).toBe('sui-border sui-border-none-bp-1 sui-border-bp-2')
+    expect(result.style).toEqual({})
+  })
+
+  it('generates responsive className based on composites', () => {
+    const result = getProps({density: ['compact', 'regular']}, cardProps)
+    expect(result.className).toBe(
+      'sui-gap2 sui-gap3-bp-1 sui-p3 sui-p4-bp-1 sui-radius2 sui-radius3-bp-1',
+    )
+    expect(result.style).toEqual({})
+  })
+
+  it('does not generate responsive className with more values than breakpoints', () => {
+    const result = getProps({padding: [1, 2, 3, 4, 5, 6, 7, 8]}, layoutProps)
+    expect(result.className).toBe(
+      'sui-p1 sui-p2-bp-1 sui-p3-bp-2 sui-p4-bp-3 sui-p5-bp-4 sui-p6-bp-5',
+    )
+    expect(result.style).toEqual({})
+  })
+
+  it('generates responsive className with undefined values', () => {
+    const result = getProps({padding: [1, 2, undefined, 3]}, layoutProps)
+    expect(result.className).toBe('sui-p1 sui-p2-bp-1 sui-p3-bp-3')
+    expect(result.style).toEqual({})
+  })
+
+  it('generates responsive className with null values', () => {
+    const result = getProps({padding: [1, 2, null, 3]}, layoutProps)
+    expect(result.className).toBe('sui-p1 sui-p2-bp-1 sui-p3-bp-3')
+    expect(result.style).toEqual({})
+  })
+
+  it('generates responsive className without unsupported values', () => {
+    const result = getProps({padding: [1, 2, 10, 3]}, layoutProps)
+    expect(result.className).toBe('sui-p1 sui-p2-bp-1 sui-p3-bp-3')
+    expect(result.style).toEqual({})
+  })
+
+  it('generates className based on a conditional', () => {
+    const result = getProps({truncate: 1}, typographyProps)
+    expect(result.className).toBe('sui-text-overflow')
+    expect(result.style).toEqual({})
+  })
+
+  it('generates className and style based on a conditional', () => {
+    const result = getProps({truncate: 3}, typographyProps)
+    expect(result.className).toBe('sui-line-clamp')
+    expect(result.style).toEqual({'--line-clamp': 3})
+  })
+
+  it('generates responsive className and style based on a conditional', () => {
+    const result = getProps({truncate: [1, 3]}, typographyProps)
+    expect(result.className).toBe('sui-text-overflow sui-line-clamp-bp-1')
+    expect(result.style).toEqual({'--line-clamp-bp-1': 3})
+  })
+})

package/src/utils/getProps.ts

@@ -0,0 +1,156 @@
+import clsx from 'clsx'
+
+import {type PropDef} from '../types/PropDef'
+
+const PREFIX = 'sui'
+const BREAKPOINTS_LENGTH = 6
+
+interface ComponentProps {
+  className?: string | undefined
+  style?: React.CSSProperties | undefined
+  [key: string]: any
+}
+
+export function getProps(
+  componentProps?: ComponentProps,
+  propDefs?: Record<string, PropDef>,
+): ComponentProps {
+  const {allComponentProps, allPropDefs} = flattenCompositeProps(componentProps, propDefs)
+  const restProps: ComponentProps = {}
+  let className = componentProps?.className || ''
+  let style = componentProps?.style || {}
+
+  for (const key in allComponentProps) {
+    const propDef = allPropDefs?.[key]
+    const propValue = allComponentProps[key]
+
+    if (
+      !((propDef && 'className' in propDef && propDef.className) || propDef?.type === 'conditional')
+    ) {
+      restProps[key] = propValue
+      continue
+    }
+
+    if (Array.isArray(propValue)) {
+      // @TODO: consider fixing this O(n^2) time complexity
+      // oxlint-disable-next-line no-accumulating-spread
+      for (let i = 0, len = Math.min(propValue.length, BREAKPOINTS_LENGTH); i < len; i++) {
+        const resolvedPropDef = getResolvedPropDef(propValue[i], propDef)
+
+        if (!resolvedPropDef) {
+          continue
+        }
+
+        className = clsx(className, getClassName(propValue[i], resolvedPropDef, i))
+        style = {...style, ...getStyle(propValue[i], resolvedPropDef, i)}
+      }
+    } else {
+      const resolvedPropDef = getResolvedPropDef(propValue, propDef)
+
+      if (!resolvedPropDef) {
+        restProps[key] = propValue
+        continue
+      }
+
+      className = clsx(className, getClassName(propValue, resolvedPropDef))
+      style = {...style, ...getStyle(propValue, resolvedPropDef)}
+    }
+  }
+
+  return {...restProps, className, style}
+}
+
+function getResolvedPropDef(propValue: any, propDef?: PropDef) {
+  if (propDef?.type !== 'conditional') {
+    return propDef
+  }
+
+  const resolvedPropDef = propDef.resolve(propValue)
+
+  if (!(resolvedPropDef && 'className' in resolvedPropDef && resolvedPropDef.className)) {
+    return null
+  }
+
+  return resolvedPropDef
+}
+
+function getClassName(propValue: any, propDef: PropDef, bp?: number) {
+  if (propDef.type === 'union' && propDef.values?.includes(propValue)) {
+    /* Note: This may need updating depending on the final CSS classname formatting */
+    return `${PREFIX}-${propDef.className}${typeof propValue === 'string' ? `-${propValue}` : propValue}${bp ? `-bp-${bp}` : ''}`
+  }
+
+  if (propDef.type === 'string' || propDef.type === 'number') {
+    return `${PREFIX}-${propDef.className}${bp ? `-bp-${bp}` : ''}`
+  }
+
+  if (propDef.type === 'boolean') {
+    if (propValue) {
+      return `${PREFIX}-${propDef.className}${bp ? `-bp-${bp}` : ''}`
+    }
+
+    if (!propValue && propDef.inverseClassName) {
+      return `${PREFIX}-${propDef.inverseClassName}${bp ? `-bp-${bp}` : ''}`
+    }
+  }
+
+  return ''
+}
+
+function getStyle(propValue: any, propDef: PropDef, bp?: number) {
+  if ((propDef.type === 'string' || propDef.type === 'number') && propDef.variable) {
+    return {
+      [`${propDef.variable}${bp ? `-bp-${bp}` : ''}`]: propValue,
+    }
+  }
+
+  return {}
+}
+
+export function flattenCompositeProps(
+  componentProps?: ComponentProps,
+  propDefs?: Record<string, PropDef>,
+) {
+  const props = {
+    allComponentProps: {} as ComponentProps,
+    allPropDefs: {} as Record<string, PropDef>,
+  }
+
+  for (const key in componentProps) {
+    if (propDefs?.[key] && propDefs?.[key].type === 'composite') {
+      for (const compositeKey in propDefs?.[key].composition) {
+        const compositeValue = getCompositeValue(componentProps[key], propDefs[key], compositeKey)
+
+        props.allComponentProps[compositeKey] = compositeValue
+        props.allPropDefs[compositeKey] = propDefs[key].composition[compositeKey]
+          ?.propDef as PropDef
+      }
+    } else {
+      props.allComponentProps[key] = componentProps[key]
+      props.allPropDefs[key] = propDefs?.[key] as PropDef
+    }
+  }
+
+  return props
+}
+
+function getCompositeValue(propValue: any, propDef: PropDef, key: string) {
+  if (!('composition' in propDef)) {
+    return
+  }
+
+  const mapping = propDef.composition[key]?.['mapping']
+  let compositeValue
+
+  if (Array.isArray(propValue)) {
+    compositeValue = []
+
+    for (let i = 0, len = propValue.length; i < len; i++) {
+      compositeValue[i] = mapping?.[propValue[i]]
+    }
+  } else {
+    compositeValue = mapping?.[propValue]
+  }
+
+  return compositeValue
+}

package/src/utils/suffixClassName.ts

@@ -0,0 +1,5 @@
+import {HASH} from '../version'
+
+export function suffixClassName(className: string) {
+  return `${className}-${HASH}`
+}

package/src/version.ts

@@ -0,0 +1,3 @@
+// This file is generated by scripts/write-version.js. Do not edit.
+export const VERSION = '500alpha1'
+export const HASH = '162541'

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Sanity.io
-
-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.