@hina-ui/vue 1.7.6 → 1.7.7

package/src/primitives/stepper/StepperParts.ts

@@ -0,0 +1,103 @@
+import {
+  createTextVNode,
+  defineComponent,
+  guardReactiveProps,
+  h,
+  mergeProps,
+  normalizeProps,
+  renderSlot,
+  toDisplayString,
+  withCtx,
+  type PropType,
+} from 'vue'
+import type { Orientation } from '../../../../shared/src/primitives/roving-focus'
+import { Primitive, type PrimitiveProps } from '../primitive'
+import { Separator } from '../separator'
+import { useForwardExpose } from '../utils/useForwardExpose'
+import { injectStepperItemContext, injectStepperRootContext } from './context'
+
+export interface StepperPartProps {
+  asChild?: boolean
+  as?: PrimitiveProps['as']
+}
+
+function asProp(fallback: string) {
+  return {
+    type: null as unknown as PropType<PrimitiveProps['as']>,
+    required: false,
+    default: fallback,
+  } as const
+}
+
+export const StepperIndicator = defineComponent({
+  name: 'StepperIndicator',
+  props: { asChild: { type: Boolean, required: false }, as: asProp('span') },
+  setup(props, { slots }) {
+    const itemContext = injectStepperItemContext()
+    useForwardExpose()
+    return () =>
+      h(Primitive, normalizeProps(guardReactiveProps(props)), {
+        default: withCtx(() => [
+          renderSlot(slots, 'default', { step: itemContext.step.value }, () => [
+            createTextVNode(' Step ' + toDisplayString(itemContext.step.value), 1),
+          ]),
+        ]),
+      })
+  },
+})
+
+export const StepperTitle = defineComponent({
+  name: 'StepperTitle',
+  props: { asChild: { type: Boolean, required: false }, as: asProp('h4') },
+  setup(props, { slots }) {
+    const itemContext = injectStepperItemContext()
+    useForwardExpose()
+    return () =>
+      h(Primitive, mergeProps(props, { id: itemContext.titleId }), {
+        default: withCtx(() => [renderSlot(slots, 'default')]),
+      })
+  },
+})
+
+export const StepperDescription = defineComponent({
+  name: 'StepperDescription',
+  props: { asChild: { type: Boolean, required: false }, as: asProp('p') },
+  setup(props, { slots }) {
+    useForwardExpose()
+    const itemContext = injectStepperItemContext()
+    return () =>
+      h(Primitive, mergeProps(props, { id: itemContext.descriptionId }), {
+        default: withCtx(() => [renderSlot(slots, 'default')]),
+      })
+  },
+})
+
+export interface StepperSeparatorProps extends StepperPartProps {
+  orientation?: Orientation
+  decorative?: boolean
+}
+
+export const StepperSeparator = defineComponent({
+  name: 'StepperSeparator',
+  props: {
+    orientation: { type: String as PropType<Orientation>, required: false },
+    decorative: { type: Boolean, required: false },
+    asChild: { type: Boolean, required: false },
+    as: { type: null as unknown as PropType<PrimitiveProps['as']>, required: false },
+  },
+  setup(props, { slots }) {
+    const rootContext = injectStepperRootContext()
+    const itemContext = injectStepperItemContext()
+    useForwardExpose()
+    return () =>
+      h(
+        Separator,
+        mergeProps(props, {
+          decorative: '',
+          orientation: rootContext.orientation.value,
+          'data-state': itemContext.state.value,
+        }),
+        { default: withCtx(() => [renderSlot(slots, 'default')]) },
+      )
+  },
+})

package/src/primitives/stepper/StepperRoot.ts

