@hina-ui/vue 1.7.5 → 1.7.7

package/dist/shared/primitives/number-field/index.ts

@@ -0,0 +1,407 @@
+import { NumberFormatter, NumberParser } from '@internationalized/number'
+
+export type NumberFieldStep = 'increase' | 'decrease'
+export type NumberFieldBound = 'min' | 'max'
+export type NumberFieldInputMode = 'decimal' | 'numeric'
+
+export interface NumberFieldRange {
+  min?: number
+  max?: number
+  step: number
+  stepSnapping: boolean
+}
+
+export interface NumberFieldFormat {
+  formatter: NumberFormatter
+  parser: NumberParser
+}
+
+export const NUMBER_FIELD_DEFAULT_LOCALE = 'en'
+export const NUMBER_FIELD_PAGE_STEPS = 10
+export const NUMBER_FIELD_HOLD_DELAY = 400
+export const NUMBER_FIELD_HOLD_INTERVAL = 60
+
+export function clamp(
+  value: number,
+  min = Number.NEGATIVE_INFINITY,
+  max = Number.POSITIVE_INFINITY,
+) {
+  return Math.min(max, Math.max(min, value))
+}
+
+export function roundToStepPrecision(value: number, step: number) {
+  let rounded = value
+  const text = step.toString()
+  const point = text.indexOf('.')
+  const precision = point >= 0 ? text.length - point : 0
+  if (precision > 0) {
+    const pow = 10 ** precision
+    rounded = Math.round(rounded * pow) / pow
+  }
+  return rounded
+}
+
+export function snapValueToStep(
+  value: number,
+  minValue: number | undefined,
+  maxValue: number | undefined,
+  step: number,
+) {
+  const min = Number(minValue)
+  const max = Number(maxValue)
+  const remainder = (value - (Number.isNaN(min) ? 0 : min)) % step
+  let snapped = roundToStepPrecision(
+    Math.abs(remainder) * 2 >= step
+      ? value + Math.sign(remainder) * (step - Math.abs(remainder))
+      : value - remainder,
+    step,
+  )
+  if (!Number.isNaN(min)) {
+    if (snapped < min) snapped = min
+    else if (!Number.isNaN(max) && snapped > max)
+      snapped = min + Math.floor(roundToStepPrecision((max - min) / step, step)) * step
+  } else if (!Number.isNaN(max) && snapped > max)
+    snapped = Math.floor(roundToStepPrecision(max / step, step)) * step
+  return roundToStepPrecision(snapped, step)
+}
+
+export function handleDecimalOperation(operator: '-' | '+', left: number, right: number) {
+  let result = operator === '+' ? left + right : left - right
+  if (left % 1 !== 0 || right % 1 !== 0) {
+    const leftDecimals = left.toString().split('.')[1]?.length ?? 0
+    const rightDecimals = right.toString().split('.')[1]?.length ?? 0
+    const multiplier = 10 ** Math.max(leftDecimals, rightDecimals)
+    const a = Math.round(left * multiplier)
+    const b = Math.round(right * multiplier)
+    result = (operator === '+' ? a + b : a - b) / multiplier
+  }
+  return result
+}
+
+export function isNullish(value: unknown): value is null | undefined {
+  return value === null || value === undefined
+}
+
+function isNumber(value: number | null | undefined): value is number {
+  return !isNullish(value) && !Number.isNaN(value)
+}
+
+export function resolveNumberFieldLocale(locale?: string, inherited?: string) {
+  return locale || inherited || NUMBER_FIELD_DEFAULT_LOCALE
+}
+
+export function createNumberFieldFormat(
+  locale: string,
+  options?: Intl.NumberFormatOptions,
+): NumberFieldFormat {
+  return {
+    formatter: new NumberFormatter(locale, options),
+    parser: new NumberParser(locale, options),
+  }
+}
+
+export function numberFieldInputMode(format: NumberFieldFormat): NumberFieldInputMode {
+  return format.formatter.resolvedOptions().maximumFractionDigits! > 0 ? 'decimal' : 'numeric'
+}
+
+export function formatNumberFieldValue(
+  value: number | null | undefined,
+  format: NumberFieldFormat,
+) {
+  return isNumber(value) ? format.formatter.format(value) : ''
+}
+
+export function clampNumberFieldValue(
+  value: number,
+  range: NumberFieldRange,
+  format: NumberFieldFormat,
+) {
+  const { min, max, step, stepSnapping } = range
+  const clamped =
+    Number.isNaN(step) || !stepSnapping
+      ? clamp(value, min, max)
+      : snapValueToStep(value, min, max, step)
+  return format.parser.parse(format.formatter.format(clamped))
+}
+
+export function nextNumberFieldValue(
+  direction: NumberFieldStep,
+  from: number,
+  range: NumberFieldRange,
+  format: NumberFieldFormat,
+  multiplier = 1,
+) {
+  const { step } = range
+  const operator = direction === 'increase' ? '+' : '-'
+  let next: number
+  if (range.stepSnapping && !Number.isNaN(step)) {
+    const snapped = snapValueToStep(from, range.min, range.max, step)
+    if (snapped === from) next = handleDecimalOperation(operator, from, step * multiplier)
+    else {
+      const aligned =
+        direction === 'increase'
+          ? snapped > from
+            ? snapped
+            : handleDecimalOperation('+', snapped, step)
+          : snapped < from
+            ? snapped
+            : handleDecimalOperation('-', snapped, step)
+      next =
+        multiplier > 1
+          ? handleDecimalOperation(operator, aligned, step * (multiplier - 1))
+          : aligned
+    }
+  } else next = handleDecimalOperation(operator, from, step * multiplier)
+  return clampNumberFieldValue(next, range, format)
+}
+
+export function isNumberFieldAtLimit(
+  direction: NumberFieldStep,
+  value: number | null | undefined,
+  range: NumberFieldRange,
+  format: NumberFieldFormat,
+) {
+  if (!isNumber(value)) return false
+  const next = nextNumberFieldValue(direction, value, range, format)
+  return direction === 'increase' ? next <= value : next >= value
+}
+
+export function stepNumberFieldText(
+  direction: NumberFieldStep,
+  text: string,
+  range: NumberFieldRange,
+  format: NumberFieldFormat,
+  multiplier = 1,
+) {
+  const current = format.parser.parse(text)
+  if (Number.isNaN(current)) return clampNumberFieldValue(range.min ?? 0, range, format)
+  return nextNumberFieldValue(direction, current, range, format, multiplier)
+}
+
+export function boundNumberFieldValue(
+  bound: NumberFieldBound,
+  range: NumberFieldRange,
+  format: NumberFieldFormat,
+) {
+  const target = bound === 'min' ? range.min : range.max
+  return target === undefined ? undefined : clampNumberFieldValue(target, range, format)
+}
+
+export interface NumberFieldCommit {
+  value: number | undefined
+  reformat: boolean
+}
+
+export function commitNumberFieldText(
+  text: string,
+  range: NumberFieldRange,
+  format: NumberFieldFormat,
+): NumberFieldCommit {
+  const parsed = format.parser.parse(text)
+  return {
+    value: Number.isNaN(parsed) ? undefined : clampNumberFieldValue(parsed, range, format),
+    reformat: text.length > 0,
+  }
+}
+
+export interface NumberFieldBeforeInput {
+  isComposing: boolean
+  inputType: string
+  data: string | null
+}
+
+export interface NumberFieldTextSelection {
+  value: string
+  selectionStart: number | null
+  selectionEnd: number | null
+}
+
+export function rejectsNumberFieldInput(
+  event: NumberFieldBeforeInput,
+  input: NumberFieldTextSelection,
+  range: NumberFieldRange,
+  format: NumberFieldFormat,
+) {
+  if (event.isComposing) return false
+  if (event.inputType.startsWith('delete') || event.inputType.startsWith('history')) return false
+  const next =
+    input.value.slice(0, input.selectionStart ?? undefined) +
+    (event.data ?? '') +
+    input.value.slice(input.selectionEnd ?? undefined)
+  return !format.parser.isValidPartialNumber(next, range.min, range.max)
+}
+
+export type NumberFieldKeyAction =
+  | { type: 'step'; direction: NumberFieldStep; multiplier: number; prevent: true }
+  | { type: 'bound'; bound: NumberFieldBound; prevent: true }
+  | { type: 'commit'; prevent: false }
+
+export function numberFieldKeyAction(
+  event: { key: string; isComposing: boolean },
+  composing: boolean,
+): NumberFieldKeyAction | undefined {
+  if (composing || event.isComposing) return undefined
+  switch (event.key) {
+    case 'ArrowUp':
+      return { type: 'step', direction: 'increase', multiplier: 1, prevent: true }
+    case 'ArrowDown':
+      return { type: 'step', direction: 'decrease', multiplier: 1, prevent: true }
+    case 'PageUp':
+      return {
+        type: 'step',
+        direction: 'increase',
+        multiplier: NUMBER_FIELD_PAGE_STEPS,
+        prevent: true,
+      }
+    case 'PageDown':
+      return {
+        type: 'step',
+        direction: 'decrease',
+        multiplier: NUMBER_FIELD_PAGE_STEPS,
+        prevent: true,
+      }
+    case 'Home':
+      return { type: 'bound', bound: 'min', prevent: true }
+    case 'End':
+      return { type: 'bound', bound: 'max', prevent: true }
+    case 'Enter':
+      return { type: 'commit', prevent: false }
+    default:
+      return undefined
+  }
+}
+
+export interface NumberFieldWheelState {
+  focused: boolean
+  disabled: boolean
+  inverted: boolean
+}
+
+export function numberFieldWheelStep(
+  event: { deltaX: number; deltaY: number },
+  state: NumberFieldWheelState,
+): NumberFieldStep | undefined {
+  if (state.disabled || !state.focused) return undefined
+  if (Math.abs(event.deltaY) <= Math.abs(event.deltaX)) return undefined
+  const down = event.deltaY > 0
+  return down !== state.inverted ? 'increase' : 'decrease'
+}
+
+export function deepActiveElement(root: Pick<DocumentOrShadowRoot, 'activeElement'>) {
+  let active = root.activeElement
+  while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement
+  return active
+}
+
+export interface NumberFieldTimers {
+  setTimeout: (callback: () => void, delay: number) => unknown
+  clearTimeout: (handle: unknown) => void
+}
+
+export interface NumberFieldPressHoldOptions {
+  timers: NumberFieldTimers
+  disabled: () => boolean
+  trigger: () => void
+  pressed: (pressed: boolean) => void
+}
+
+export interface NumberFieldPress {
+  button: number
+  preventDefault: () => void
+}
+
+export function createNumberFieldPressHold(options: NumberFieldPressHoldOptions) {
+  let handle: unknown
+  let pressed = false
+  const reset = () => options.timers.clearTimeout(handle)
+  const repeat = (delay: number) => {
+    reset()
+    if (options.disabled()) return
+    options.trigger()
+    handle = options.timers.setTimeout(() => repeat(NUMBER_FIELD_HOLD_INTERVAL), delay)
+  }
+  return {
+    press(event: NumberFieldPress) {
+      if (event.button !== 0 || pressed) return
+      event.preventDefault()
+      pressed = true
+      options.pressed(true)
+      repeat(NUMBER_FIELD_HOLD_DELAY)
+    },
+    release() {
+      pressed = false
+      options.pressed(false)
+      reset()
+    },
+    dispose: reset,
+  }
+}
+
+export function numberFieldRootAttributes(state: { disabled: boolean; readonly: boolean }) {
+  return {
+    role: 'group',
+    'data-disabled': state.disabled ? '' : undefined,
+    'data-readonly': state.readonly ? '' : undefined,
+  } as const
+}
+
+export interface NumberFieldInputState {
+  id: string | undefined
+  value: string
+  inputMode: NumberFieldInputMode
+  disabled: boolean
+  readonly: boolean
+  modelValue: number | null | undefined
+  min: number | undefined
+  max: number | undefined
+}
+
+export function numberFieldInputAttributes(state: NumberFieldInputState) {
+  return {
+    id: state.id,
+    value: state.value,
+    role: 'spinbutton',
+    type: 'text',
+    tabindex: '0',
+    inputmode: state.inputMode,
+    disabled: state.disabled ? '' : undefined,
+    'data-disabled': state.disabled ? '' : undefined,
+    readonly: state.readonly ? '' : undefined,
+    'data-readonly': state.readonly ? '' : undefined,
+    autocomplete: 'off',
+    autocorrect: 'off',
+    spellcheck: 'false',
+    'aria-roledescription': 'Number field',
+    'aria-valuenow': state.modelValue,
+    'aria-valuemin': state.min,
+    'aria-valuemax': state.max,
+  } as const
+}
+
+export function isNumberFieldStepDisabled(state: {
+  disabled: boolean
+  readonly: boolean
+  own: boolean
+  atLimit: boolean
+}) {
+  return state.disabled || state.readonly || state.own || state.atLimit
+}
+
+export interface NumberFieldStepState {
+  direction: NumberFieldStep
+  button: boolean
+  disabled: boolean
+  pressed: boolean
+}
+
+export function numberFieldStepAttributes(state: NumberFieldStepState) {
+  return {
+    tabindex: '-1',
+    'aria-label': state.direction === 'increase' ? 'Increase' : 'Decrease',
+    type: state.button ? 'button' : undefined,
+    style: { userSelect: state.pressed ? 'none' : undefined },
+    disabled: state.disabled ? '' : undefined,
+    'data-disabled': state.disabled ? '' : undefined,
+    'data-pressed': state.pressed ? 'true' : undefined,
+  } as const
+}

