bluera-knowledge 0.14.0 → 0.14.1

package/tests/fixtures/corpus/oss-repos/hono/src/helper/css/index.ts

@@ -1,220 +0,0 @@
-/**
- * @module
- * css Helper for Hono.
- */
-
-import { raw } from '../../helper/html'
-import { DOM_RENDERER } from '../../jsx/constants'
-import { createCssJsxDomObjects } from '../../jsx/dom/css'
-import type { HtmlEscapedCallback, HtmlEscapedString } from '../../utils/html'
-import type { CssClassName as CssClassNameCommon, CssVariableType } from './common'
-import {
-  CLASS_NAME,
-  DEFAULT_STYLE_ID,
-  PSEUDO_GLOBAL_SELECTOR,
-  SELECTOR,
-  SELECTORS,
-  STYLE_STRING,
-  cssCommon,
-  cxCommon,
-  keyframesCommon,
-  viewTransitionCommon,
-} from './common'
-export { rawCssString } from './common'
-
-type CssClassName = HtmlEscapedString & CssClassNameCommon
-
-type usedClassNameData = [
-  Record<string, string>, // class name to add
-  Record<string, true>, // class name already added
-]
-
-interface CssType {
-  (strings: TemplateStringsArray, ...values: CssVariableType[]): Promise<string>
-}
-
-interface CxType {
-  (
-    ...args: (CssClassName | Promise<string> | string | boolean | null | undefined)[]
-  ): Promise<string>
-}
-
-interface KeyframesType {
-  (strings: TemplateStringsArray, ...values: CssVariableType[]): CssClassNameCommon
-}
-
-interface ViewTransitionType {
-  (strings: TemplateStringsArray, ...values: CssVariableType[]): Promise<string>
-  (content: Promise<string>): Promise<string>
-  (): Promise<string>
-}
-
-interface StyleType {
-  (args?: { children?: Promise<string> }): HtmlEscapedString
-}
-
-/**
- * @experimental
- * `createCssContext` is an experimental feature.
- * The API might be changed.
- */
-export const createCssContext = ({ id }: { id: Readonly<string> }): DefaultContextType => {
-  const [cssJsxDomObject, StyleRenderToDom] = createCssJsxDomObjects({ id })
-
-  const contextMap: WeakMap<object, usedClassNameData> = new WeakMap()
-
-  const replaceStyleRe = new RegExp(`(<style id="${id}">.*?)(</style>)`)
-
-  const newCssClassNameObject = (cssClassName: CssClassNameCommon): Promise<string> => {
-    const appendStyle: HtmlEscapedCallback = ({ buffer, context }): Promise<string> | undefined => {
-      const [toAdd, added] = contextMap.get(context) as usedClassNameData
-      const names = Object.keys(toAdd)
-
-      if (!names.length) {
-        return
-      }
-
-      let stylesStr = ''
-      names.forEach((className) => {
-        added[className] = true
-        stylesStr += className.startsWith(PSEUDO_GLOBAL_SELECTOR)
-          ? toAdd[className]
-          : `${className[0] === '@' ? '' : '.'}${className}{${toAdd[className]}}`
-      })
-      contextMap.set(context, [{}, added])
-
-      if (buffer && replaceStyleRe.test(buffer[0])) {
-        buffer[0] = buffer[0].replace(replaceStyleRe, (_, pre, post) => `${pre}${stylesStr}${post}`)
-        return
-      }
-
-      const appendStyleScript = `<script>document.querySelector('#${id}').textContent+=${JSON.stringify(
-        stylesStr
-      )}</script>`
-      if (buffer) {
-        buffer[0] = `${appendStyleScript}${buffer[0]}`
-        return
-      }
-
-      return Promise.resolve(appendStyleScript)
-    }
-
-    const addClassNameToContext: HtmlEscapedCallback = ({ context }) => {
-      if (!contextMap.get(context)) {
-        contextMap.set(context, [{}, {}])
-      }
-      const [toAdd, added] = contextMap.get(context) as usedClassNameData
-      let allAdded = true
-      if (!added[cssClassName[SELECTOR]]) {
-        allAdded = false
-        toAdd[cssClassName[SELECTOR]] = cssClassName[STYLE_STRING]
-      }
-      cssClassName[SELECTORS].forEach(
-        ({ [CLASS_NAME]: className, [STYLE_STRING]: styleString }) => {
-          if (!added[className]) {
-            allAdded = false
-            toAdd[className] = styleString
-          }
-        }
-      )
-      if (allAdded) {
-        return
-      }
-
-      return Promise.resolve(raw('', [appendStyle]))
-    }
-
-    const className = new String(cssClassName[CLASS_NAME]) as CssClassName
-    Object.assign(className, cssClassName)
-    ;(className as HtmlEscapedString).isEscaped = true
-    ;(className as HtmlEscapedString).callbacks = [addClassNameToContext]
-    const promise = Promise.resolve(className)
-    Object.assign(promise, cssClassName)
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    promise.toString = cssJsxDomObject.toString
-    return promise
-  }
-
-  const css: CssType = (strings, ...values) => {
-    return newCssClassNameObject(cssCommon(strings, values))
-  }
-
-  const cx: CxType = (...args) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    args = cxCommon(args as any) as any
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return css(Array(args.length).fill('') as any, ...args)
-  }
-
-  const keyframes = keyframesCommon
-
-  const viewTransition: ViewTransitionType = ((
-    strings: TemplateStringsArray | Promise<string> | undefined,
-    ...values: CssVariableType[]
-  ) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return newCssClassNameObject(viewTransitionCommon(strings as any, values))
-  }) as ViewTransitionType
-
-  const Style: StyleType = ({ children } = {}) =>
-    children
-      ? raw(`<style id="${id}">${(children as unknown as CssClassName)[STYLE_STRING]}</style>`)
-      : raw(`<style id="${id}"></style>`)
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ;(Style as any)[DOM_RENDERER] = StyleRenderToDom
-
-  return {
-    css,
-    cx,
-    keyframes,
-    viewTransition: viewTransition as ViewTransitionType,
-    Style,
-  }
-}
-
-interface DefaultContextType {
-  css: CssType
-  cx: CxType
-  keyframes: KeyframesType
-  viewTransition: ViewTransitionType
-  Style: StyleType
-}
-
-const defaultContext: DefaultContextType = createCssContext({
-  id: DEFAULT_STYLE_ID,
-})
-
-/**
- * @experimental
- * `css` is an experimental feature.
- * The API might be changed.
- */
-export const css = defaultContext.css
-
-/**
- * @experimental
- * `cx` is an experimental feature.
- * The API might be changed.
- */
-export const cx = defaultContext.cx
-
-/**
- * @experimental
- * `keyframes` is an experimental feature.
- * The API might be changed.
- */
-export const keyframes = defaultContext.keyframes
-
-/**
- * @experimental
- * `viewTransition` is an experimental feature.
- * The API might be changed.
- */
-export const viewTransition = defaultContext.viewTransition
-
-/**
- * @experimental
- * `Style` is an experimental feature.
- * The API might be changed.
- */
-export const Style = defaultContext.Style