@@ -0,0 +1,171 @@
+import {
+  computed,
+  defineComponent,
+  h,
+  nextTick,
+  ref,
+  renderSlot,
+  toRefs,
+  watch,
+  withCtx,
+  type PropType,
+} from 'vue'
+import type { Orientation } from '../../../../shared/src/primitives/roving-focus'
+import {
+  adjacentStepperItems,
+  canGoToStep,
+  STEPPER_STATUS_STYLE,
+  stepperStatusText,
+} from '../../../../shared/src/primitives/stepper'
+import { Primitive, type PrimitiveProps } from '../primitive'
+import { useDirection, type Direction } from '../utils/useDirection'
+import { useForwardExpose } from '../utils/useForwardExpose'
+import { useVModel } from '../utils/useVModel'
+import { provideStepperRootContext } from './context'
+
+export interface StepperRootProps {
+  defaultValue?: number
+  orientation?: Orientation
+  dir?: Direction
+  modelValue?: number
+  linear?: boolean
+  asChild?: boolean
+  as?: PrimitiveProps['as']
+}
+
+export type StepperRootEmits = {
+  'update:modelValue': [value: number | undefined]
+}
+
+const STATUS_PROPS = {
+  'aria-live': 'polite',
+  'aria-atomic': 'true',
+  role: 'status',
+  style: STEPPER_STATUS_STYLE,
+}
+
+export const StepperRoot = defineComponent({
+  name: 'StepperRoot',
+  props: {
+    defaultValue: { type: Number, required: false, default: 1 },
+    orientation: { type: String as PropType<Orientation>, required: false, default: 'horizontal' },
+    dir: { type: String as PropType<Direction>, required: false },
+    modelValue: { type: Number, required: false },
+    linear: { type: Boolean, required: false, default: true },
+    asChild: { type: Boolean, required: false },
+    as: { type: null as unknown as PropType<PrimitiveProps['as']>, required: false },
+  },
+  emits: ['update:modelValue'],
+  setup(props, { emit, expose, slots }) {
+    const { dir: propDir, orientation: propOrientation, linear } = toRefs(props)
+    const dir = useDirection(propDir)
+    const totalStepperItems = ref(new Set<HTMLElement>())
+    const modelValue = useVModel(props, 'modelValue', emit, {
+      defaultValue: props.defaultValue,
+      passive: props.modelValue === undefined,
+    })
+    const totalStepperItemsArray = computed(() => Array.from(totalStepperItems.value))
+    const isFirstStep = computed(() => modelValue.value === 1)
+    const isLastStep = computed(() => modelValue.value === totalStepperItemsArray.value.length)
+    const totalSteps = computed(() => totalStepperItems.value.size)
+
+    function goToStep(step: number) {
+      if (!canGoToStep(step, totalStepperItemsArray.value, linear.value, modelValue.value)) return
+      modelValue.value = step
+    }
+    function nextStep() {
+      goToStep((modelValue.value ?? 1) + 1)
+    }
+    function prevStep() {
+      goToStep((modelValue.value ?? 1) - 1)
+    }
+    function hasNext() {
+      return (modelValue.value ?? 1) < totalSteps.value
+    }
+    function hasPrev() {
+      return (modelValue.value ?? 1) > 1
+    }
+
+    const nextStepperItem = ref<HTMLElement | null | 0>(null)
+    const prevStepperItem = ref<HTMLElement | null | 0>(null)
+    const isNextDisabled = computed(() =>
+      nextStepperItem.value ? nextStepperItem.value.getAttribute('disabled') === '' : true,
+    )
+    const isPrevDisabled = computed(() =>
+      prevStepperItem.value ? prevStepperItem.value.getAttribute('disabled') === '' : true,
+    )
+
+    function updateAdjacent() {
+      const adjacent = adjacentStepperItems(totalStepperItemsArray.value, modelValue.value!)
+      nextStepperItem.value = adjacent.next ?? null
+      prevStepperItem.value = adjacent.prev ?? null
+    }
+    watch(modelValue, async () => {
+      await nextTick(updateAdjacent)
+    })
+    watch(totalStepperItemsArray, async () => {
+      await nextTick(updateAdjacent)
+    })
+
+    provideStepperRootContext({
+      modelValue,
+      changeModelValue: value => {
+        modelValue.value = value
+      },
+      orientation: propOrientation,
+      dir,
+      linear,
+      totalStepperItems,
+    })
+
+    expose({
+      goToStep,
+      nextStep,
+      prevStep,
+      modelValue,
+      totalSteps,
+      isNextDisabled,
+      isPrevDisabled,
+      isFirstStep,
+      isLastStep,
+      hasNext,
+      hasPrev,
+    })
+    useForwardExpose()
+
+    return () =>
+      h(
+        Primitive,
+        {
+          role: 'group',
+          'aria-label': 'progress',
+          as: props.as,
+          'as-child': props.asChild,
+          'data-linear': linear.value ? '' : undefined,
+          'data-orientation': props.orientation,
+        },
+        {
+          default: withCtx(() => [
+            renderSlot(slots, 'default', {
+              modelValue: modelValue.value,
+              totalSteps: totalStepperItems.value.size,
+              isNextDisabled: isNextDisabled.value,
+              isPrevDisabled: isPrevDisabled.value,
+              isFirstStep: isFirstStep.value,
+              isLastStep: isLastStep.value,
+              goToStep,
+              nextStep,
+              prevStep,
+              hasNext,
+              hasPrev,
+            }),
+            h(
+              'div',
+              STATUS_PROPS,
+              stepperStatusText(modelValue.value, totalStepperItems.value.size),
+            ),
+          ]),
+        },
+      )
+  },
+})

