botframework-webchat-api 4.18.1-main.20260416.88357ae → 4.18.1

package/src/hooks/middleware/activityFallbackPolymiddleware.ts

@@ -1,23 +0,0 @@
-import { activityComponent, createActivityPolymiddleware } from '@msinternal/botframework-webchat-api-middleware';
-import { type WebChatActivity } from 'botframework-webchat-core';
-import { memo } from 'react';
-
-// eslint-disable-next-line prefer-arrow-callback
-const NoActivityToRenderComponent = memo(function NoActivityToRenderComponent({
-  activity
-}: {
-  readonly activity: WebChatActivity;
-  children?: never;
-}) {
-  throw new Error(`No renderer for activity of type "${activity.type}"`);
-});
-
-const activityFallbackPolymiddleware = createActivityPolymiddleware(
-  () =>
-    ({ activity }) =>
-      activityComponent<{ readonly activity: WebChatActivity; children?: never }>(NoActivityToRenderComponent, {
-        activity
-      })
-);
-
-export default activityFallbackPolymiddleware;

package/src/hooks/useStartVoice.ts

@@ -1,9 +0,0 @@
-import useWebChatAPIContext from './internal/useWebChatAPIContext';
-
-/**
- * Hook to start voice mode (turns on microphone and enables audio synthesis).
- * This starts speech-to-speech interaction.
- */
-export default function useStartVoice(): () => void {
-  return useWebChatAPIContext().startVoice;
-}

package/src/hooks/useStopVoice.ts

@@ -1,9 +0,0 @@
-import useWebChatAPIContext from './internal/useWebChatAPIContext';
-
-/**
- * Hook to stop voice mode (turns off microphone and stops audio playback).
- * This ends speech-to-speech interaction.
- */
-export default function useStopVoice(): () => void {
-  return useWebChatAPIContext().stopVoice;
-}

package/src/hooks/useUIState.ts

@@ -1,18 +0,0 @@
-import { useMemo } from 'react';
-
-import useWebChatAPIContext from './internal/useWebChatAPIContext';
-
-/**
- * Gets the state of the UI.
- *
- * - `undefined` will render normally
- * - `"blueprint"` will render as few UI elements as possible and should be non-functional
- *   - Useful for loading scenarios
- * - `"disabled"` will render most UI elements as non-functional
- *   - Scrolling may continue to trigger read acknowledgements
- */
-export default function useUIState(): readonly ['blueprint' | 'disabled' | undefined] {
-  const { uiState } = useWebChatAPIContext();
-
-  return useMemo(() => Object.freeze([uiState]), [uiState]);
-}

package/src/hooks/useVoiceRecordingMuted.ts

@@ -1,24 +0,0 @@
-import { muteVoiceRecording, unmuteVoiceRecording } from 'botframework-webchat-core';
-import { useCallback } from 'react';
-import { useDispatch, useSelector } from './internal/WebChatReduxContext';
-
-/**
- * Hook to get and set voice recording mute state in speech-to-speech mode.
- *
- * Mute is independent of voice state - it can be toggled at any time.
- * When muted, silent audio chunks are sent instead of real audio.
- * Mute resets to false when recording stops.
- */
-export default function useVoiceRecordingMuted(): readonly [boolean, (muted: boolean) => void] {
-  const dispatch = useDispatch();
-  const value = useSelector(({ voice }) => voice.microphoneMuted);
-
-  const setter = useCallback(
-    (muted: boolean) => {
-      dispatch(muted ? muteVoiceRecording() : unmuteVoiceRecording());
-    },
-    [dispatch]
-  );
-
-  return Object.freeze([value, setter]);
-}

package/src/hooks/useVoiceState.ts

@@ -1,15 +0,0 @@
-import type { VoiceState } from 'botframework-webchat-core';
-import useVoiceStateWritable from './internal/useVoiceStateWritable';
-
-/**
- * Hook to get the voice state.
- * The voice state represents the current state of the speech-to-speech interaction:
- * - 'idle': No active speech session, microphone and audio playback are off
- * - 'listening': Microphone is active
- * - 'user_speaking': User is actively speaking
- * - 'processing': User finished speaking, server is processing
- * - 'bot_speaking': Bot is speaking (audio playback)
- */
-export default function useVoiceState(): readonly [VoiceState] {
-  return Object.freeze([useVoiceStateWritable()[0]]);
-}