package/dist/shared/primitives/pagination/LICENSE

@@ -0,0 +1,21 @@
+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.

package/dist/shared/primitives/pagination/index.ts

@@ -0,0 +1,99 @@
+export type PaginationItems = Array<{ type: 'ellipsis' } | { type: 'page'; value: number }>
+
+function range(start: number, end: number) {
+  const length = end - start + 1
+  return Array.from({ length }, (_, idx) => idx + start)
+}
+
+export function transform(items: (string | number)[]): PaginationItems {
+  return items.map(value => {
+    if (typeof value === 'number') return { type: 'page', value }
+    return { type: 'ellipsis' }
+  })
+}
+
+const ELLIPSIS = 'ellipsis'
+
+export function getRange(
+  currentPage: number,
+  pageCount: number,
+  siblingCount: number,
+  showEdges: boolean,
+) {
+  const firstPageIndex = 1
+  const lastPageIndex = pageCount
+
+  const leftSiblingIndex = Math.max(currentPage - siblingCount, firstPageIndex)
+  const rightSiblingIndex = Math.min(currentPage + siblingCount, lastPageIndex)
+
+  if (showEdges) {
+    const totalPageNumbers = Math.min(2 * siblingCount + 5, pageCount)
+
+    const itemCount = totalPageNumbers - 2
+
+    const showLeftEllipsis =
+      leftSiblingIndex > firstPageIndex + 2 &&
+      Math.abs(lastPageIndex - itemCount - firstPageIndex + 1) > 2 &&
+      Math.abs(leftSiblingIndex - firstPageIndex) > 2
+
+    const showRightEllipsis =
+      rightSiblingIndex < lastPageIndex - 2 &&
+      Math.abs(lastPageIndex - itemCount) > 2 &&
+      Math.abs(lastPageIndex - rightSiblingIndex) > 2
+
+    if (!showLeftEllipsis && showRightEllipsis) {
+      const leftRange = range(1, itemCount)
+
+      return [...leftRange, ELLIPSIS, lastPageIndex]
+    }
+
+    if (showLeftEllipsis && !showRightEllipsis) {
+      const rightRange = range(lastPageIndex - itemCount + 1, lastPageIndex)
+
+      return [firstPageIndex, ELLIPSIS, ...rightRange]
+    }
+
+    if (showLeftEllipsis && showRightEllipsis) {
+      const middleRange = range(leftSiblingIndex, rightSiblingIndex)
+
+      return [firstPageIndex, ELLIPSIS, ...middleRange, ELLIPSIS, lastPageIndex]
+    }
+
+    const fullRange = range(firstPageIndex, lastPageIndex)
+    return fullRange
+  } else {
+    const itemCount = siblingCount * 2 + 1
+
+    if (pageCount < itemCount) return range(1, lastPageIndex)
+    else if (currentPage <= siblingCount + 1) return range(firstPageIndex, itemCount)
+    else if (pageCount - currentPage <= siblingCount)
+      return range(pageCount - itemCount + 1, lastPageIndex)
+    else return range(leftSiblingIndex, rightSiblingIndex)
+  }
+}
+
+export type PaginationEdge = 'first' | 'prev' | 'next' | 'last'
+
+export function paginationPageCount(total: number, itemsPerPage: number) {
+  return Math.max(1, Math.ceil(total / (itemsPerPage || 1)))
+}
+
+export function paginationEdgeDisabled(
+  edge: PaginationEdge,
+  page: number,
+  pageCount: number,
+  disabled: boolean,
+) {
+  return (edge === 'first' || edge === 'prev' ? page === 1 : page === pageCount) || disabled
+}
+
+export function paginationEdgeTarget(edge: PaginationEdge, page: number, pageCount: number) {
+  return edge === 'first' ? 1 : edge === 'prev' ? page - 1 : edge === 'next' ? page + 1 : pageCount
+}
+
+export const PAGINATION_EDGES: Record<PaginationEdge, { label: string; fallback: string }> = {
+  first: { label: 'First Page', fallback: 'First page' },
+  prev: { label: 'Previous Page', fallback: 'Prev page' },
+  next: { label: 'Next Page', fallback: 'Next page' },
+  last: { label: 'Last Page', fallback: 'Last page' },
+}