package/src/primitives/stepper/StepperTrigger.ts

@@ -0,0 +1,119 @@
+import {
+  computed,
+  defineComponent,
+  h,
+  onMounted,
+  onUnmounted,
+  renderSlot,
+  withCtx,
+  withKeys,
+  withModifiers,
+  type PropType,
+} from 'vue'
+import { arrowNavigation } from '../../../../shared/src/primitives/arrow-navigation'
+import { getActiveElement } from '../../../../shared/src/primitives/focus-scope'
+import { activatesStepOnPointer } from '../../../../shared/src/primitives/stepper'
+import { Primitive, type PrimitiveProps } from '../primitive'
+import { useForwardExpose } from '../utils/useForwardExpose'
+import { injectStepperItemContext, injectStepperRootContext } from './context'
+
+export interface StepperTriggerProps {
+  asChild?: boolean
+  as?: PrimitiveProps['as']
+}
+
+const ARROW_KEYS = ['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown']
+
+export const StepperTrigger = defineComponent({
+  name: 'StepperTrigger',
+  props: {
+    asChild: { type: Boolean, required: false },
+    as: {
+      type: null as unknown as PropType<PrimitiveProps['as']>,
+      required: false,
+      default: 'button',
+    },
+  },
+  setup(props, { slots }) {
+    const rootContext = injectStepperRootContext()
+    const itemContext = injectStepperItemContext()
+    const stepperItems = computed(() => Array.from(rootContext.totalStepperItems.value))
+
+    function handleMouseDown(event: MouseEvent) {
+      if (itemContext.disabled.value) return
+      if (
+        activatesStepOnPointer(
+          event,
+          rootContext.linear.value,
+          itemContext.step.value,
+          rootContext.modelValue.value!,
+        )
+      ) {
+        rootContext.changeModelValue(itemContext.step.value)
+        return
+      }
+      event.preventDefault()
+    }
+
+    function handleKeyDown(event: KeyboardEvent) {
+      event.preventDefault()
+      if (itemContext.disabled.value) return
+      if ((event.key === 'Enter' || event.key === ' ') && !event.ctrlKey && !event.shiftKey)
+        rootContext.changeModelValue(itemContext.step.value)
+      if (ARROW_KEYS.includes(event.key))
+        arrowNavigation(event, getActiveElement() as HTMLElement | null, undefined, {
+          itemsArray: stepperItems.value,
+          focus: true,
+          loop: false,
+          arrowKeyOptions: rootContext.orientation.value,
+          dir: rootContext.dir.value,
+        })
+    }
+
+    const { forwardRef, currentElement } = useForwardExpose()
+    let registeredElement: HTMLElement | null = null
+    onMounted(() => {
+      registeredElement = currentElement.value
+      if (registeredElement) rootContext.totalStepperItems.value.add(registeredElement)
+    })
+    onUnmounted(() => {
+      if (registeredElement) {
+        rootContext.totalStepperItems.value.delete(registeredElement)
+        registeredElement = null
+      }
+    })
+
+    const onMousedown = withModifiers(handleMouseDown as (event: Event) => void, ['left'])
+    const onKeydown = withKeys(handleKeyDown as (event: Event) => void, [
+      'enter',
+      'space',
+      'left',
+      'right',
+      'up',
+      'down',
+    ])
+
+    return () => {
+      const unavailable = itemContext.disabled.value || !itemContext.isFocusable.value
+      return h(
+        Primitive,
+        {
+          ref: forwardRef,
+          type: props.as === 'button' ? 'button' : undefined,
+          as: props.as,
+          'as-child': props.asChild,
+          'data-state': itemContext.state.value,
+          disabled: unavailable ? '' : undefined,
+          'data-disabled': unavailable ? '' : undefined,
+          'data-orientation': rootContext.orientation.value,
+          tabindex: itemContext.isFocusable.value ? 0 : -1,
+          'aria-describedby': itemContext.descriptionId,
+          'aria-labelledby': itemContext.titleId,
+          onMousedown,
+          onKeydown,
+        },
+        { default: withCtx(() => [renderSlot(slots, 'default')]) },
+      )
+    }
+  },
+})

