@huynle/hub 0.8.7 → 0.9.1

package/src/spoke/preview-bundle.ts

@@ -0,0 +1,538 @@
+// (Session media §3, item 4b) Local HTML previews: the page an assistant message names and the files it refers to,
+// collected under the media path policy (media-policy.ts: the same open-first, realpath, dev/ino and /proc checks as
+// for images) for the previewBundle op (packages/protocol/src/preview-bundle.ts).
+//
+// - The page must be a target of the message's text (markdownHtmlPaths: code spans and same-site path links ending in
+//   .html/.htm, read like image sources: the first 64 KiB up to a blank line, never in indented or fenced code).
+// - References followed (relative ones only, resolved against the file that has them; query and fragment dropped):
+//   in HTML `src`/`href`/`srcset` of script, link rel=stylesheet, img, source, video and audio, CSS in <style> and
+//   style attributes; in CSS `url()` and `@import` (imported sheets are read in turn; each file once, so @import loops
+//   end). JS module imports are not followed. Remote and data: URLs and fragments are left alone (the host's CSP
+//   blocks remote ones); absolute paths (`/x`, `//host`) and files the policy refuses are skipped.
+// - Caps (PREVIEW_BUNDLE_LIMITS): ≤ 200 files, ≤ 5 MiB each, ≤ 20 MiB in all. A page over 5 MiB is tooLarge; an asset
+//   over a cap is skipped with its reason, as is a file of a type the artifact store does not take (previewMediaType).
+//   At most 2 × the file cap references are looked up on disk per walk (the rest: "limit"), and the touched set is
+//   resolved once per walk (resolvedPolicy). A file is reported "missing" only where the policy would allow it
+//   (missingAllowed); outside it every failure reads "refused", so a preview never tells whether such a file exists.
+// - Layout: files keep their places relative to each other. Bundle paths are relative to the deepest directory that
+//   holds them all, and must be artifact paths (letters, digits, `._-/`, ≤ 200): others are skipped ("name").
+//
+// The scanners are tolerant (no DOM) and linear-time: every step moves forward, and every search starts where the
+// last one ended (test/spoke-preview-bundle.test.ts has the adversarial inputs).
+import { createHash } from "node:crypto"
+import { basename, dirname, relative, resolve, sep } from "node:path"
+import { parseMarkdown } from "../../packages/protocol/src/markdown.ts"
+import { htmlTargets, isBundlePath, PREVIEW_BUNDLE_LIMITS, previewMediaType, type PreviewBundleFile, type PreviewBundleResult, type PreviewBundleSkip, type PreviewSkipReason } from "../protocol"
+import type { MediaMessages } from "./media"
+import { missingAllowed, readAllowedPath, resolvedPolicy, scannedPart, sourcePath, touchedPaths, withoutIndentedCode, type PolicyContext } from "./media-policy"
+
+/**
+ * The local HTML pages a message's text names (htmlTargets), read like its image sources: the first 64 KiB up to its
+ * last blank line, and only targets that are still there with indented code left out.
+ */
+export function markdownHtmlPaths(markdown: string): string[] {
+  const text = scannedPart(markdown)
+  if (!/\.htm/i.test(text)) return []
+  const outsideIndented = new Set(htmlTargets(parseMarkdown(withoutIndentedCode(text))))
+  return htmlTargets(parseMarkdown(text)).filter((t) => outsideIndented.has(t))
+}
+
+// ---- scanners -------------------------------------------------------------------------------------------------
+
+/** A reference found in a file: `css` when the file it names is a style sheet (read for its own references). */
+export interface Reference {
+  readonly url: string
+  readonly css: boolean
+}
+
+const NAMED: Readonly<Record<string, string>> = { amp: "&", quot: '"', apos: "'", lt: "<", gt: ">", nbsp: "\u00a0" }
+
+/** HTML character references in an attribute value (named ones of NAMED, decimal and hex). */
+function decodeEntities(value: string): string {
+  if (!value.includes("&")) return value
+  return value.replace(/&(?:#(\d{1,7})|#[xX]([0-9a-fA-F]{1,6})|([A-Za-z]{2,6}));?/g, (whole, dec: string | undefined, hex: string | undefined, name: string | undefined) => {
+    if (name !== undefined) return Object.hasOwn(NAMED, name.toLowerCase()) ? NAMED[name.toLowerCase()]! : whole
+    const code = dec !== undefined ? Number(dec) : parseInt(hex!, 16)
+    return code > 0 && code <= 0x10ffff ? String.fromCodePoint(code) : whole
+  })
+}
+
+/** Elements whose text is never markup (raw text and escapable raw text): skipped to their end tag. */
+const RAW_TEXT = new Set(["script", "style", "textarea", "title", "xmp", "noembed", "noframes", "iframe", "plaintext"])
+const TAG_NAME = /[A-Za-z][A-Za-z0-9-]*/y
+const SPACE = /[\s/]/
+
+/** The references of an HTML document, in document order. */
+export function htmlReferences(html: string): Reference[] {
+  const out: Reference[] = []
+  const n = html.length
+  let i = 0
+  while (i < n) {
+    const lt = html.indexOf("<", i)
+    if (lt < 0) break
+    if (html.startsWith("<!--", lt)) {
+      const end = html.indexOf("-->", lt + 4)
+      i = end < 0 ? n : end + 3
+      continue
+    }
+    const next = html[lt + 1]
+    if (next === "!" || next === "?" || next === "/") {
+      const end = html.indexOf(">", lt + 2)
+      i = end < 0 ? n : end + 1
+      continue
+    }
+    TAG_NAME.lastIndex = lt + 1
+    const name = TAG_NAME.exec(html)
+    if (!name) {
+      i = lt + 1
+      continue
+    }
+    const tag = name[0].toLowerCase()
+    const { attrs, end } = attributes(html, lt + 1 + name[0].length)
+    i = end
+    if (attrs) referencesOf(tag, attrs, out)
+    if (RAW_TEXT.has(tag) && i < n) {
+      const close = new RegExp(`</${tag}[\\s/>]`, "gi")
+      close.lastIndex = i
+      const found = close.exec(html)
+      const body = html.slice(i, found ? found.index : n)
+      if (tag === "style") out.push(...cssReferences(body))
+      i = found ? found.index : n
+    }
+  }
+  return out
+}
+
+/**
+ * The attributes of a start tag from `at` (after its name) to its `>`: names lowercased, values decoded. A tag that
+ * never closes takes the rest of the text; a quoted value that never closes drops the tag (undefined).
+ */
+function attributes(html: string, at: number): { attrs: Map<string, string> | undefined; end: number } {
+  const attrs = new Map<string, string>()
+  const n = html.length
+  let i = at
+  while (i < n) {
+    const c = html[i]!
+    if (c === ">") return { attrs, end: i + 1 }
+    if (SPACE.test(c)) {
+      i++
+      continue
+    }
+    const start = i
+    while (i < n && !/[\s/>=]/.test(html[i]!)) i++
+    // An "=" with no name before it is a character of the next name (the HTML tokenizer's rule).
+    if (i === start) i++
+    const key = html.slice(start, i).toLowerCase()
+    while (i < n && /\s/.test(html[i]!)) i++
+    if (html[i] !== "=") {
+      if (!attrs.has(key)) attrs.set(key, "")
+      continue
+    }
+    i++
+    while (i < n && /\s/.test(html[i]!)) i++
+    let value: string
+    const q = html[i]
+    if (q === '"' || q === "'") {
+      const close = html.indexOf(q, i + 1)
+      if (close < 0) return { attrs: undefined, end: n }
+      value = html.slice(i + 1, close)
+      i = close + 1
+    } else {
+      const begin = i
+      while (i < n && !/[\s>]/.test(html[i]!)) i++
+      value = html.slice(begin, i)
+    }
+    if (!attrs.has(key)) attrs.set(key, decodeEntities(value))
+  }
+  return { attrs, end: n }
+}
+
+const SRC_TAGS = new Set(["script", "img", "source", "video", "audio"])
+
+function referencesOf(tag: string, attrs: Map<string, string>, out: Reference[]): void {
+  const add = (url: string | undefined, css = false) => {
+    if (url) out.push({ url, css })
+  }
+  if (tag === "link") {
+    const rel = (attrs.get("rel") ?? "").toLowerCase().split(/\s+/)
+    if (rel.includes("stylesheet")) add(attrs.get("href")?.trim(), true)
+  } else if (SRC_TAGS.has(tag)) {
+    add(attrs.get("src")?.trim())
+    if (tag === "img" || tag === "source") for (const url of srcsetUrls(attrs.get("srcset") ?? "")) add(url)
+  }
+  const style = attrs.get("style")
+  if (style) out.push(...cssReferences(style))
+}
+
+/**
+ * The URLs of a srcset attribute (the HTML "parse a srcset attribute" steps, without descriptor checks): each
+ * candidate is a run of non-space characters (trailing commas dropped), then descriptors up to the next comma outside
+ * parentheses.
+ */
+export function srcsetUrls(value: string): string[] {
+  const out: string[] = []
+  const n = value.length
+  let i = 0
+  while (i < n) {
+    while (i < n && /[\s,]/.test(value[i]!)) i++
+    if (i >= n) break
+    const start = i
+    while (i < n && !/\s/.test(value[i]!)) i++
+    let url = value.slice(start, i)
+    if (url.endsWith(",")) {
+      url = url.replace(/,+$/, "")
+      if (url) out.push(url)
+      continue
+    }
+    if (url) out.push(url)
+    let depth = 0
+    while (i < n) {
+      const c = value[i]!
+      if (c === "(") depth++
+      else if (c === ")") depth = Math.max(0, depth - 1)
+      else if (c === "," && depth === 0) break
+      i++
+    }
+  }
+  return out
+}
+
+const CSS_TOKEN = /\/\*|url\(|@import/gi
+
+/** The references of a style sheet: `url()` (files) and `@import` (style sheets), outside comments, in order. */
+export function cssReferences(css: string): Reference[] {
+  const out: Reference[] = []
+  const n = css.length
+  const re = new RegExp(CSS_TOKEN.source, "gi")
+  for (let m = re.exec(css); m; m = re.exec(css)) {
+    const token = m[0].toLowerCase()
+    let i = m.index + m[0].length
+    if (token === "/*") {
+      const end = css.indexOf("*/", i)
+      if (end < 0) break
+      re.lastIndex = end + 2
+      continue
+    }
+    let isImport = false
+    if (token === "@import") {
+      isImport = true
+      while (i < n && /\s/.test(css[i]!)) i++
+      if (css[i] === '"' || css[i] === "'") {
+        const close = css.indexOf(css[i]!, i + 1)
+        if (close < 0) break
+        out.push({ url: css.slice(i + 1, close).trim(), css: true })
+        re.lastIndex = close + 1
+        continue
+      }
+      if (css.slice(i, i + 4).toLowerCase() !== "url(") {
+        re.lastIndex = i
+        continue
+      }
+      i += 4
+    }
+    while (i < n && /\s/.test(css[i]!)) i++
+    let url: string
+    if (css[i] === '"' || css[i] === "'") {
+      const close = css.indexOf(css[i]!, i + 1)
+      if (close < 0) break
+      url = css.slice(i + 1, close)
+      const paren = css.indexOf(")", close + 1)
+      re.lastIndex = paren < 0 ? n : paren + 1
+    } else {
+      const paren = css.indexOf(")", i)
+      if (paren < 0) break
+      url = css.slice(i, paren)
+      re.lastIndex = paren + 1
+    }
+    url = url.trim()
+    if (url) out.push({ url, css: isImport })
+  }
+  return out
+}
+
+// ---- the walk -------------------------------------------------------------------------------------------------
+
+export type BundleLimits = { -readonly [K in "files" | "fileBytes" | "totalBytes"]: number }
+
+export interface WalkInput extends PolicyContext {
+  /** The page as written in the message (a code span or link target). */
+  readonly src: string
+  /** The message's text (its text parts joined). */
+  readonly text: string
+  /** For tests: smaller caps. */
+  readonly limits?: Partial<BundleLimits>
+}
+
+export interface WalkedFile {
+  readonly path: string
+  readonly mediaType: string
+  readonly bytes: Uint8Array
+}
+
+export type WalkResult =
+  | { readonly entry: string; readonly files: readonly WalkedFile[]; readonly skipped: readonly PreviewBundleSkip[]; readonly skippedMore?: number }
+  | { readonly refused: "path" | "type" }
+  | { readonly tooLarge: { readonly bytes: number; readonly max: number } }
+
+const SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:/
+
+/** A reference as followed: without query and fragment, `\` read as `/` (as browsers do); undefined: left alone. */
+function localReference(raw: string): { written: string; path?: string; refused?: PreviewSkipReason } | undefined {
+  const written = raw.trim().replace(/\\/g, "/").replace(/[?#].*$/s, "")
+  if (!written || SCHEME.test(written)) return undefined
+  if (written.startsWith("/")) return { written, refused: "refused" }
+  let path: string
+  try {
+    path = decodeURIComponent(written)
+  } catch {
+    return { written, refused: "name" }
+  }
+  if (path.includes("\u0000")) return { written, refused: "refused" }
+  return { written, path }
+}
+
+/** The directory every path is under (the deepest common one). */
+function commonDir(dirs: readonly string[]): string {
+  let common = dirs[0]!
+  for (const d of dirs.slice(1)) {
+    while (common !== d && !d.startsWith(common.endsWith(sep) ? common : common + sep)) {
+      const up = dirname(common)
+      if (up === common) break
+      common = up
+    }
+  }
+  return common
+}
+
+const posix = (p: string) => (sep === "/" ? p : p.split(sep).join("/"))
+
+/** Walks the page `src` names and what it refers to (see the file's header). */
+export async function walkBundle(input: WalkInput): Promise<WalkResult> {
+  const limits: BundleLimits = { files: PREVIEW_BUNDLE_LIMITS.files, fileBytes: PREVIEW_BUNDLE_LIMITS.fileBytes, totalBytes: PREVIEW_BUNDLE_LIMITS.totalBytes, ...input.limits }
+  if (!markdownHtmlPaths(input.text).includes(input.src)) return { refused: "path" }
+  const entryPath = sourcePath(input.src, input.directory)
+  if (!entryPath) return { refused: "path" }
+  // The touched set is resolved once for the walk, not once per reference.
+  const ctx: PolicyContext = await resolvedPolicy({ directory: input.directory, touched: input.touched, ...(input.fs ? { fs: input.fs } : {}) })
+  // File-system lookups per walk (each reference read once): past this, references are skipped as "limit".
+  const maxProbes = 2 * limits.files
+  let probes = 0
+  const page = await readAllowedPath(entryPath, { ...ctx, max: limits.fileBytes })
+  if ("refused" in page) return page
+  if ("tooLarge" in page) return { tooLarge: { bytes: page.tooLarge, max: limits.fileBytes } }
+  if (!/\.html?$/i.test(page.path)) return { refused: "type" }
+
+  // Lexical paths keep the layout the page's relative references expect; the policy checks each real path.
+  const entryName = isBundlePath(basename(entryPath)) ? basename(entryPath) : "index.html"
+  const files: Array<{ abs: string; bytes: Uint8Array }> = [{ abs: resolve(dirname(entryPath), entryName), bytes: page.bytes }]
+  const seen = new Set<string>([entryPath, files[0]!.abs])
+  const skipped: PreviewBundleSkip[] = []
+  let skippedMore = 0
+  let total = page.bytes.length
+  let root = dirname(entryPath)
+  const skip = (written: string, reason: PreviewSkipReason) => {
+    if (skipped.length < PREVIEW_BUNDLE_LIMITS.skipped) skipped.push({ path: written.slice(0, PREVIEW_BUNDLE_LIMITS.refMax), reason })
+    else skippedMore++
+  }
+  const relOf = (abs: string, under: string) => posix(relative(under, abs))
+  /** The root with `abs` added, when every file still has a valid bundle path under it. */
+  const rootWith = (abs: string): string | undefined => {
+    const next = commonDir([root, dirname(abs)])
+    return [...files.map((f) => f.abs), abs].every((p) => isBundlePath(relOf(p, next))) ? next : undefined
+  }
+
+  const queue: Array<{ abs: string; css: boolean; text: string }> = [{ abs: entryPath, css: false, text: new TextDecoder().decode(page.bytes) }]
+  for (let q = 0; q < queue.length; q++) {
+    const file = queue[q]!
+    const refs = file.css ? cssReferences(file.text) : htmlReferences(file.text)
+    for (const ref of refs) {
+      const local = localReference(ref.url)
+      if (!local) continue
+      if (local.refused) {
+        skip(local.written, local.refused)
+        continue
+      }
+      const abs = resolve(dirname(file.abs), local.path!)
+      if (seen.has(abs)) continue
+      seen.add(abs)
+      if (!previewMediaType(abs)) {
+        skip(local.written, "type")
+        continue
+      }
+      if (files.length >= limits.files || probes >= maxProbes) {
+        skip(local.written, "limit")
+        continue
+      }
+      probes++
+      const read = await readAllowedPath(abs, { ...ctx, max: limits.fileBytes })
+      if ("refused" in read) {
+        // "missing" only where the policy would allow the file: outside it, existing or not reads the same.
+        skip(local.written, (await missingAllowed(abs, ctx)) ? "missing" : "refused")
+        continue
+      }
+      if ("tooLarge" in read) {
+        skip(local.written, "too_large")
+        continue
+      }
+      if (total + read.bytes.length > limits.totalBytes) {
+        skip(local.written, "limit")
+        continue
+      }
+      const next = rootWith(abs)
+      if (next === undefined) {
+        skip(local.written, "name")
+        continue
+      }
+      root = next
+      total += read.bytes.length
+      files.push({ abs, bytes: read.bytes })
+      if (ref.css) queue.push({ abs, css: true, text: new TextDecoder().decode(read.bytes) })
+    }
+  }
+  const out = files.map((f) => {
+    const path = relOf(f.abs, root)
+    return { path, mediaType: previewMediaType(path)!, bytes: f.bytes }
+  })
+  return { entry: out[0]!.path, files: out, skipped, ...(skippedMore > 0 ? { skippedMore } : {}) }
+}
+
+
+// ---- the op ---------------------------------------------------------------------------------------------------
+
+/** A walked bundle as the op serves it: its identity and its files with their hashes. */
+export interface CachedBundle {
+  readonly id: string
+  readonly entry: string
+  readonly files: ReadonlyArray<{ readonly path: string; readonly mediaType: string; readonly bytes: Uint8Array; readonly sha256: string }>
+  readonly skipped: readonly PreviewBundleSkip[]
+  readonly skippedMore?: number
+}
+
+const sizeOf = (b: CachedBundle) => b.files.reduce((n, f) => n + f.bytes.length, 0)
+
+/** Walked bundles by key (session, message, page), least recently used first; entries expire after `ttlMs`. */
+export class BundleCache {
+  private readonly entries = new Map<string, { bundle: CachedBundle; at: number; size: number }>()
+  private total = 0
+  private readonly ttlMs: number
+  private readonly maxBytes: number
+  private readonly now: () => number
+
+  constructor(options: { ttlMs?: number; maxBytes?: number; now?: () => number } = {}) {
+    this.ttlMs = options.ttlMs ?? 60_000
+    this.maxBytes = options.maxBytes ?? 48 * 1024 * 1024
+    this.now = options.now ?? Date.now
+  }
+
+  get(key: string): CachedBundle | undefined {
+    const entry = this.entries.get(key)
+    if (!entry) return undefined
+    this.entries.delete(key)
+    if (this.now() - entry.at >= this.ttlMs) {
+      this.total -= entry.size
+      return undefined
+    }
+    this.entries.set(key, entry)
+    return entry.bundle
+  }
+
+  set(key: string, bundle: CachedBundle): void {
+    this.drop(key)
+    const size = sizeOf(bundle)
+    if (size > this.maxBytes) return
+    this.entries.set(key, { bundle, at: this.now(), size })
+    this.total += size
+    while (this.total > this.maxBytes) this.drop(this.entries.keys().next().value!)
+  }
+
+  /** Forget a session's bundles (deleted, or a revert hid messages). */
+  invalidate(sessionID: string): void {
+    for (const key of [...this.entries.keys()]) if (key.startsWith(`${sessionID}\u0000`)) this.drop(key)
+  }
+
+  private drop(key: string): void {
+    const entry = this.entries.get(key)
+    if (!entry) return
+    this.entries.delete(key)
+    this.total -= entry.size
+  }
+}
+
+export interface PreviewBundleInput {
+  readonly sessionID: string
+  readonly messageID: string
+  readonly path: string
+  readonly bundle?: string
+  readonly file?: number
+  readonly offset?: number
+  readonly cache: BundleCache
+  /** The session's messages (read for every walk, so access is checked again). */
+  readonly load: () => Promise<MediaMessages>
+  readonly directory: string
+  readonly fs?: PolicyContext["fs"]
+}
+
+const record = (value: unknown): Record<string, any> => (value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, any>) : {})
+
+/** The bundle's identity: a hash of its entry and every file's path, type and content hash. */
+const bundleID = (entry: string, files: CachedBundle["files"]) => createHash("sha256").update(JSON.stringify([entry, files.map((f) => [f.path, f.mediaType, f.sha256])])).digest("hex")
+
+/** Walks the page of the message again (message, revert and path checks included). */
+async function walkMessage(input: PreviewBundleInput): Promise<CachedBundle | PreviewBundleResult> {
+  const messages = await input.load()
+  const message = messages.all.map(record).find((m) => m.id === input.messageID)
+  if (!message) return input.messageID === messages.committed ? { refused: "hidden" } : {}
+  if (!messages.shown.some((m) => record(m).id === input.messageID)) return { refused: "hidden" }
+  if (message.type !== "assistant" || !Array.isArray(message.content)) return { refused: "path" }
+  const text = message.content
+    .filter((p: any) => p?.type === "text" && typeof p.text === "string")
+    .map((p: any) => p.text as string)
+    .join("\n\n")
+  const walked = await walkBundle({ src: input.path, text, directory: input.directory, touched: touchedPaths(messages.shown, input.directory), ...(input.fs ? { fs: input.fs } : {}) })
+  if (!("files" in walked)) return walked
+  const files = walked.files.map((f) => ({ ...f, sha256: createHash("sha256").update(f.bytes).digest("hex") }))
+  return { id: bundleID(walked.entry, files), entry: walked.entry, files, skipped: walked.skipped, ...(walked.skippedMore ? { skippedMore: walked.skippedMore } : {}) }
+}
+
+const isBundle = (v: CachedBundle | PreviewBundleResult): v is CachedBundle => "id" in v
+
+/**
+ * The answer to previewBundle (packages/protocol/src/preview-bundle.ts): without `bundle`, a fresh walk's manifest
+ * (files inlined in order while they fit PREVIEW_BUNDLE_LIMITS.inlineBytes); with `bundle, file, offset`, that chunk,
+ * from the cache or a new walk with the same identity, else `stale`. Throws for no such file or an offset past its end.
+ */
+export async function previewBundle(input: PreviewBundleInput): Promise<PreviewBundleResult> {
+  const key = `${input.sessionID}\u0000${input.messageID}\u0000${input.path}`
+  if (input.bundle !== undefined) {
+    let bundle = input.cache.get(key)
+    if (bundle?.id !== input.bundle) {
+      const walked = await walkMessage(input)
+      if (!isBundle(walked)) return walked
+      input.cache.set(key, walked)
+      if (walked.id !== input.bundle) return { stale: true }
+      bundle = walked
+    }
+    const file = bundle.files[input.file ?? -1]
+    if (!file) throw new Error("No such file in the preview bundle")
+    const offset = input.offset ?? 0
+    if (offset >= file.bytes.length) throw new Error("The offset is past the end of the file")
+    const end = Math.min(file.bytes.length, offset + PREVIEW_BUNDLE_LIMITS.chunkBytes)
+    return { chunk: { offset, data: Buffer.from(file.bytes.buffer, file.bytes.byteOffset + offset, end - offset).toString("base64"), last: end >= file.bytes.length } }
+  }
+  const walked = await walkMessage(input)
+  if (!isBundle(walked)) return walked
+  input.cache.set(key, walked)
+  let inline = 0
+  const files: PreviewBundleFile[] = walked.files.map((f) => {
+    const fits = inline + f.bytes.length <= PREVIEW_BUNDLE_LIMITS.inlineBytes
+    if (fits) inline += f.bytes.length
+    return { path: f.path, mediaType: f.mediaType, bytes: f.bytes.length, sha256: f.sha256, ...(fits ? { data: Buffer.from(f.bytes).toString("base64") } : {}) }
+  })
+  return {
+    bundle: walked.id,
+    entry: walked.entry,
+    files,
+    ...(walked.skipped.length ? { skipped: walked.skipped } : {}),
+    ...(walked.skippedMore ? { skippedMore: walked.skippedMore } : {}),
+  }
+}