package/tests/fixtures/corpus/oss-repos/hono/src/helper/dev/index.ts

@@ -1,79 +0,0 @@
-/**
- * @module
- * Dev Helper for Hono.
- */
-
-import type { Hono } from '../../hono'
-import type { Env, RouterRoute } from '../../types'
-import { getColorEnabled } from '../../utils/color'
-import { findTargetHandler, isMiddleware } from '../../utils/handler'
-
-interface ShowRoutesOptions {
-  verbose?: boolean
-  colorize?: boolean
-}
-
-interface RouteData {
-  path: string
-  method: string
-  name: string
-  isMiddleware: boolean
-}
-
-const handlerName = (handler: Function): string => {
-  return handler.name || (isMiddleware(handler) ? '[middleware]' : '[handler]')
-}
-
-export const inspectRoutes = <E extends Env>(hono: Hono<E>): RouteData[] => {
-  return hono.routes.map(({ path, method, handler }: RouterRoute) => {
-    const targetHandler = findTargetHandler(handler)
-    return {
-      path,
-      method,
-      name: handlerName(targetHandler),
-      isMiddleware: isMiddleware(targetHandler),
-    }
-  })
-}
-
-export const showRoutes = <E extends Env>(hono: Hono<E>, opts?: ShowRoutesOptions): void => {
-  const colorEnabled = opts?.colorize ?? getColorEnabled()
-  const routeData: Record<string, RouteData[]> = {}
-  let maxMethodLength = 0
-  let maxPathLength = 0
-
-  inspectRoutes(hono)
-    .filter(({ isMiddleware }) => opts?.verbose || !isMiddleware)
-    .map((route) => {
-      const key = `${route.method}-${route.path}`
-      ;(routeData[key] ||= []).push(route)
-      if (routeData[key].length > 1) {
-        return
-      }
-      maxMethodLength = Math.max(maxMethodLength, route.method.length)
-      maxPathLength = Math.max(maxPathLength, route.path.length)
-      return { method: route.method, path: route.path, routes: routeData[key] }
-    })
-    .forEach((data) => {
-      if (!data) {
-        return
-      }
-      const { method, path, routes } = data
-
-      const methodStr = colorEnabled ? `\x1b[32m${method}\x1b[0m` : method
-      console.log(`${methodStr} ${' '.repeat(maxMethodLength - method.length)} ${path}`)
-
-      if (!opts?.verbose) {
-        return
-      }
-
-      routes.forEach(({ name }) => {
-        console.log(`${' '.repeat(maxMethodLength + 3)} ${name}`)
-      })
-    })
-}
-
-export const getRouterName = <E extends Env>(app: Hono<E>): string => {
-  app.router.match('GET', '/')
-  return app.router.name
-}