package/src/primitives/stepper/context.ts

@@ -0,0 +1,29 @@
+import type { ComputedRef, Ref } from 'vue'
+import type { StepperState } from '../../../../shared/src/primitives/stepper'
+import type { Orientation } from '../../../../shared/src/primitives/roving-focus'
+import { createContext } from '../utils/createContext'
+import type { Direction } from '../utils/useDirection'
+
+export interface StepperRootContext {
+  modelValue: Ref<number | undefined>
+  changeModelValue: (value: number) => void
+  orientation: Ref<Orientation>
+  dir: Ref<Direction>
+  linear: Ref<boolean>
+  totalStepperItems: Ref<Set<HTMLElement>>
+}
+
+export const [injectStepperRootContext, provideStepperRootContext] =
+  createContext<StepperRootContext>('StepperRoot')
+
+export interface StepperItemContext {
+  titleId: string
+  descriptionId: string
+  step: Ref<number>
+  state: ComputedRef<StepperState>
+  disabled: Ref<boolean>
+  isFocusable: ComputedRef<boolean>
+}
+
+export const [injectStepperItemContext, provideStepperItemContext] =
+  createContext<StepperItemContext>('StepperItem')

package/src/primitives/stepper/index.ts

@@ -0,0 +1,17 @@
+export {
+  injectStepperItemContext,
+  injectStepperRootContext,
+  type StepperItemContext,
+  type StepperRootContext,
+} from './context'
+export { StepperItem, type StepperItemProps } from './StepperItem'
+export {
+  StepperDescription,
+  StepperIndicator,
+  StepperSeparator,
+  StepperTitle,
+  type StepperPartProps,
+  type StepperSeparatorProps,
+} from './StepperParts'
+export { StepperRoot, type StepperRootEmits, type StepperRootProps } from './StepperRoot'
+export { StepperTrigger, type StepperTriggerProps } from './StepperTrigger'

package/src/primitives/switch/LICENSE

@@ -0,0 +1,44 @@
+MIT License
+
+Copyright (c) 2023 UnoVue <https://github.com/unovue>
+
+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.
+
+Portions adapted from VueUse:
+MIT License
+
+Copyright (c) 2019-PRESENT Anthony Fu<https://github.com/antfu>
+
+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.

package/src/primitives/switch/SwitchRoot.ts

