react-native-audio-browser 0.2.0-next.9 → 0.2.0

package/src/web/browser/classifyTrackNavigation.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { Track } from '../../types'
-import { classifyTrackNavigation } from './classifyTrackNavigation'
-
-const track = (fields: Partial<Track>): Track => fields as Track
-
-describe('classifyTrackNavigation', () => {
-  it('classifies a contextual url, exposing parent path and track id', () => {
-    expect(
-      classifyTrackNavigation(
-        track({ url: '/library/radio?__trackId=song.mp3' })
-      )
-    ).toEqual({
-      kind: 'contextual',
-      parentPath: '/library/radio',
-      trackId: 'song.mp3'
-    })
-  })
-
-  it('classifies a non-contextual url as a browse navigation', () => {
-    expect(classifyTrackNavigation(track({ url: '/library/radio' }))).toEqual({
-      kind: 'browse'
-    })
-  })
-
-  it('classifies a track with src but no url as playable', () => {
-    expect(classifyTrackNavigation(track({ src: 'song.mp3' }))).toEqual({
-      kind: 'playable'
-    })
-  })
-
-  it('prefers browse over playable when a url is present', () => {
-    expect(
-      classifyTrackNavigation(track({ url: '/library/radio', src: 'song.mp3' }))
-    ).toEqual({ kind: 'browse' })
-  })
-
-  it('classifies a track with neither url nor src as invalid', () => {
-    expect(classifyTrackNavigation(track({}))).toEqual({ kind: 'invalid' })
-  })
-})

package/src/web/browser/classifyTrackNavigation.ts

@@ -1,35 +0,0 @@
-import type { Track } from '../../types'
-import { BrowserPathHelper } from '../util/BrowserPathHelper'
-
-/**
- * How a selected track should be navigated, decided purely from its shape:
- * - `contextual` — a playable track carrying its parent queue context in a
- *   contextual URL (`{parentPath}?__trackId={src}`); expand/skip within that queue.
- * - `browse` — a browsable track (has a `url` that isn't contextual); drill in.
- * - `playable` — a bare playable track (`src`, no `url`); load and play it alone.
- * - `invalid` — neither `url` nor `src`; nothing to do.
- */
-export type TrackNavigation =
-  | { kind: 'contextual'; parentPath: string; trackId: string | undefined }
-  | { kind: 'browse' }
-  | { kind: 'playable' }
-  | { kind: 'invalid' }
-
-/**
- * Pure classifier for {@link Track} navigation — the web analog of iOS's
- * TrackSelector decision tree. Executing the chosen action stays with the
- * caller; this only decides which action applies.
- */
-export function classifyTrackNavigation(track: Track): TrackNavigation {
-  const url = track.url
-  if (url && BrowserPathHelper.isContextual(url)) {
-    return {
-      kind: 'contextual',
-      parentPath: BrowserPathHelper.stripTrackId(url),
-      trackId: BrowserPathHelper.extractTrackId(url)
-    }
-  }
-  if (url) return { kind: 'browse' }
-  if (track.src) return { kind: 'playable' }
-  return { kind: 'invalid' }
-}

package/src/web/browser/parseSearchResponse.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { parseSearchResponse } from './parseSearchResponse'
-
-describe('parseSearchResponse', () => {
-  it('extracts children from a page-object response', () => {
-    const tracks = [{ src: '/a', title: 'A' }]
-    expect(
-      parseSearchResponse({ url: '/search', title: 'Search', children: tracks })
-    ).toEqual(tracks)
-  })
-
-  it('returns a bare array response unchanged (back-compat)', () => {
-    const tracks = [{ src: '/a', title: 'A' }]
-    expect(parseSearchResponse(tracks)).toEqual(tracks)
-  })
-
-  it('returns [] for a page object with no children', () => {
-    expect(parseSearchResponse({ url: '/search', title: 'Search' })).toEqual([])
-  })
-
-  it('returns [] for null / non-object responses', () => {
-    expect(parseSearchResponse(null)).toEqual([])
-    expect(parseSearchResponse('nope')).toEqual([])
-  })
-})

package/src/web/browser/parseSearchResponse.ts