package/tests/fixtures/corpus/oss-repos/hono/src/helper/factory/index.ts

@@ -1,246 +0,0 @@
-/**
- * @module
- * Factory Helper for Hono.
- */
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Hono } from '../../hono'
-import type { Env, H, HandlerResponse, Input, MiddlewareHandler } from '../../types'
-
-type InitApp<E extends Env = Env> = (app: Hono<E>) => void
-
-export interface CreateHandlersInterface<E extends Env, P extends string> {
-  <I extends Input = {}, R extends HandlerResponse<any> = any>(
-    handler1: H<E, P, I, R>
-  ): [H<E, P, I, R>]
-  // handler x2
-  <I extends Input = {}, I2 extends Input = I, R extends HandlerResponse<any> = any>(
-    handler1: H<E, P, I, R>,
-    handler2: H<E, P, I2, R>
-  ): [H<E, P, I, R>, H<E, P, I2, R>]
-
-  // handler x3
-  <
-    I extends Input = {},
-    I2 extends Input = I,
-    I3 extends Input = I & I2,
-    R extends HandlerResponse<any> = any,
-  >(
-    handler1: H<E, P, I, R>,
-    handler2: H<E, P, I2, R>,
-    handler3: H<E, P, I3, R>
-  ): [H<E, P, I, R>, H<E, P, I2, R>, H<E, P, I3, R>]
-
-  // handler x4
-  <
-    I extends Input = {},
-    I2 extends Input = I,
-    I3 extends Input = I & I2,
-    I4 extends Input = I & I2 & I3,
-    R extends HandlerResponse<any> = any,
-  >(
-    handler1: H<E, P, I, R>,
-    handler2: H<E, P, I2, R>,
-    handler3: H<E, P, I3, R>,
-    handler4: H<E, P, I4, R>
-  ): [H<E, P, I, R>, H<E, P, I2, R>, H<E, P, I3, R>, H<E, P, I4, R>]
-
-  // handler x5
-  <
-    I extends Input = {},
-    I2 extends Input = I,
-    I3 extends Input = I & I2,
-    I4 extends Input = I & I2 & I3,
-    I5 extends Input = I & I2 & I3 & I4,
-    R extends HandlerResponse<any> = any,
-  >(
-    handler1: H<E, P, I, R>,
-    handler2: H<E, P, I2, R>,
-    handler3: H<E, P, I3, R>,
-    handler4: H<E, P, I4, R>,
-    handler5: H<E, P, I5, R>
-  ): [H<E, P, I, R>, H<E, P, I2, R>, H<E, P, I3, R>, H<E, P, I4, R>, H<E, P, I5, R>]
-
-  // handler x6
-  <
-    I extends Input = {},
-    I2 extends Input = I,
-    I3 extends Input = I & I2,
-    I4 extends Input = I & I2 & I3,
-    I5 extends Input = I & I2 & I3 & I4,
-    I6 extends Input = I & I2 & I3 & I4 & I5,
-    R extends HandlerResponse<any> = any,
-  >(
-    handler1: H<E, P, I, R>,
-    handler2: H<E, P, I2, R>,
-    handler3: H<E, P, I3, R>,
-    handler4: H<E, P, I4, R>,
-    handler5: H<E, P, I5, R>,
-    handler6: H<E, P, I6, R>
-  ): [H<E, P, I, R>, H<E, P, I2, R>, H<E, P, I3, R>, H<E, P, I4, R>, H<E, P, I5, R>, H<E, P, I6, R>]
-
-  // handler x7
-  <
-    I extends Input = {},
-    I2 extends Input = I,
-    I3 extends Input = I & I2,
-    I4 extends Input = I & I2 & I3,
-    I5 extends Input = I & I2 & I3 & I4,
-    I6 extends Input = I & I2 & I3 & I4 & I5,
-    I7 extends Input = I & I2 & I3 & I4 & I5 & I6,
-    R extends HandlerResponse<any> = any,
-  >(
-    handler1: H<E, P, I, R>,
-    handler2: H<E, P, I2, R>,
-    handler3: H<E, P, I3, R>,
-    handler4: H<E, P, I4, R>,
-    handler5: H<E, P, I5, R>,
-    handler6: H<E, P, I6, R>,
-    handler7: H<E, P, I7, R>
-  ): [
-    H<E, P, I, R>,
-    H<E, P, I2, R>,
-    H<E, P, I3, R>,
-    H<E, P, I4, R>,
-    H<E, P, I5, R>,
-    H<E, P, I6, R>,
-    H<E, P, I7, R>,
-  ]
-
-  // handler x8
-  <
-    I extends Input = {},
-    I2 extends Input = I,
-    I3 extends Input = I & I2,
-    I4 extends Input = I & I2 & I3,
-    I5 extends Input = I & I2 & I3 & I4,
-    I6 extends Input = I & I2 & I3 & I4 & I5,
-    I7 extends Input = I & I2 & I3 & I4 & I5 & I6,
-    I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7,
-    R extends HandlerResponse<any> = any,
-  >(
-    handler1: H<E, P, I, R>,
-    handler2: H<E, P, I2, R>,
-    handler3: H<E, P, I3, R>,
-    handler4: H<E, P, I4, R>,
-    handler5: H<E, P, I5, R>,
-    handler6: H<E, P, I6, R>,
-    handler7: H<E, P, I7, R>,
-    handler8: H<E, P, I8, R>
-  ): [
-    H<E, P, I, R>,
-    H<E, P, I2, R>,
-    H<E, P, I3, R>,
-    H<E, P, I4, R>,
-    H<E, P, I5, R>,
-    H<E, P, I6, R>,
-    H<E, P, I7, R>,
-    H<E, P, I8, R>,
-  ]
-
-  // handler x9
-  <
-    I extends Input = {},
-    I2 extends Input = I,
-    I3 extends Input = I & I2,
-    I4 extends Input = I & I2 & I3,
-    I5 extends Input = I & I2 & I3 & I4,
-    I6 extends Input = I & I2 & I3 & I4 & I5,
-    I7 extends Input = I & I2 & I3 & I4 & I5 & I6,
-    I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7,
-    I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8,
-    R extends HandlerResponse<any> = any,
-  >(
-    handler1: H<E, P, I, R>,
-    handler2: H<E, P, I2, R>,
-    handler3: H<E, P, I3, R>,
-    handler4: H<E, P, I4, R>,
-    handler5: H<E, P, I5, R>,
-    handler6: H<E, P, I6, R>,
-    handler7: H<E, P, I7, R>,
-    handler8: H<E, P, I8, R>,
-    handler9: H<E, P, I9, R>
-  ): [
-    H<E, P, I, R>,
-    H<E, P, I2, R>,
-    H<E, P, I3, R>,
-    H<E, P, I4, R>,
-    H<E, P, I5, R>,
-    H<E, P, I6, R>,
-    H<E, P, I7, R>,
-    H<E, P, I8, R>,
-    H<E, P, I9, R>,
-  ]
-
-  // handler x10
-  <
-    I extends Input = {},
-    I2 extends Input = I,
-    I3 extends Input = I & I2,
-    I4 extends Input = I & I2 & I3,
-    I5 extends Input = I & I2 & I3 & I4,
-    I6 extends Input = I & I2 & I3 & I4 & I5,
-    I7 extends Input = I & I2 & I3 & I4 & I5 & I6,
-    I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7,
-    I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8,
-    I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9,
-    R extends HandlerResponse<any> = any,
-  >(
-    handler1: H<E, P, I, R>,
-    handler2: H<E, P, I2, R>,
-    handler3: H<E, P, I3, R>,
-    handler4: H<E, P, I4, R>,
-    handler5: H<E, P, I5, R>,
-    handler6: H<E, P, I6, R>,
-    handler7: H<E, P, I7, R>,
-    handler8: H<E, P, I8, R>,
-    handler9: H<E, P, I9, R>,
-    handler10: H<E, P, I10, R>
-  ): [
-    H<E, P, I, R>,
-    H<E, P, I2, R>,
-    H<E, P, I3, R>,
-    H<E, P, I4, R>,
-    H<E, P, I5, R>,
-    H<E, P, I6, R>,
-    H<E, P, I7, R>,
-    H<E, P, I8, R>,
-    H<E, P, I9, R>,
-    H<E, P, I10, R>,
-  ]
-}
-
-export class Factory<E extends Env = any, P extends string = any> {
-  private initApp?: InitApp<E>
-
-  constructor(init?: { initApp?: InitApp<E> }) {
-    this.initApp = init?.initApp
-  }
-
-  createApp = (): Hono<E> => {
-    const app = new Hono<E>()
-    if (this.initApp) {
-      this.initApp(app)
-    }
-    return app
-  }
-
-  createMiddleware = <I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => middleware
-
-  createHandlers: CreateHandlersInterface<E, P> = (...handlers: any) => {
-    // @ts-expect-error this should not be typed
-    return handlers.filter((handler) => handler !== undefined)
-  }
-}
-
-export const createFactory = <E extends Env = any, P extends string = any>(init?: {
-  initApp?: InitApp<E>
-}): Factory<E, P> => new Factory<E, P>(init)
-
-export const createMiddleware = <
-  E extends Env = any,
-  P extends string = string,
-  I extends Input = {},
->(
-  middleware: MiddlewareHandler<E, P, I>
-): MiddlewareHandler<E, P, I> => createFactory<E, P>().createMiddleware<I>(middleware)