package/src/hooks/validation/uiState.parseUIState.spec.ts

@@ -1,21 +0,0 @@
-import { parseUIState } from './uiState';
-
-describe.each([
-  ['blueprint', false, 'blueprint'],
-  ['blueprint', true, 'blueprint'],
-  ['blueprint', undefined, 'blueprint'],
-  ['disabled', false, 'disabled'],
-  ['disabled', true, 'disabled'],
-  ['disabled', undefined, 'disabled'],
-  ['xyz', false, undefined],
-  ['xyz', true, 'disabled'],
-  ['xyz', undefined, undefined],
-  [undefined, false, undefined],
-  [undefined, true, 'disabled'],
-  [undefined, undefined, undefined]
-])('uiState=%s and disabled=%s', (uiState, disabled, expected) => {
-  describe('parseUIState', () => {
-    test(`should return ${JSON.stringify(expected)}`, () =>
-      expect(parseUIState(uiState as any, disabled as any)).toBe(expected));
-  });
-});

package/src/hooks/validation/uiState.ts

@@ -1,10 +0,0 @@
-import { fallback, literal, parse, union } from 'valibot';
-
-export function parseUIState(
-  input: 'blueprint' | 'disabled' | undefined,
-  disabled: boolean | undefined
-): 'blueprint' | 'disabled' | undefined {
-  // Patching deprecated "disabled" props into "uiState".
-  // Priority: uiState > disabled.
-  return parse(fallback(union([literal('blueprint'), literal('disabled')]), disabled ? 'disabled' : undefined), input);
-}

package/src/legacy/LegacyActivityBridge.tsx

@@ -1,77 +0,0 @@
-import { validateProps } from '@msinternal/botframework-webchat-react-valibot';
-import React, { Fragment, memo, useMemo } from 'react';
-
-import useCreateActivityStatusRenderer from '../hooks/useCreateActivityStatusRenderer';
-import useCreateAvatarRenderer from '../hooks/useCreateAvatarRenderer';
-import useRenderAttachment from '../hooks/useRenderAttachment';
-import { useLegacyActivityContext } from './LegacyActivityBridgeContext';
-import {
-  legacyActivityBridgeComponentPropsSchema,
-  type LegacyActivityBridgeComponentProps
-} from './createActivityPolymiddlewareFromLegacy';
-
-/**
- * This component is solely for `createActivityPolymiddlewareFromLegacy`.
- *
- * @param props Legacy activity middleware props, includes `hideTimestamp`, `renderActivityStatus`, `renderAvatar`, and `showCallout`.
- * @returns An activity node rendered using the `props.render()` of type `LegacyRenderFunction`.
- */
-function LegacyActivityBridge(props: LegacyActivityBridgeComponentProps) {
-  const {
-    activity,
-    hideTimestamp: hideTimestampFromProps,
-    render,
-    renderActivityStatus: renderActivityStatusFromProps,
-    renderAvatar: renderAvatarFromProps,
-    showCallout: showCalloutFromProps
-  } = validateProps(legacyActivityBridgeComponentPropsSchema, props);
-
-  // These props are only available when the activity is being rendered through <BasicTranscript>.
-  // Otherwise, they will be false/undefined.
-  const { hideTimestamp, showCallout } = useLegacyActivityContext();
-
-  const createActivityStatusRenderer = useCreateActivityStatusRenderer();
-  const renderAttachment = useRenderAttachment();
-  const renderAvatarRaw = useCreateAvatarRenderer();
-
-  const renderActivityStatus = useMemo(
-    () => createActivityStatusRenderer(Object.freeze({ activity })),
-    [activity, createActivityStatusRenderer]
-  );
-  const renderAvatar = useMemo(
-    () => !!renderAvatarRaw && renderAvatarRaw(Object.freeze({ activity })),
-    [activity, renderAvatarRaw]
-  );
-
-  const children = useMemo(
-    () =>
-      render(
-        renderAttachment,
-        Object.freeze({
-          hideTimestamp: typeof hideTimestampFromProps === 'undefined' ? hideTimestamp : hideTimestampFromProps,
-          renderActivityStatus:
-            typeof renderActivityStatusFromProps === 'undefined' ? renderActivityStatus : renderActivityStatusFromProps,
-          renderAvatar: typeof renderAvatarFromProps === 'undefined' ? renderAvatar : renderAvatarFromProps,
-          showCallout: typeof showCalloutFromProps === 'undefined' ? showCallout : showCalloutFromProps
-        })
-      ),
-    [
-      hideTimestamp,
-      hideTimestampFromProps,
-      render,
-      renderActivityStatus,
-      renderActivityStatusFromProps,
-      renderAttachment,
-      renderAvatar,
-      renderAvatarFromProps,
-      showCallout,
-      showCalloutFromProps
-    ]
-  );
-
-  return <Fragment>{children}</Fragment>;
-}
-
-LegacyActivityBridge.displayName = 'LegacyActivityBridge';
-
-export default memo(LegacyActivityBridge);