@@ -1,15 +0,0 @@
-import type { Track } from '../../types'
-
-/**
- * Normalise a search endpoint's HTTP body into `Track[]`. Endpoints return the
- * audio-browser page shape `{ children: Track[] }` (matching iOS/Android, which
- * decode a ResolvedTrack and read `.children`). A bare `Track[]` is still
- * accepted for back-compat with callback/array-returning sources.
- */
-export function parseSearchResponse(response: unknown): Track[] {
-  if (Array.isArray(response)) return response as Track[]
-  if (response && typeof response === 'object' && 'children' in response) {
-    return (response as { children?: Track[] }).children ?? []
-  }
-  return []
-}

package/src/web/http/RequestConfigBuilder.test.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import type { RequestConfig, TransformableRequestConfig } from '../../types'
-import { RequestConfigBuilder } from './RequestConfigBuilder'
-
-/**
- * Composition tests for the sync/async `transform` split. These lock down the
- * run-both pipeline (async first, then sync) so a regression in the layering
- * logic is caught. NOTE: they do NOT exercise the JS↔native Nitro bridge — the
- * original "async returns an empty config" bug lived there and is structurally
- * invisible to a pure-JS test. See the codegen regression guard for that.
- */
-describe('RequestConfigBuilder.applyLayer — sync/async transform composition', () => {
-  const base: RequestConfig = { baseUrl: 'https://api.example.com', path: '/p' }
-
-  it('applies an async transform', async () => {
-    const layer: TransformableRequestConfig = {
-      transform: async (req) => ({ ...req, headers: { a: '1' } })
-    }
-    const out = await RequestConfigBuilder.applyLayer(base, layer)
-    expect(out.headers).toEqual({ a: '1' })
-    expect(out.baseUrl).toBe('https://api.example.com')
-  })
-
-  it('applies a sync transform', async () => {
-    const layer: TransformableRequestConfig = {
-      transformSync: (req) => ({ ...req, headers: { b: '2' } })
-    }
-    const out = await RequestConfigBuilder.applyLayer(base, layer)
-    expect(out.headers).toEqual({ b: '2' })
-  })
-
-  it('runs both as a pipeline: async first, then sync sees the async output', async () => {
-    const order: string[] = []
-    const layer: TransformableRequestConfig = {
-      transform: async (req) => {
-        order.push('async')
-        return { ...req, query: { stage: 'async' } }
-      },
-      transformSync: (req) => {
-        order.push('sync')
-        // The sync stage must receive the async stage's output.
-        expect(req.query).toEqual({ stage: 'async' })
-        return { ...req, query: { ...req.query, stage: 'sync' } }
-      }
-    }
-    const out = await RequestConfigBuilder.applyLayer(base, layer)
-    expect(order).toEqual(['async', 'sync'])
-    expect(out.query).toEqual({ stage: 'sync' })
-  })
-
-  it('falls back to a static field merge when no transform is set', async () => {
-    const layer: TransformableRequestConfig = {
-      baseUrl: 'https://override.example.com'
-    }
-    const out = await RequestConfigBuilder.applyLayer(base, layer)
-    expect(out.baseUrl).toBe('https://override.example.com')
-    expect(out.path).toBe('/p')
-  })
-})