package/tests/fixtures/corpus/oss-repos/hono/src/helper/html/index.ts

@@ -1,56 +0,0 @@
-/**
- * @module
- * html Helper for Hono.
- */
-
-import { escapeToBuffer, raw, resolveCallbackSync, stringBufferToString } from '../../utils/html'
-import type { HtmlEscaped, HtmlEscapedString, StringBufferWithCallbacks } from '../../utils/html'
-
-export { raw }
-
-export const html = (
-  strings: TemplateStringsArray,
-  ...values: unknown[]
-): HtmlEscapedString | Promise<HtmlEscapedString> => {
-  const buffer: StringBufferWithCallbacks = [''] as StringBufferWithCallbacks
-
-  for (let i = 0, len = strings.length - 1; i < len; i++) {
-    buffer[0] += strings[i]
-
-    const children =
-      values[i] instanceof Array ? (values[i] as Array<unknown>).flat(Infinity) : [values[i]]
-    for (let i = 0, len = children.length; i < len; i++) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const child = children[i] as any
-      if (typeof child === 'string') {
-        escapeToBuffer(child, buffer)
-      } else if (typeof child === 'number') {
-        ;(buffer[0] as string) += child
-      } else if (typeof child === 'boolean' || child === null || child === undefined) {
-        continue
-      } else if (typeof child === 'object' && (child as HtmlEscaped).isEscaped) {
-        if ((child as HtmlEscapedString).callbacks) {
-          buffer.unshift('', child)
-        } else {
-          const tmp = child.toString()
-          if (tmp instanceof Promise) {
-            buffer.unshift('', tmp)
-          } else {
-            buffer[0] += tmp
-          }
-        }
-      } else if (child instanceof Promise) {
-        buffer.unshift('', child)
-      } else {
-        escapeToBuffer(child.toString(), buffer)
-      }
-    }
-  }
-  buffer[0] += strings[strings.length - 1]
-
-  return buffer.length === 1
-    ? 'callbacks' in buffer
-      ? raw(resolveCallbackSync(raw(buffer[0], buffer.callbacks)))
-      : raw(buffer[0])
-    : stringBufferToString(buffer, buffer.callbacks)
-}