package/src/legacy/LegacyActivityBridgeContext.ts

@@ -1,23 +0,0 @@
-import { createContext, useContext } from 'react';
-
-type LegacyActivityContextType = {
-  readonly hideTimestamp: boolean;
-  readonly showCallout: boolean;
-};
-
-const LegacyActivityContext = createContext<LegacyActivityContextType>(
-  Object.freeze({
-    hideTimestamp: false,
-    showCallout: false
-  })
-);
-
-function useLegacyActivityContext(): LegacyActivityContextType {
-  return useContext(LegacyActivityContext);
-}
-
-// Exporting <Provider> individually so we can let people write to the context but not reading from it.
-const { Provider: LegacyActivityContextProvider } = LegacyActivityContext;
-
-export default LegacyActivityContext;
-export { LegacyActivityContextProvider, useLegacyActivityContext, type LegacyActivityContextType };

package/src/legacy/createActivityPolymiddlewareFromLegacy.tsx

@@ -1,123 +0,0 @@
-import {
-  activityComponent,
-  createActivityPolymiddleware,
-  type ActivityPolymiddleware
-} from '@msinternal/botframework-webchat-api-middleware';
-import {
-  type LegacyActivityMiddleware,
-  type LegacyRenderAttachment
-} from '@msinternal/botframework-webchat-api-middleware/legacy';
-import { type WebChatActivity } from 'botframework-webchat-core';
-import { composeEnhancer } from 'handler-chain';
-import { type ReactNode } from 'react';
-import {
-  boolean,
-  custom,
-  function_,
-  literal,
-  never,
-  object,
-  optional,
-  pipe,
-  readonly,
-  safeParse,
-  union,
-  type InferInput
-} from 'valibot';
-
-import LegacyActivityBridge from './LegacyActivityBridge';
-
-const DEBUG_ORIGINAL_LEGACY_MIDDLEWARE_SYMBOL = Symbol('OriginalLegacyMiddleware');
-const webChatActivitySchema = custom<WebChatActivity>(value => safeParse(object({}), value).success);
-
-type LegacyRenderFunction = (
-  renderAttachment: LegacyRenderAttachment,
-  options: {
-    readonly hideTimestamp: boolean;
-    readonly renderActivityStatus: (options: { hideTimestamp: boolean }) => ReactNode;
-    readonly renderAvatar: false | (() => Exclude<ReactNode, boolean | null | undefined>);
-    readonly showCallout: boolean;
-  }
-) => Exclude<ReactNode, boolean>;
-
-const legacyActivityBridgeComponentPropsSchema = pipe(
-  object({
-    activity: webChatActivitySchema,
-    children: optional(never()),
-    render: custom<LegacyRenderFunction>(value => safeParse(function_(), value).success),
-
-    // The following extraneous props should be removed once `useCreateActivityRenderer()` is removed.
-    hideTimestamp: optional(boolean()),
-    renderActivityStatus: optional(
-      custom<(options: { hideTimestamp: boolean }) => ReactNode>(value => safeParse(function_(), value).success)
-    ),
-    renderAvatar: optional(
-      union([
-        literal(false),
-        custom<() => Exclude<ReactNode, boolean | null | undefined>>(value => safeParse(function_(), value).success)
-      ])
-    ),
-    showCallout: optional(boolean())
-  }),
-  readonly()
-);
-
-type LegacyActivityBridgeComponentProps = Readonly<
-  InferInput<typeof legacyActivityBridgeComponentPropsSchema> & { children?: never }
->;
-
-const fallbackComponentPropsSchema = pipe(
-  object({
-    activity: webChatActivitySchema,
-    children: optional(never())
-  }),
-  readonly()
-);
-
-type FallbackComponentProps = Readonly<InferInput<typeof fallbackComponentPropsSchema> & { children?: never }>;
-
-/**
- * Polyfill legacy activity middleware into a polymiddleware.
- *
- * @deprecated Legacy activity middleware is being deprecated and will be removed on or after 2027-08-16.
- * @param middleware An array of legacy activity middleware.
- * @returns A polymiddleware composed by legacy activity middleware.
- */
-function createActivityPolymiddlewareFromLegacy(
-  ...middleware: readonly LegacyActivityMiddleware[]
-): ActivityPolymiddleware {
-  const legacyEnhancer = composeEnhancer(...middleware.map(middleware => middleware()));
-
-  const polymiddleware = createActivityPolymiddleware(next => {
-    const legacyHandler = legacyEnhancer(request => {
-      const handler = next(request);
-
-      return !!handler && (() => handler.render({}));
-    });
-
-    return request => {
-      const legacyResult = legacyHandler(request);
-
-      return legacyResult
-        ? activityComponent(LegacyActivityBridge, { activity: request.activity, render: legacyResult })
-        : undefined;
-    };
-  });
-
-  Object.defineProperty(polymiddleware, DEBUG_ORIGINAL_LEGACY_MIDDLEWARE_SYMBOL, {
-    configurable: false,
-    value: Object.freeze([...middleware]),
-    writable: false
-  });
-
-  return polymiddleware;
-}
-
-export default createActivityPolymiddlewareFromLegacy;
-
-export {
-  fallbackComponentPropsSchema,
-  legacyActivityBridgeComponentPropsSchema,
-  type FallbackComponentProps,
-  type LegacyActivityBridgeComponentProps
-};