package/src/web/playbackErrorKind.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { kindForHttpStatus, playbackErrorKind } from './playbackErrorKind'
-
-const BAD_HTTP_STATUS = 1001
-const TIMEOUT = 1003
-
-describe('kindForHttpStatus', () => {
-  it('maps statuses to kinds', () => {
-    // 404/410 must be checked before the 400-499 arm swallows them.
-    expect(kindForHttpStatus(404)).toBe('not-found')
-    expect(kindForHttpStatus(410)).toBe('not-found')
-    // Range edges.
-    expect(kindForHttpStatus(400)).toBe('rejected')
-    expect(kindForHttpStatus(499)).toBe('rejected')
-    expect(kindForHttpStatus(500)).toBe('server-error')
-    expect(kindForHttpStatus(599)).toBe('server-error')
-    expect(kindForHttpStatus(302)).toBe('unknown')
-    expect(kindForHttpStatus(600)).toBe('unknown')
-  })
-})
-
-describe('playbackErrorKind', () => {
-  it('reports offline regardless of the code', () => {
-    expect(playbackErrorKind(BAD_HTTP_STATUS, 404, false)).toBe('offline')
-  })
-
-  it('uses the HTTP status Shaka carries in data[1]', () => {
-    expect(playbackErrorKind(BAD_HTTP_STATUS, 503)).toBe('server-error')
-  })
-
-  it('falls back to the category when no status was reported', () => {
-    // BAD_HTTP_STATUS is category 1, which is not one of the unplayable
-    // categories — without a status there is nothing to classify.
-    expect(playbackErrorKind(BAD_HTTP_STATUS)).toBe('unknown')
-  })
-
-  it('treats network timeouts as unreachable', () => {
-    expect(playbackErrorKind(TIMEOUT)).toBe('unreachable')
-  })
-
-  it('treats media, manifest and streaming failures as unplayable', () => {
-    expect(playbackErrorKind(3016)).toBe('unplayable') // MEDIA
-    expect(playbackErrorKind(4032)).toBe('unplayable') // MANIFEST
-    expect(playbackErrorKind(5006)).toBe('unplayable') // STREAMING
-  })
-
-  it('treats DRM failures as rejected', () => {
-    expect(playbackErrorKind(6001)).toBe('rejected')
-  })
-
-  it('leaves codes that name no cause unknown', () => {
-    expect(playbackErrorKind(7001)).toBe('unknown') // PLAYER
-    expect(playbackErrorKind(-1)).toBe('unknown') // our own non-Shaka fallback
-  })
-})

package/src/web/playbackErrorKind.ts

@@ -1,56 +0,0 @@
-import type { PlaybackErrorKind } from '../features/errors'
-
-/**
- * Maps Shaka's error codes onto {@link PlaybackErrorKind}, the same
- * cross-platform contract iOS derives from AVFoundation and Android from
- * ExoPlayer.
- *
- * Shaka numbers its codes `<category><nnn>`: 1xxx network, 2xxx text, 3xxx
- * media, 4xxx manifest, 5xxx streaming, 6xxx DRM, 7xxx player.
- *
- * As on the native side, codes that name no cause stay `'unknown'` rather than
- * being guessed into a friendlier bucket.
- */
-
-const BAD_HTTP_STATUS = 1001
-const HTTP_ERROR = 1002
-const TIMEOUT = 1003
-const ATTEMPTS_EXHAUSTED = 1010
-
-export function kindForHttpStatus(status: number): PlaybackErrorKind {
-  if (status === 404 || status === 410) return 'not-found'
-  if (status >= 500 && status <= 599) return 'server-error'
-  // Every other 4xx is the server refusing us — auth, geo-blocking, a rate
-  // limit. All of them mean "you can't have this stream", not "retry".
-  if (status >= 400 && status <= 499) return 'rejected'
-  return 'unknown'
-}
-
-/**
- * @param code - a `shaka.util.Error.Code`
- * @param httpStatus - the status Shaka reported for `BAD_HTTP_STATUS`, which it
- *   carries in `error.data[1]`
- * @param online - `navigator.onLine`. Shaka's codes cannot tell a dead station
- *   from a dead connection; only the browser can.
- */
-export function playbackErrorKind(
-  code: number,
-  httpStatus?: number,
-  online = true
-): PlaybackErrorKind {
-  if (!online) return 'offline'
-  if (code === BAD_HTTP_STATUS && httpStatus !== undefined) {
-    return kindForHttpStatus(httpStatus)
-  }
-  if (code === HTTP_ERROR || code === TIMEOUT || code === ATTEMPTS_EXHAUSTED) {
-    return 'unreachable'
-  }
-  const category = Math.floor(code / 1000)
-  // Media, manifest and streaming failures all mean the same thing to a
-  // listener: it arrived, and it is not playable.
-  if (category === 2 || category === 3 || category === 4 || category === 5) {
-    return 'unplayable'
-  }
-  if (category === 6) return 'rejected'
-  return 'unknown'
-}

package/src/web/player/MediaSessionManager.test.ts

