runonweb 0.0.1

package/src/clean/index.ts

@@ -0,0 +1,263 @@
+import type { Device, ProgressCallback, ProgressInfo } from '../core/index.ts'
+import { loadPipeline } from '../core/pipeline.ts'
+
+/**
+ * Default weights: Superwhisper S1-mini as ONNX (Qwen3-0.6B fine-tune).
+ * q4f16 on WebGPU (~339 MB) · q4 on WASM (~385 MB).
+ */
+export const DEFAULT_MODEL = 'onnx-community/s1-mini-ONNX'
+
+/** Exact system prompt S1-mini was trained with. Do not reword. */
+export const SYSTEM_PROMPT =
+  'You are a text normalizer for speech-to-text transcripts. The input begins ' +
+  'with a control line specifying the styling, structure, and context settings; ' +
+  'clean the transcript to match those settings and output only the cleaned text.'
+
+export const STYLING = ['casual', 'semi-casual', 'semi-formal', 'formal'] as const
+export const STRUCTURE = ['prose', 'lists'] as const
+export const CONTEXT = ['general', 'email'] as const
+
+export type Styling = (typeof STYLING)[number]
+export type Structure = (typeof STRUCTURE)[number]
+export type Context = (typeof CONTEXT)[number]
+
+export type CleanOptions = {
+  /** Hugging Face model id. Defaults to `onnx-community/s1-mini-ONNX`. */
+  model?: string
+  device?: Device
+  /** Written register. Default `semi-formal`. */
+  styling?: Styling
+  /** `lists` may emit Markdown bullets when there are 3+ items. Default `prose`. */
+  structure?: Structure
+  /** `email` adds greeting / body / sign-off layout. Default `general`. */
+  context?: Context
+  onProgress?: ProgressCallback
+}
+
+export type CleanRunOptions = {
+  styling?: Styling
+  structure?: Structure
+  context?: Context
+  /** Incremental decoded tokens as they arrive (think-block stripped). */
+  onPartial?: (text: string) => void
+}
+
+export type CleanResult = {
+  /** Cleaned written text. Empty when the input was only filler or noise. */
+  text: string
+}
+
+type Tokenizer = {
+  apply_chat_template: (messages: unknown, opts: Record<string, unknown>) => string
+  (text: string): { input_ids?: { size?: number; dims?: number[] } }
+}
+
+type GenPipe = CallableFunction & {
+  tokenizer?: Tokenizer
+  dispose?: () => Promise<void>
+}
+
+const THINK_BLOCK = /<think>[\s\S]*?<\/think>\s*/g
+
+function controlLine(styling: Styling, structure: Structure, context: Context): string {
+  return `[Styling: ${styling}] [Structure: ${structure}] [Context: ${context}]`
+}
+
+function tokenCount(tokenizer: Tokenizer | undefined, text: string): number {
+  if (!tokenizer) return Math.max(8, text.split(/\s+/).length)
+  const ids = tokenizer(text).input_ids
+  return ids?.dims?.at(-1) ?? ids?.size ?? Math.max(8, text.split(/\s+/).length)
+}
+
+function stripThink(text: string): string {
+  return text.replace(THINK_BLOCK, '').trim()
+}
+
+function generatedText(raw: unknown): string {
+  if (typeof raw === 'string') return raw
+  if (Array.isArray(raw)) return generatedText(raw[0])
+  if (raw && typeof raw === 'object' && 'generated_text' in raw) {
+    const g = (raw as { generated_text: unknown }).generated_text
+    if (typeof g === 'string') return g
+    if (Array.isArray(g)) {
+      const last = g.at(-1) as { content?: string } | undefined
+      if (typeof last?.content === 'string') return last.content
+    }
+  }
+  return ''
+}
+
+/**
+ * Clean a raw speech-to-text transcript in the browser (S1-mini by Superwhisper).
+ *
+ * @example
+ * ```ts
+ * import { TranscriptCleaner } from 'runonweb/clean'
+ *
+ * const cleaner = new TranscriptCleaner()
+ * await cleaner.load()
+ *
+ * const { text } = await cleaner.clean(
+ *   'so um i need to like send the the report by uh friday no wait make that thursday'
+ * )
+ * // "I need to send the report by Thursday."
+ * ```
+ */
+export class TranscriptCleaner {
+  #model: string
+  #device: Device
+  #styling: Styling
+  #structure: Structure
+  #context: Context
+  #onProgress?: ProgressCallback
+  #pipe: GenPipe | null = null
+  #loading: Promise<void> | null = null
+  #resolvedDevice: 'webgpu' | 'wasm' | null = null
+
+  constructor(options: CleanOptions = {}) {
+    this.#model = options.model ?? DEFAULT_MODEL
+    this.#device = options.device ?? 'auto'
+    this.#styling = options.styling ?? 'semi-formal'
+    this.#structure = options.structure ?? 'prose'
+    this.#context = options.context ?? 'general'
+    this.#onProgress = options.onProgress
+  }
+
+  get device(): 'webgpu' | 'wasm' | null {
+    return this.#resolvedDevice
+  }
+
+  async load(): Promise<void> {
+    if (this.#pipe) return
+    if (this.#loading) return this.#loading
+
+    this.#loading = (async () => {
+      const attempts =
+        this.#device === 'wasm'
+          ? [{ device: 'wasm' as const, dtype: 'q4' as const }]
+          : this.#device === 'webgpu'
+            ? [
+                { device: 'webgpu' as const, dtype: 'q4f16' as const },
+                { device: 'webgpu' as const, dtype: 'q4' as const },
+              ]
+            : [
+                { device: 'webgpu' as const, dtype: 'q4f16' as const },
+                { device: 'webgpu' as const, dtype: 'q4' as const },
+                { device: 'wasm' as const, dtype: 'q4' as const },
+              ]
+
+      let lastError: unknown
+      for (const attempt of attempts) {
+        try {
+          const { pipe, device } = await loadPipeline({
+            task: 'text-generation',
+            model: this.#model,
+            device: attempt.device,
+            // q4f16 matches the official WebGPU demo; q4 is the compatible fallback.
+            dtype: attempt.dtype,
+            supportedDevices: [attempt.device],
+            onProgress: this.#onProgress,
+          })
+          this.#pipe = pipe
+          this.#resolvedDevice = device
+          return
+        } catch (err) {
+          lastError = err
+        }
+      }
+      const message = lastError instanceof Error ? lastError.message : String(lastError)
+      throw new Error(
+        /^\d+$/.test(message)
+          ? `Could not start S1-mini on this device (${message}). Try again or pass device: "wasm".`
+          : message
+      )
+    })()
+
+    try {
+      await this.#loading
+    } finally {
+      this.#loading = null
+    }
+  }
+
+  /**
+   * Rewrite a raw ASR transcript as clean written text.
+   * Empty / whitespace-only input throws. Filler-only input returns `{ text: "" }`.
+   */
+  async clean(text: string, options: CleanRunOptions = {}): Promise<CleanResult> {
+    await this.load()
+    if (!this.#pipe) throw new Error('Cleaner model failed to load')
+    if (!text.trim()) throw new Error('Text is empty')
+
+    const styling = options.styling ?? this.#styling
+    const structure = options.structure ?? this.#structure
+    const context = options.context ?? this.#context
+    const tokenizer = this.#pipe.tokenizer
+
+    const messages = [
+      { role: 'system', content: SYSTEM_PROMPT },
+      { role: 'user', content: `${controlLine(styling, structure, context)}\n${text}` },
+    ]
+
+    // S1-mini was trained with thinking off. The pipeline does not pass this flag,
+    // so the chat template must be applied here or the model emits an empty think block.
+    const prompt = tokenizer
+      ? tokenizer.apply_chat_template(messages, {
+          tokenize: false,
+          add_generation_prompt: true,
+          enable_thinking: false,
+        })
+      : `${SYSTEM_PROMPT}\n${controlLine(styling, structure, context)}\n${text}`
+
+    const maxNewTokens = Math.min(1024, Math.max(64, Math.ceil(tokenCount(tokenizer, text) * 1.3) + 32))
+
+    this.#onProgress?.({ status: 'cleaning' })
+
+    let streamed = ''
+    let streamer: unknown
+    if (options.onPartial && tokenizer) {
+      const { TextStreamer } = await import('@huggingface/transformers')
+      streamer = new TextStreamer(tokenizer as never, {
+        skip_prompt: true,
+        skip_special_tokens: true,
+        callback_function: (chunk: string) => {
+          streamed += chunk
+          options.onPartial?.(stripThink(streamed))
+        },
+      })
+    }
+
+    const raw = await this.#pipe(prompt, {
+      max_new_tokens: maxNewTokens,
+      do_sample: false,
+      return_full_text: false,
+      ...(streamer ? { streamer } : {}),
+    })
+
+    const result = stripThink(generatedText(raw) || streamed)
+
+    this.#onProgress?.({ status: 'done' })
+    return { text: result }
+  }
+
+  dispose(): void {
+    const pipe = this.#pipe
+    this.#pipe = null
+    this.#resolvedDevice = null
+    void pipe?.dispose?.()
+  }
+}
+
+export async function clean(
+  text: string,
+  options?: CleanOptions & CleanRunOptions
+): Promise<CleanResult> {
+  const cleaner = new TranscriptCleaner(options)
+  try {
+    return await cleaner.clean(text, options)
+  } finally {
+    cleaner.dispose()
+  }
+}
+
+export type { ProgressInfo, Device }