package/src/legacy/createAvatarPolymiddlewareFromLegacy.tsx

@@ -1,102 +0,0 @@
-import {
-  __INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol,
-  __INTERNAL_DO_NOT_USE__legacyAvatarMiddlewareOriginalRequestSymbol,
-  avatarComponent,
-  createAvatarPolymiddleware,
-  type AvatarPolymiddleware
-} from '@msinternal/botframework-webchat-api-middleware';
-import { type LegacyAvatarMiddleware } from '@msinternal/botframework-webchat-api-middleware/legacy';
-import { composeEnhancer } from 'handler-chain';
-import React, { Fragment, memo, type ReactNode } from 'react';
-import { custom, function_, never, object, optional, pipe, readonly, safeParse, type InferInput } from 'valibot';
-
-type LegacyAvatarRenderFunction = () => Exclude<ReactNode, boolean | null | undefined>;
-
-const legacyAvatarBridgeComponentPropsSchema = pipe(
-  object({
-    children: optional(never()),
-    renderFn: custom<LegacyAvatarRenderFunction>(value => safeParse(function_(), value).success)
-  }),
-  readonly()
-);
-
-type LegacyAvatarBridgeComponentProps = Readonly<
-  InferInput<typeof legacyAvatarBridgeComponentPropsSchema> & { children?: never }
->;
-
-/**
- * Bridge component for the legacy avatar middleware.
- * Renders the result of the legacy render function.
- */
-function LegacyAvatarBridge(props: LegacyAvatarBridgeComponentProps) {
-  const { renderFn } = props;
-
-  return <Fragment>{renderFn()}</Fragment>;
-}
-
-const MemoizedLegacyAvatarBridge = memo(LegacyAvatarBridge);
-
-/**
- * Polyfill legacy avatar middleware into a polymiddleware.
- *
- * @deprecated Use `polymiddleware` instead. Legacy avatar middleware is being deprecated and will be removed on or after 2028-03-16.
- * @param middleware An array of legacy avatar middleware.
- * @returns A polymiddleware composed by legacy avatar middleware.
- */
-function createAvatarPolymiddlewareFromLegacy(...middlewares: readonly LegacyAvatarMiddleware[]): AvatarPolymiddleware {
-  const legacyEnhancer = composeEnhancer(...middlewares.map(middleware => middleware()));
-
-  return createAvatarPolymiddleware(next => {
-    const legacyHandler = legacyEnhancer(
-      ({ [__INTERNAL_DO_NOT_USE__legacyAvatarMiddlewareOriginalRequestSymbol]: originalRequest }) => {
-        if (!originalRequest) {
-          // TODO: Add a test
-          throw new Error(
-            'botframework-webchat: `avatarMiddleware` must pass the whole request object to downstreamers'
-          );
-        }
-
-        // Pass styleOptions through the polymiddleware chain via the internal runtime extension
-        // so downstream handlers (e.g. core middleware) can still read it.
-        const handler = next(originalRequest);
-
-        return !!handler && ((): Exclude<ReactNode, boolean | null | undefined> => handler.render({}));
-      }
-    );
-
-    return request => {
-      const { [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: styleOptions, activity } =
-        request;
-
-      const legacyResult = legacyHandler(
-        Object.freeze({
-          activity,
-          fromUser: activity.from?.role === 'user',
-          styleOptions,
-          [__INTERNAL_DO_NOT_USE__legacyAvatarMiddlewareOriginalRequestSymbol]: request
-        })
-      );
-
-      if (!legacyResult) {
-        return;
-      }
-
-      let props: LegacyAvatarBridgeComponentProps;
-
-      if (typeof legacyResult !== 'function') {
-        console.warn(
-          'botframework-webchat: avatarMiddleware should return a function to render the avatar, or return false if avatar should be hidden. Please refer to HOOKS.md for details.'
-        );
-
-        props = Object.freeze({ renderFn: () => legacyResult });
-      } else {
-        props = Object.freeze({ renderFn: legacyResult });
-      }
-
-      return avatarComponent(MemoizedLegacyAvatarBridge, props);
-    };
-  });
-}
-
-export default createAvatarPolymiddlewareFromLegacy;
-export { legacyAvatarBridgeComponentPropsSchema, type LegacyAvatarBridgeComponentProps };

package/src/middleware/AvatarPolymiddlewareProxy.tsx

@@ -1,46 +0,0 @@
-// We need to patch <AvatarPolymiddlewareProxy> from `api-middleware`.
-//
-// - Props of <AvatarPolymiddlewareProxy> should not need `styleOptions`
-//   - We should call `useStyleOptions()` to get style options
-// - However, `api-middleware` is before `api`, so it do not have access to `useStyleOptions`
-//
-// Until we have `api-style-options`, we have to patch <AvatarPolymiddlewareProxy> inside `api`.
-
-import {
-  __INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol,
-  AvatarPolymiddlewareProxy as RawAvatarPolymiddlewareProxy
-} from '@msinternal/botframework-webchat-api-middleware';
-import { validateProps } from '@msinternal/botframework-webchat-react-valibot';
-import type { WebChatActivity } from 'botframework-webchat-core';
-import React, { memo, useMemo } from 'react';
-import { custom, object, pipe, readonly, safeParse, type InferInput } from 'valibot';
-import { useStyleOptions } from '../hooks';
-
-const avatarPolymiddlewareProxyPropsSchema = pipe(
-  object({
-    activity: custom<Readonly<WebChatActivity>>(value => safeParse(object({}), value).success)
-  }),
-  readonly()
-);
-
-type AvatarPolymiddlewareProxyProps = Readonly<InferInput<typeof avatarPolymiddlewareProxyPropsSchema>>;
-
-const AvatarPolymiddlewareProxy = memo((props: AvatarPolymiddlewareProxyProps) => {
-  const { activity } = validateProps(avatarPolymiddlewareProxyPropsSchema, props);
-
-  const [styleOptions] = useStyleOptions();
-
-  const rawProps = useMemo(
-    () => ({
-      [__INTERNAL_DO_NOT_USE__avatarPolymiddlewareRequestStyleOptionsSymbol]: styleOptions
-    }),
-    [styleOptions]
-  );
-
-  return <RawAvatarPolymiddlewareProxy activity={activity} {...rawProps} />;
-});
-
-AvatarPolymiddlewareProxy.displayName = 'AvatarPolymiddlewareProxy';
-
-export default AvatarPolymiddlewareProxy;
-export { avatarPolymiddlewareProxyPropsSchema, type AvatarPolymiddlewareProxyProps };

package/src/middleware/SendBoxMiddleware.ts

@@ -1,28 +0,0 @@
-import templateMiddleware, {
-  type InferMiddleware,
-  type InferProps,
-  type InferRequest
-} from './private/templateMiddleware';
-
-const template = templateMiddleware<void, { className?: string | undefined }>('sendBoxMiddleware');
-
-const {
-  createMiddleware: createSendBoxMiddleware,
-  extractMiddleware: extractSendBoxMiddleware,
-  Provider: SendBoxMiddlewareProvider,
-  Proxy: SendBoxMiddlewareProxy
-} = template;
-
-type SendBoxMiddleware = InferMiddleware<typeof template>;
-type SendBoxMiddlewareProps = InferProps<typeof template>;
-type SendBoxMiddlewareRequest = InferRequest<typeof template>;
-
-export {
-  createSendBoxMiddleware,
-  extractSendBoxMiddleware,
-  SendBoxMiddlewareProvider,
-  SendBoxMiddlewareProxy,
-  type SendBoxMiddleware,
-  type SendBoxMiddlewareProps,
-  type SendBoxMiddlewareRequest
-};

package/src/middleware/SendBoxToolbarMiddleware.ts

@@ -1,28 +0,0 @@
-import templateMiddleware, {
-  type InferMiddleware,
-  type InferProps,
-  type InferRequest
-} from './private/templateMiddleware';
-
-const template = templateMiddleware<void, { className?: string | undefined }>('sendBoxToolbarMiddleware');
-
-const {
-  createMiddleware: createSendBoxToolbarMiddleware,
-  extractMiddleware: extractSendBoxToolbarMiddleware,
-  Provider: SendBoxToolbarMiddlewareProvider,
-  Proxy: SendBoxToolbarMiddlewareProxy
-} = template;
-
-type SendBoxToolbarMiddleware = InferMiddleware<typeof template>;
-type SendBoxToolbarMiddlewareProps = InferProps<typeof template>;
-type SendBoxToolbarMiddlewareRequest = InferRequest<typeof template>;
-
-export {
-  createSendBoxToolbarMiddleware,
-  extractSendBoxToolbarMiddleware,
-  SendBoxToolbarMiddlewareProvider,
-  SendBoxToolbarMiddlewareProxy,
-  type SendBoxToolbarMiddleware,
-  type SendBoxToolbarMiddlewareProps,
-  type SendBoxToolbarMiddlewareRequest
-};

package/src/middleware/private/templateMiddleware.check.test.tsx

@@ -1,47 +0,0 @@
-import templateMiddleware from './templateMiddleware';
-
-test('should warn if middleware is not an array of function', () => {
-  const warn = jest.fn();
-  const template = templateMiddleware('Check');
-
-  jest.spyOn(console, 'warn').mockImplementation(warn);
-
-  template.extractMiddleware(1 as any);
-
-  expect(warn).toHaveBeenCalledTimes(1);
-  expect(warn).toHaveBeenNthCalledWith(1, expect.stringContaining('must be an array of function'));
-});
-
-test('should warn if middleware did not return function', () => {
-  const warn = jest.fn();
-  const template = templateMiddleware('Check');
-
-  jest.spyOn(console, 'warn').mockImplementation(warn);
-
-  template.extractMiddleware([() => 1 as any]);
-
-  expect(warn).toHaveBeenCalledTimes(1);
-  expect(warn).toHaveBeenNthCalledWith(1, expect.stringContaining('must return enhancer function'));
-});
-
-test('should not warn if middleware return false', () => {
-  const warn = jest.fn();
-  const template = templateMiddleware('Check');
-
-  jest.spyOn(console, 'warn').mockImplementation(warn);
-
-  template.extractMiddleware([() => false]);
-
-  expect(warn).toHaveBeenCalledTimes(0);
-});
-
-test('should not warn if middleware return function', () => {
-  const warn = jest.fn();
-  const template = templateMiddleware('Check');
-
-  jest.spyOn(console, 'warn').mockImplementation(warn);
-
-  template.extractMiddleware([() => () => 1 as any]);
-
-  expect(warn).toHaveBeenCalledTimes(0);
-});