@@ -1,220 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import type { MediaSessionActions } from './MediaSessionManager'
-import { MediaSessionManager } from './MediaSessionManager'
-
-type Handler = ((details: any) => void) | null
-
-class FakeMediaMetadata {
-  title?: string
-  artist?: string
-  album?: string
-  artwork: { src: string }[]
-  constructor(init: {
-    title?: string
-    artist?: string
-    album?: string
-    artwork?: { src: string }[]
-  }) {
-    this.title = init.title
-    this.artist = init.artist
-    this.album = init.album
-    this.artwork = init.artwork ?? []
-  }
-}
-
-function makeFakeSession() {
-  const handlers = new Map<string, Handler>()
-  const setPositionState = vi.fn()
-  const session = {
-    metadata: null as FakeMediaMetadata | null,
-    playbackState: 'none' as 'none' | 'paused' | 'playing',
-    setActionHandler: vi.fn((action: string, handler: Handler) => {
-      handlers.set(action, handler)
-    }),
-    setPositionState
-  }
-  return { session, handlers, setPositionState }
-}
-
-function makeActions(): MediaSessionActions {
-  return {
-    play: vi.fn(),
-    pause: vi.fn(),
-    stop: vi.fn(),
-    next: vi.fn(),
-    previous: vi.fn(),
-    seek: vi.fn(),
-    jumpForward: vi.fn(),
-    jumpBackward: vi.fn()
-  }
-}
-
-describe('MediaSessionManager', () => {
-  let fake: ReturnType<typeof makeFakeSession>
-
-  beforeEach(() => {
-    fake = makeFakeSession()
-    vi.stubGlobal('navigator', { mediaSession: fake.session })
-    vi.stubGlobal('MediaMetadata', FakeMediaMetadata)
-  })
-
-  afterEach(() => {
-    vi.unstubAllGlobals()
-  })
-
-  it('registers action handlers that route to the provided actions', () => {
-    const actions = makeActions()
-    new MediaSessionManager(actions)
-
-    fake.handlers.get('play')?.(undefined)
-    fake.handlers.get('pause')?.(undefined)
-    fake.handlers.get('stop')?.(undefined)
-    fake.handlers.get('nexttrack')?.(undefined)
-    fake.handlers.get('previoustrack')?.(undefined)
-
-    expect(actions.play).toHaveBeenCalledOnce()
-    expect(actions.pause).toHaveBeenCalledOnce()
-    expect(actions.stop).toHaveBeenCalledOnce()
-    expect(actions.next).toHaveBeenCalledOnce()
-    expect(actions.previous).toHaveBeenCalledOnce()
-  })
-
-  it('routes seekto with the requested seek time', () => {
-    const actions = makeActions()
-    new MediaSessionManager(actions)
-
-    fake.handlers.get('seekto')?.({ seekTime: 42 })
-
-    expect(actions.seek).toHaveBeenCalledWith(42)
-  })
-
-  it('ignores seekto without a seek time', () => {
-    const actions = makeActions()
-    new MediaSessionManager(actions)
-
-    fake.handlers.get('seekto')?.({})
-
-    expect(actions.seek).not.toHaveBeenCalled()
-  })
-
-  it('uses the seek offset for seekforward/seekbackward, falling back to a default', () => {
-    const actions = makeActions()
-    new MediaSessionManager(actions)
-
-    fake.handlers.get('seekforward')?.({ seekOffset: 30 })
-    fake.handlers.get('seekbackward')?.({})
-
-    expect(actions.jumpForward).toHaveBeenCalledWith(30)
-    expect(actions.jumpBackward).toHaveBeenCalledWith(10)
-  })
-
-  it('publishes metadata to the session', () => {
-    new MediaSessionManager(makeActions()).setMetadata({
-      title: 'Live Set',
-      artist: 'Station FM',
-      album: 'Radio',
-      artwork: 'https://api.example.com/art.png'
-    })
-
-    const metadata = fake.session.metadata as FakeMediaMetadata
-    expect(metadata.title).toBe('Live Set')
-    expect(metadata.artist).toBe('Station FM')
-    expect(metadata.album).toBe('Radio')
-    expect(metadata.artwork).toEqual([
-      { src: 'https://api.example.com/art.png' }
-    ])
-  })
-
-  it('omits artwork when none is provided', () => {
-    new MediaSessionManager(makeActions()).setMetadata({ title: 'No Art' })
-    const metadata = fake.session.metadata as FakeMediaMetadata
-    expect(metadata.artwork).toEqual([])
-  })
-
-  it('reflects playback state', () => {
-    const manager = new MediaSessionManager(makeActions())
-    manager.setPlaybackState('playing')
-    expect(fake.session.playbackState).toBe('playing')
-    manager.setPlaybackState('paused')
-    expect(fake.session.playbackState).toBe('paused')
-  })
-
-  it('reports position state for finite, seekable durations', () => {
-    const manager = new MediaSessionManager(makeActions())
-    manager.setPositionState({ duration: 180, position: 30, playbackRate: 1 })
-    expect(fake.setPositionState).toHaveBeenCalledWith({
-      duration: 180,
-      position: 30,
-      playbackRate: 1
-    })
-  })
-
-  it('clears position state for live streams (infinite/zero duration)', () => {
-    const manager = new MediaSessionManager(makeActions())
-    manager.setPositionState({
-      duration: Infinity,
-      position: 30,
-      playbackRate: 1
-    })
-    manager.setPositionState({ duration: 0, position: 0, playbackRate: 1 })
-    // Called with no argument resets the position state.
-    expect(fake.setPositionState).toHaveBeenCalledTimes(2)
-    expect(fake.setPositionState).toHaveBeenNthCalledWith(1)
-    expect(fake.setPositionState).toHaveBeenNthCalledWith(2)
-  })
-
-  it('clamps position to within the duration', () => {
-    const manager = new MediaSessionManager(makeActions())
-    manager.setPositionState({ duration: 100, position: 150, playbackRate: 1 })
-    expect(fake.setPositionState).toHaveBeenCalledWith({
-      duration: 100,
-      position: 100,
-      playbackRate: 1
-    })
-  })
-
-  it('clamps a negative position up to zero', () => {
-    const manager = new MediaSessionManager(makeActions())
-    manager.setPositionState({ duration: 100, position: -5, playbackRate: 1 })
-    expect(fake.setPositionState).toHaveBeenCalledWith({
-      duration: 100,
-      position: 0,
-      playbackRate: 1
-    })
-  })
-
-  it('coerces a non-positive playback rate to 1 (the API rejects rate 0)', () => {
-    const manager = new MediaSessionManager(makeActions())
-    manager.setPositionState({ duration: 100, position: 10, playbackRate: 0 })
-    expect(fake.setPositionState).toHaveBeenCalledWith({
-      duration: 100,
-      position: 10,
-      playbackRate: 1
-    })
-  })
-
-  it('dispose clears handlers, metadata and playback state', () => {
-    const manager = new MediaSessionManager(makeActions())
-    manager.setMetadata({ title: 'x' })
-    manager.setPlaybackState('playing')
-
-    manager.dispose()
-
-    expect(fake.session.metadata).toBeNull()
-    expect(fake.session.playbackState).toBe('none')
-    // Every registered action gets cleared back to null.
-    expect(fake.handlers.get('play')).toBeNull()
-  })
-
-  it('is a no-op when the Media Session API is unavailable', () => {
-    vi.stubGlobal('navigator', {})
-    const actions = makeActions()
-    expect(() => {
-      const manager = new MediaSessionManager(actions)
-      manager.setMetadata({ title: 'x' })
-      manager.setPlaybackState('playing')
-      manager.setPositionState({ duration: 1, position: 0, playbackRate: 1 })
-      manager.dispose()
-    }).not.toThrow()
-  })
-})