package/src/core/cache.ts

@@ -0,0 +1,248 @@
+/**
+ * Inspect and clear the model weights Transformers.js stores in the browser's Cache Storage.
+ * Everything runonweb downloads lives in the `transformers-cache` bucket, keyed by the
+ * Hugging Face URL, so a model id maps to a set of cached requests.
+ */
+
+export const CACHE_NAME = 'transformers-cache'
+
+/** Cache Storage bucket used by `runonweb/translate` for Firefox Translations models. */
+export const TRANSLATE_CACHE_NAME = 'runonweb-translate'
+
+/** Cache Storage bucket used by Bonsai Image (range-request leftovers). */
+export const BONSAI_CACHE_NAME = 'bonsai-pipeline-v1'
+/** IndexedDB used by the Bonsai Image WebGPU engine for safetensor chunks. */
+export const BONSAI_IDB_NAME = 'bonsai-image-v1'
+
+const EXTRA_CACHE_NAMES = [BONSAI_CACHE_NAME, TRANSLATE_CACHE_NAME]
+
+export type CachedFile = {
+  url: string
+  /** Path inside the repo, e.g. `onnx/encoder_model_fp16.onnx`. */
+  path: string
+  bytes: number
+}
+
+export type CachedModel = {
+  /** Hugging Face repo id, e.g. `onnx-community/whisper-tiny.en`. */
+  id: string
+  files: CachedFile[]
+  bytes: number
+}
+
+const HF_RE = /^https?:\/\/[^/]+\/(?:datasets\/)?([^/]+\/[^/]+)\/resolve\/[^/]+\/(.+)$/
+/** `<base>/<from>-<to>/<model|lex|vocab file>?rev=…` as written by `runonweb/translate`. */
+const TRANSLATE_RE = /\/([a-z]{2,3}(?:-Han[st])?-[a-z]{2,3}(?:-Han[st])?)\/((?:model|lex|vocab|srcvocab|trgvocab)\.[^/?]+)(?:\?.*)?$/
+
+/** Split a cached request URL into a model id and a path inside it. */
+function identify(url: string): { id: string; path: string } {
+  const t = TRANSLATE_RE.exec(url)
+  if (t) return { id: `firefox-translations/${t[1]}`, path: t[2] }
+  const m = HF_RE.exec(url)
+  return { id: m?.[1] ?? 'other', path: m?.[2] ?? url }
+}
+
+function cachesAvailable(): boolean {
+  return typeof caches !== 'undefined'
+}
+
+async function responseSize(res: Response): Promise<number> {
+  const len = res.headers.get('content-length')
+  if (len && Number(len) > 0) return Number(len)
+  try {
+    return (await res.clone().blob()).size
+  } catch {
+    return 0
+  }
+}
+
+async function collectCacheBucket(cacheName: string, byModel: Map<string, CachedModel>): Promise<void> {
+  if (!cachesAvailable()) return
+  let cache: Cache
+  try {
+    cache = await caches.open(cacheName)
+  } catch {
+    return
+  }
+  const requests = await cache.keys()
+  for (const req of requests) {
+    const { id, path } = identify(req.url)
+    const res = await cache.match(req)
+    const bytes = res ? await responseSize(res) : 0
+    const entry = byModel.get(id) ?? { id, files: [], bytes: 0 }
+    entry.files.push({ url: req.url, path, bytes })
+    entry.bytes += bytes
+    byModel.set(id, entry)
+  }
+}
+
+async function idbExists(name: string): Promise<boolean> {
+  if (typeof indexedDB === 'undefined' || !indexedDB.databases) return false
+  try {
+    const dbs = await indexedDB.databases()
+    return dbs.some((db) => db.name === name)
+  } catch {
+    return false
+  }
+}
+
+/** Sum Bonsai Image chunks stored in IndexedDB (the engine's real weight cache). */
+async function listBonsaiIndexedDb(): Promise<CachedModel | null> {
+  if (typeof indexedDB === 'undefined') return null
+  if (!(await idbExists(BONSAI_IDB_NAME))) return null
+
+  return new Promise((resolve) => {
+    const req = indexedDB.open(BONSAI_IDB_NAME)
+    req.onerror = () => resolve(null)
+    req.onsuccess = () => {
+      const db = req.result
+      if (!db.objectStoreNames.contains('chunks')) {
+        db.close()
+        resolve(null)
+        return
+      }
+      const names = [...db.objectStoreNames]
+      const tx = db.transaction(names, 'readonly')
+      let bytes = 0
+      let id = 'prism-ml/bonsai-image'
+
+      if (names.includes('meta')) {
+        const keysReq = tx.objectStore('meta').getAllKeys()
+        keysReq.onsuccess = () => {
+          for (const key of keysReq.result) {
+            const m = HF_RE.exec(String(key))
+            if (m?.[1]) {
+              id = m[1]
+              break
+            }
+          }
+        }
+      }
+
+      const cursorReq = tx.objectStore('chunks').openCursor()
+      cursorReq.onsuccess = () => {
+        const cursor = cursorReq.result
+        if (!cursor) return
+        const value = cursor.value as unknown
+        if (value instanceof Blob) bytes += value.size
+        else if (value instanceof ArrayBuffer) bytes += value.byteLength
+        cursor.continue()
+      }
+
+      tx.oncomplete = () => {
+        db.close()
+        resolve(
+          bytes > 0
+            ? { id, files: [{ url: `indexeddb://${BONSAI_IDB_NAME}`, path: 'chunks', bytes }], bytes }
+            : null
+        )
+      }
+      tx.onerror = () => {
+        db.close()
+        resolve(null)
+      }
+    }
+  })
+}
+
+/** List every model cached in this origin, largest first. */
+export async function listCachedModels(): Promise<CachedModel[]> {
+  const byModel = new Map<string, CachedModel>()
+  await collectCacheBucket(CACHE_NAME, byModel)
+  for (const name of EXTRA_CACHE_NAMES) {
+    await collectCacheBucket(name, byModel)
+  }
+
+  const bonsai = await listBonsaiIndexedDb()
+  if (bonsai) {
+    const existing = byModel.get(bonsai.id)
+    if (existing) {
+      existing.files.push(...bonsai.files)
+      existing.bytes += bonsai.bytes
+    } else {
+      byModel.set(bonsai.id, bonsai)
+    }
+  }
+
+  return [...byModel.values()].sort((a, b) => b.bytes - a.bytes)
+}
+
+async function deleteIndexedDb(name: string): Promise<boolean> {
+  if (typeof indexedDB === 'undefined') return false
+  if (!(await idbExists(name))) return false
+  return new Promise((resolve) => {
+    const req = indexedDB.deleteDatabase(name)
+    req.onsuccess = () => resolve(true)
+    req.onerror = () => resolve(false)
+    req.onblocked = () => resolve(true)
+  })
+}
+
+async function clearCacheBucketForModel(cacheName: string, modelId: string): Promise<number> {
+  if (!cachesAvailable()) return 0
+  let cache: Cache
+  try {
+    cache = await caches.open(cacheName)
+  } catch {
+    return 0
+  }
+  let removed = 0
+  for (const req of await cache.keys()) {
+    if (identify(req.url).id === modelId && (await cache.delete(req))) removed++
+  }
+  return removed
+}
+
+/** Delete the cached files of one model. Returns the number of entries removed. */
+export async function clearModelCache(modelId: string): Promise<number> {
+  let removed = await clearCacheBucketForModel(CACHE_NAME, modelId)
+  for (const name of EXTRA_CACHE_NAMES) {
+    removed += await clearCacheBucketForModel(name, modelId)
+  }
+  if (modelId.includes('bonsai-image') && (await deleteIndexedDb(BONSAI_IDB_NAME))) {
+    removed += 1
+  }
+  return removed
+}
+
+/** Delete every cached model. Returns the number of entries removed. */
+export async function clearAllModelCache(): Promise<number> {
+  let removed = 0
+  if (cachesAvailable()) {
+    for (const name of [CACHE_NAME, ...EXTRA_CACHE_NAMES]) {
+      try {
+        const cache = await caches.open(name)
+        removed += (await cache.keys()).length
+        await caches.delete(name)
+      } catch {
+        // Bucket may not exist.
+      }
+    }
+  }
+  if (await deleteIndexedDb(BONSAI_IDB_NAME)) removed += 1
+  return removed
+}
+
+/** Bytes used / available for this origin, when the browser reports it. */
+export async function storageEstimate(): Promise<{ usage: number; quota: number } | null> {
+  try {
+    const est = await navigator.storage?.estimate?.()
+    if (!est) return null
+    return { usage: est.usage ?? 0, quota: est.quota ?? 0 }
+  } catch {
+    return null
+  }
+}
+
+/** Human-readable bytes: 23 MB, 1.2 GB. */
+export function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`
+  const units = ['KB', 'MB', 'GB']
+  let v = bytes / 1024
+  let i = 0
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024
+    i++
+  }
+  return `${v < 10 ? v.toFixed(1) : Math.round(v)} ${units[i]}`
+}

package/src/core/device.ts

@@ -0,0 +1,34 @@
+export type Device = 'webgpu' | 'wasm' | 'auto'
+export type ResolvedDevice = 'webgpu' | 'wasm'
+
+let webgpuCache: boolean | null = null
+
+/**
+ * Detect whether WebGPU is available in this environment.
+ * Result is cached after the first successful check.
+ */
+export async function isWebGPUAvailable(): Promise<boolean> {
+  if (webgpuCache !== null) return webgpuCache
+
+  try {
+    const gpu = (globalThis as { navigator?: { gpu?: GPU } }).navigator?.gpu
+    if (!gpu) {
+      webgpuCache = false
+      return false
+    }
+    const adapter = await gpu.requestAdapter()
+    webgpuCache = adapter != null
+    return webgpuCache
+  } catch {
+    webgpuCache = false
+    return false
+  }
+}
+
+/**
+ * Resolve `auto` to `webgpu` when available, otherwise `wasm`.
+ */
+export async function resolveDevice(device: Device = 'auto'): Promise<ResolvedDevice> {
+  if (device === 'webgpu' || device === 'wasm') return device
+  return (await isWebGPUAvailable()) ? 'webgpu' : 'wasm'
+}

package/src/core/index.ts

@@ -0,0 +1,18 @@
+export type { Device, ResolvedDevice } from './device.ts'
+export { isWebGPUAvailable, resolveDevice } from './device.ts'
+
+export type { ProgressInfo, ProgressCallback } from './progress.ts'
+export { toProgressInfo } from './progress.ts'
+
+export type { CachedFile, CachedModel } from './cache.ts'
+export {
+  CACHE_NAME,
+  TRANSLATE_CACHE_NAME,
+  BONSAI_CACHE_NAME,
+  BONSAI_IDB_NAME,
+  clearAllModelCache,
+  clearModelCache,
+  formatBytes,
+  listCachedModels,
+  storageEstimate,
+} from './cache.ts'

package/src/core/pipeline.ts

@@ -0,0 +1,108 @@
+import {
+  resolveDevice,
+  toProgressInfo,
+  type Device,
+  type ProgressCallback,
+  type ResolvedDevice,
+} from './index.ts'
+
+export type DTypeName = 'auto' | 'fp32' | 'fp16' | 'q8' | 'int8' | 'uint8' | 'q4' | 'bnb4' | 'q4f16'
+export type DType = DTypeName | Record<string, DTypeName>
+
+export type PipelineLoadOptions = {
+  task: string
+  model: string
+  /** Defaults to `auto` (WebGPU when available, else WASM). */
+  device?: Device
+  /** Quantization. A function receives the resolved device so modules can pick per backend. */
+  dtype?: DType | ((device: ResolvedDevice) => DType)
+  /**
+   * Backends this model is known to work on. If the resolved device is not listed,
+   * the loader falls back to WASM instead of failing at session creation.
+   */
+  supportedDevices?: ResolvedDevice[]
+  /**
+   * Base URL for self-hosted weights (e.g. `/models/`). When set, `model` is resolved as
+   * `<modelPath>/<model>/…` instead of the Hugging Face Hub.
+   */
+  modelPath?: string
+  onProgress?: ProgressCallback
+  pipelineOptions?: Record<string, unknown>
+}
+
+export type LoadedPipeline = {
+  pipe: CallableFunction & { dispose?: () => Promise<void> }
+  device: 'webgpu' | 'wasm'
+}
+
+/**
+ * Shared loader for Transformers.js pipelines with device resolution + progress.
+ */
+export async function loadPipeline(options: PipelineLoadOptions): Promise<LoadedPipeline> {
+  let device = await resolveDevice(options.device ?? 'auto')
+  if (options.supportedDevices && !options.supportedDevices.includes(device)) {
+    device = 'wasm'
+  }
+  options.onProgress?.({ status: 'loading', progress: 0 })
+
+  const { pipeline, env } = await import('@huggingface/transformers')
+  if (options.modelPath) {
+    env.allowLocalModels = true
+    env.allowRemoteModels = false
+    env.localModelPath = options.modelPath
+  } else {
+    env.allowLocalModels = false
+    env.allowRemoteModels = true
+  }
+
+  const dtype =
+    typeof options.dtype === 'function'
+      ? options.dtype(device)
+      : (options.dtype ?? (device === 'webgpu' ? 'fp32' : 'q8'))
+
+  const pipe = await pipeline(options.task as never, options.model, {
+    device,
+    dtype,
+    progress_callback: (data: Record<string, unknown>) => {
+      options.onProgress?.(toProgressInfo(data))
+    },
+    ...options.pipelineOptions,
+  })
+
+  options.onProgress?.({ status: 'ready', progress: 100 })
+  return { pipe: pipe as LoadedPipeline['pipe'], device }
+}
+
+export async function imageToPipelineInput(
+  image: Blob | File | string | HTMLImageElement | HTMLCanvasElement | ImageData
+): Promise<string | import('@huggingface/transformers').RawImage> {
+  if (typeof image === 'string') return image
+
+  const { RawImage } = await import('@huggingface/transformers')
+
+  if (image instanceof HTMLImageElement) {
+    if (image.src && !image.src.startsWith('blob:')) return image.src
+    const canvas = document.createElement('canvas')
+    canvas.width = image.naturalWidth || image.width
+    canvas.height = image.naturalHeight || image.height
+    const ctx = canvas.getContext('2d')
+    if (!ctx) throw new Error('Could not get 2d context')
+    ctx.drawImage(image, 0, 0)
+    return RawImage.fromCanvas(canvas)
+  }
+
+  if (image instanceof HTMLCanvasElement) {
+    return RawImage.fromCanvas(image)
+  }
+
+  if (image instanceof ImageData) {
+    return new RawImage(image.data, image.width, image.height, 4)
+  }
+
+  const url = URL.createObjectURL(image)
+  try {
+    return await RawImage.fromURL(url)
+  } finally {
+    URL.revokeObjectURL(url)
+  }
+}

package/src/core/progress.ts

@@ -0,0 +1,20 @@
+export type ProgressInfo = {
+  status: string
+  progress?: number
+  file?: string
+}
+
+export type ProgressCallback = (info: ProgressInfo) => void
+
+/** Normalize Transformers.js progress callbacks into a simple shape. */
+export function toProgressInfo(data: Record<string, unknown>): ProgressInfo {
+  const status = typeof data.status === 'string' ? data.status : 'progress'
+  const progress =
+    typeof data.progress === 'number'
+      ? data.progress
+      : typeof data.loaded === 'number' && typeof data.total === 'number' && data.total > 0
+        ? (data.loaded / data.total) * 100
+        : undefined
+  const file = typeof data.file === 'string' ? data.file : undefined
+  return { status, progress, file }
+}