package/dist/shared/primitives/pin-input/LICENSE

@@ -0,0 +1,21 @@
+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.

package/dist/shared/primitives/pin-input/index.ts

@@ -0,0 +1,126 @@
+import { arrowNavigation } from '../arrow-navigation'
+
+export type PinInputValue = Array<string | number | undefined>
+
+const NUMBER = /^\d*$/
+const NON_NUMBER = /\D/g
+const NAVIGATION_KEYS = ['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown', 'Home', 'End']
+
+export function pinInputValues(value: unknown): PinInputValue {
+  return Array.isArray(value) ? [...value] : []
+}
+
+export function isPinInputComplete(values: PinInputValue, count: number, numeric: boolean) {
+  return values.filter(value => !!value || (numeric && value === 0)).length === count
+}
+
+export function stripPinNonNumbers(value: string) {
+  return value.replace(NON_NUMBER, '')
+}
+
+function removeTrailingEmptyStrings(values: PinInputValue) {
+  while (values.length && values[values.length - 1] === '') values.pop()
+  return values
+}
+
+export function setPinValueAt(
+  current: PinInputValue,
+  index: number,
+  value: string,
+  numeric: boolean,
+) {
+  const values = [...current]
+  if (numeric) {
+    const number = +value
+    if (value === '' || Number.isNaN(number)) delete values[index]
+    else values[index] = number
+  } else values[index] = value
+  return removeTrailingEmptyStrings(values)
+}
+
+export function spreadPinValue(
+  current: PinInputValue,
+  characters: string,
+  index: number,
+  count: number,
+  numeric: boolean,
+) {
+  const values = [...current]
+  const start = characters.length >= count ? 0 : index
+  const end = Math.min(start + characters.length, count)
+  const filled: number[] = []
+  for (let at = start; at < end; at++) {
+    const character = characters[at - start]!
+    if (numeric) {
+      const number = Number.parseInt(character)
+      if (Number.isNaN(number)) continue
+      values[at] = number
+    } else values[at] = character
+    filled.push(at)
+  }
+  return { values, filled, end }
+}
+
+export type PinTextAction =
+  | { kind: 'clear' }
+  | { kind: 'filter'; value: string }
+  | { kind: 'spread'; characters: string }
+  | { kind: 'single'; character: string }
+
+export function resolvePinComposition(value: string, numeric: boolean): PinTextAction {
+  const text = numeric ? stripPinNonNumbers(value) : value
+  if (numeric && !text) return { kind: 'clear' }
+  if (text.length > 1) return { kind: 'spread', characters: text }
+  return { kind: 'single', character: text }
+}
+
+export function resolvePinInput(
+  data: string | null | undefined,
+  value: string,
+  numeric: boolean,
+): PinTextAction {
+  if ((data?.length ?? 0) > 1) return { kind: 'spread', characters: value }
+  if (numeric && !NUMBER.test(value)) return { kind: 'filter', value: stripPinNonNumbers(value) }
+  return { kind: 'single', character: data || value.slice(-1) }
+}
+
+export function resolvePinPaste(text: string, numeric: boolean) {
+  return numeric ? stripPinNonNumbers(text) : text
+}
+
+export function pinFocusRedirect(values: PinInputValue, count: number, index: number) {
+  for (let at = 0; at < count; at++)
+    if (values[at] === '' || values[at] === undefined) return at < index ? at : -1
+  return -1
+}
+
+export function isPinNavigationKey(key: string) {
+  return NAVIGATION_KEYS.includes(key)
+}
+
+export function navigatePin(
+  event: KeyboardEvent,
+  current: HTMLElement | null,
+  inputs: HTMLElement[],
+  dir: 'ltr' | 'rtl',
+) {
+  arrowNavigation(event, current, undefined, {
+    itemsArray: inputs,
+    focus: true,
+    loop: false,
+    arrowKeyOptions: 'horizontal',
+    dir,
+  })
+}
+
+export function pinPlaceholder(
+  element: HTMLInputElement,
+  active: Element | null,
+  placeholder: string,
+) {
+  element.placeholder = !element.value && element === active ? '' : placeholder
+}
+
+export function pinInputLabel(index: number, count: number) {
+  return `pin input ${index + 1} of ${count}`
+}

package/dist/shared/primitives/presence/LICENSE

@@ -0,0 +1,21 @@
+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.