@@ -0,0 +1,151 @@
+import {
+  computed,
+  createCommentVNode,
+  defineComponent,
+  Fragment,
+  h,
+  mergeProps,
+  renderSlot,
+  toRefs,
+  withCtx,
+  withKeys,
+  withModifiers,
+  type PropType,
+  type Ref,
+} from 'vue'
+import { nextCheckedValue } from '../../../../shared/src/primitives/checkbox'
+import { getLabelText } from '../../../../shared/src/primitives/label'
+import { Primitive, type PrimitiveProps } from '../primitive'
+import { createContext } from '../utils/createContext'
+import { useFormControl } from '../utils/useFormControl'
+import { useForwardExpose } from '../utils/useForwardExpose'
+import { useForwardScopeId } from '../utils/useForwardScopeId'
+import { useVModel } from '../utils/useVModel'
+import { VisuallyHiddenInput } from '../visually-hidden'
+
+export interface SwitchRootContext {
+  checked: Ref<boolean>
+  toggleCheck: () => void
+  disabled: Ref<boolean>
+}
+
+export const [injectSwitchRootContext, provideSwitchRootContext] =
+  createContext<SwitchRootContext>('SwitchRoot')
+
+export interface SwitchRootProps {
+  defaultValue?: unknown
+  modelValue?: unknown
+  disabled?: boolean
+  id?: string
+  value?: string
+  trueValue?: unknown
+  falseValue?: unknown
+  asChild?: boolean
+  as?: PrimitiveProps['as']
+  name?: string
+  required?: boolean
+}
+
+export const SwitchRoot = defineComponent({
+  name: 'SwitchRoot',
+  inheritAttrs: false,
+  props: {
+    defaultValue: { type: null as unknown as PropType<unknown>, required: false },
+    modelValue: { type: null as unknown as PropType<unknown>, required: false },
+    disabled: { type: Boolean, required: false },
+    id: { type: String, required: false },
+    value: { type: String, required: false, default: 'on' },
+    trueValue: { type: null as unknown as PropType<unknown>, required: false, default: () => true },
+    falseValue: {
+      type: null as unknown as PropType<unknown>,
+      required: false,
+      default: () => false,
+    },
+    asChild: { type: Boolean, required: false },
+    as: {
+      type: null as unknown as PropType<PrimitiveProps['as']>,
+      required: false,
+      default: 'button',
+    },
+    name: { type: String, required: false },
+    required: { type: Boolean, required: false },
+  },
+  emits: ['update:modelValue'],
+  setup(props, { emit, attrs, slots }) {
+    const { disabled } = toRefs(props)
+    const modelValue = useVModel(props, 'modelValue', emit, {
+      defaultValue: props.defaultValue ?? props.falseValue,
+      passive: props.modelValue === undefined,
+    })
+    const checked = computed(() => modelValue.value === props.trueValue)
+    function toggleCheck() {
+      if (disabled.value) return
+      modelValue.value = nextCheckedValue(
+        undefined,
+        checked.value,
+        props.trueValue,
+        props.falseValue,
+      )
+    }
+    const { forwardRef, currentElement } = useForwardExpose()
+    const isFormControl = useFormControl(currentElement)
+    const scopeIdAttrs = useForwardScopeId()
+    const ariaLabel = computed(() => getLabelText(props.id, currentElement.value))
+
+    provideSwitchRootContext({ checked, toggleCheck, disabled })
+
+    return () =>
+      h(Fragment, null, [
+        h(
+          Primitive,
+          mergeProps(
+            {
+              id: props.id,
+              ref: forwardRef,
+              role: 'switch',
+              type: props.as === 'button' ? 'button' : undefined,
+              value: props.value,
+              'aria-label': attrs['aria-label'] || ariaLabel.value,
+              'aria-checked': checked.value,
+              'aria-required': props.required,
+              'data-state': checked.value ? 'checked' : 'unchecked',
+              'data-disabled': disabled.value ? '' : undefined,
+              'as-child': props.asChild,
+              as: props.as,
+              disabled: disabled.value,
+            },
+            { ...scopeIdAttrs, ...attrs },
+            {
+              onClick: toggleCheck,
+              onKeydown: withKeys(withModifiers(toggleCheck, ['prevent']), ['enter']),
+            },
+          ),
+          {
+            default: withCtx(() => [
+              renderSlot(slots, 'default', {
+                modelValue: modelValue.value,
+                checked: checked.value,
+              }),
+            ]),
+          },
+        ),
+        isFormControl.value && props.name
+          ? h(
+              VisuallyHiddenInput,
+              mergeProps(
+                {
+                  key: 0,
+                  type: 'checkbox',
+                  name: props.name,
+                  disabled: disabled.value,
+                  required: props.required,
+                  value: props.value,
+                  checked: checked.value,
+                },
+                scopeIdAttrs,
+              ) as { name: string; value: unknown },
+            )
+          : createCommentVNode('v-if', true),
+      ])
+  },
+})

package/src/primitives/switch/index.ts

@@ -0,0 +1,6 @@
+export {
+  injectSwitchRootContext,
+  SwitchRoot,
+  type SwitchRootContext,
+  type SwitchRootProps,
+} from './SwitchRoot'

package/src/primitives/tabs/LICENSE

@@ -0,0 +1,44 @@
+MIT License
+
+Copyright (c) 2023 UnoVue <https://github.com/unovue>
+
+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.
+
+Portions adapted from VueUse:
+MIT License
+
+Copyright (c) 2019-PRESENT Anthony Fu<https://github.com/antfu>
+
+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.