package/src/web/player/MediaSessionManager.ts

@@ -1,151 +0,0 @@
-import type { NowPlayingMetadata } from '../../features'
-
-/**
- * Player actions a Media Session command routes into. The host wires these to
- * its remote-dispatch methods (handle-or-default, then emit) so browser media
- * controls behave exactly like the native lockscreen/CarPlay/Android Auto path.
- */
-export interface MediaSessionActions {
-  play(): void
-  pause(): void
-  stop(): void
-  next(): void
-  previous(): void
-  /** Absolute seek, in seconds. */
-  seek(position: number): void
-  /** Relative seek forward, in seconds. */
-  jumpForward(interval: number): void
-  /** Relative seek backward, in seconds. */
-  jumpBackward(interval: number): void
-}
-
-/** Fallback skip interval (seconds) when the browser omits a seek offset. */
-const DEFAULT_SEEK_INTERVAL = 10
-
-/**
- * Bridges the web player to the browser's Media Session API, so the OS media
- * controls (lockscreen, notification shade, hardware media keys, Bluetooth
- * controls) show the current track and route their commands back into the
- * player.
- *
- * The native platforms publish now-playing metadata and handle remote commands
- * via MPNowPlayingInfoCenter / MediaSession; this is the web equivalent. It is a
- * no-op when the API is unavailable (server-side rendering, older browsers).
- */
-export class MediaSessionManager {
-  private readonly session: MediaSession | undefined
-
-  /** Actions registered as handlers — tracked so dispose() can clear them. */
-  private static readonly ACTIONS: MediaSessionAction[] = [
-    'play',
-    'pause',
-    'stop',
-    'nexttrack',
-    'previoustrack',
-    'seekto',
-    'seekforward',
-    'seekbackward'
-  ]
-
-  constructor(actions: MediaSessionActions) {
-    this.session =
-      typeof navigator !== 'undefined' &&
-      'mediaSession' in navigator &&
-      typeof MediaMetadata !== 'undefined'
-        ? navigator.mediaSession
-        : undefined
-    if (this.session) this.registerHandlers(this.session, actions)
-  }
-
-  /**
-   * Publishes now-playing metadata to the OS media controls.
-   */
-  setMetadata(metadata: NowPlayingMetadata): void {
-    if (!this.session) return
-    this.session.metadata = new MediaMetadata({
-      title: metadata.title ?? '',
-      artist: metadata.artist ?? '',
-      album: metadata.album ?? '',
-      artwork: metadata.artwork ? [{ src: metadata.artwork }] : []
-    })
-  }
-
-  /**
-   * Reflects whether the player is playing/paused/stopped in the OS controls.
-   */
-  setPlaybackState(state: MediaSessionPlaybackState): void {
-    if (!this.session) return
-    this.session.playbackState = state
-  }
-
-  /**
-   * Reports the scrubber position. Live streams (infinite or unknown duration)
-   * have no meaningful position, so the state is cleared instead.
-   */
-  setPositionState(state: {
-    duration: number
-    position: number
-    playbackRate: number
-  }): void {
-    if (!this.session?.setPositionState) return
-    const { duration, position, playbackRate } = state
-    if (!Number.isFinite(duration) || duration <= 0) {
-      // No seekable timeline (live radio) — clear any stale position.
-      this.session.setPositionState()
-      return
-    }
-    this.session.setPositionState({
-      duration,
-      position: Math.max(0, Math.min(position, duration)),
-      playbackRate: playbackRate > 0 ? playbackRate : 1
-    })
-  }
-
-  /**
-   * Removes handlers and clears metadata/state. Call when tearing down.
-   */
-  dispose(): void {
-    if (!this.session) return
-    for (const action of MediaSessionManager.ACTIONS) {
-      try {
-        this.session.setActionHandler(action, null)
-      } catch {
-        // Browser doesn't support this action — nothing to clear.
-      }
-    }
-    this.session.metadata = null
-    this.session.playbackState = 'none'
-  }
-
-  private registerHandlers(
-    session: MediaSession,
-    actions: MediaSessionActions
-  ): void {
-    const set = (
-      action: MediaSessionAction,
-      handler: MediaSessionActionHandler
-    ) => {
-      // Not every browser supports every action; ignore the ones it rejects.
-      try {
-        session.setActionHandler(action, handler)
-      } catch {
-        // Unsupported action — skip it.
-      }
-    }
-
-    set('play', () => actions.play())
-    set('pause', () => actions.pause())
-    set('stop', () => actions.stop())
-    set('nexttrack', () => actions.next())
-    set('previoustrack', () => actions.previous())
-    set('seekto', (details) => {
-      if (details.seekTime != null) actions.seek(details.seekTime)
-    })
-    set('seekforward', (details) => {
-      actions.jumpForward(details.seekOffset ?? DEFAULT_SEEK_INTERVAL)
-    })
-    set('seekbackward', (details) => {
-      actions.jumpBackward(details.seekOffset ?? DEFAULT_SEEK_INTERVAL)
-    })
-  }
-}