package/tests/fixtures/corpus/oss-repos/hono/src/helper/ssg/index.ts

@@ -1,13 +0,0 @@
-/**
- * @module
- * SSG Helper for Hono.
- */
-
-export * from './ssg'
-export {
-  X_HONO_DISABLE_SSG_HEADER_KEY,
-  ssgParams,
-  isSSGContext,
-  disableSSG,
-  onlySSG,
-} from './middleware'

package/tests/fixtures/corpus/oss-repos/hono/src/helper/ssg/middleware.ts

@@ -1,79 +0,0 @@
-import type { Context } from '../../context'
-import type { Env, MiddlewareHandler } from '../../types'
-
-export const SSG_CONTEXT = 'HONO_SSG_CONTEXT'
-export const X_HONO_DISABLE_SSG_HEADER_KEY = 'x-hono-disable-ssg'
-
-/**
- * @deprecated
- * Use `X_HONO_DISABLE_SSG_HEADER_KEY` instead.
- * This constant will be removed in the next minor version.
- */
-export const SSG_DISABLED_RESPONSE = (() => {
-  try {
-    return new Response('SSG is disabled', {
-      status: 404,
-      headers: { [X_HONO_DISABLE_SSG_HEADER_KEY]: 'true' },
-    })
-  } catch (e) {
-    return null
-  }
-})() as Response
-
-interface SSGParam {
-  [key: string]: string
-}
-export type SSGParams = SSGParam[]
-
-interface SSGParamsMiddleware {
-  <E extends Env = Env>(
-    generateParams: (c: Context<E>) => SSGParams | Promise<SSGParams>
-  ): MiddlewareHandler<E>
-  <E extends Env = Env>(params: SSGParams): MiddlewareHandler<E>
-}
-
-export type AddedSSGDataRequest = Request & {
-  ssgParams?: SSGParams
-}
-
-/**
- * Define SSG Route
- */
-export const ssgParams: SSGParamsMiddleware = (params) => async (c, next) => {
-  ;(c.req.raw as AddedSSGDataRequest).ssgParams = Array.isArray(params) ? params : await params(c)
-  await next()
-}
-
-/**
- * @experimental
- * `isSSGContext` is an experimental feature.
- * The API might be changed.
- */
-export const isSSGContext = (c: Context): boolean => !!c.env?.[SSG_CONTEXT]
-
-/**
- * @experimental
- * `disableSSG` is an experimental feature.
- * The API might be changed.
- */
-export const disableSSG = (): MiddlewareHandler =>
-  async function disableSSG(c, next) {
-    if (isSSGContext(c)) {
-      c.header(X_HONO_DISABLE_SSG_HEADER_KEY, 'true')
-      return c.notFound()
-    }
-    await next()
-  }
-
-/**
- * @experimental
- * `onlySSG` is an experimental feature.
- * The API might be changed.
- */
-export const onlySSG = (): MiddlewareHandler =>
-  async function onlySSG(c, next) {
-    if (!isSSGContext(c)) {
-      return c.notFound()
-    }
-    await next()
-  }