@heyquilt/seam 0.27.0 → 0.131.0

package/lib/quilts/conflict-format.js

@@ -0,0 +1,266 @@
+// 07's default conflict materialisation, `diff` (Jujutsu's style): inside each marker block one
+// side as a snapshot (`+++++++`), then each other side as a diff from its base (`%%%%%%%`). With
+// two sides (diff3), more sides on one base (an N-way merge, `nway`) or on different bases (each
+// side's change laid onto the first side, `ontoFirst`) only the clashing regions are marked and the
+// rest of the file is merged text; a deleted side is an empty side labelled "(deleted by <who>)". Also the `git` format (diff3 markers with the `|||||||` base section, two sides
+// only). Every block's first line carries the term's tag, so a
+// file committed with these markers is still conflicted (service.js, block.js).
+import { diff3Merge } from 'node-diff3'
+import { hunks, splitLines } from './textdiff.js'
+
+/** `old` → `now` as `-`/`+`/` ` lines (every line of both, in order). */
+export function lineDiff (old, now) {
+  const out = []
+  let i = 0
+  let j = 0
+  for (const h of hunks(old, now)) {
+    while (i < h.a[0]) { out.push(' ' + old[i++]); j++ }
+    for (let k = 0; k < h.a[1]; k++) out.push('-' + old[i++])
+    for (let k = 0; k < h.b[1]; k++) out.push('+' + now[j++])
+  }
+  while (i < old.length) { out.push(' ' + old[i++]); j++ }
+  return out
+}
+
+/**
+ * The term as `diff` markers. `sides` are [{ text, label, by }] (adds, text null for a delete);
+ * `bases` the removes' texts (bases[i] is the base of sides[i + 1]). `tag` is
+ * `quilt-conflict <hash>`, `kind` the term kind.
+ */
+export function diffMarkers ({ sides, bases, tag, kind }) {
+  const L = (t) => splitLines(t || '')
+  // Ruling (2026-10-24): a side that deleted the file, or the region, is an empty side labelled so.
+  const name = (s, lines, base) => s.text == null || (!lines.length && base && base.length) ? `${s.label} (deleted by ${s.by || 'someone'})` : s.label
+  const block = (snap, others) => [
+    `<<<<<<< ${tag} ${kind}`,
+    `+++++++ ${name(snap.side, snap.lines, snap.base)}`, ...snap.lines,
+    ...others.flatMap((o) => [`%%%%%%% ${name(o.side, o.lines, o.base)} (diff from base)`, ...lineDiff(o.base, o.lines)]),
+    `>>>>>>> ${tag}`
+  ]
+  const whole = () => block({ side: sides[0], lines: L(sides[0].text), base: L(bases[0]) },
+    sides.slice(1).map((s, i) => ({ side: s, base: L(bases[i]), lines: L(s.text) })))
+  if (sides.length < 2) return whole().join('\n') + '\n'
+  const out = []
+  let marked = false
+  if (sides.length === 2) {
+    for (const r of diff3Merge(L(sides[0].text), L(bases[0]), L(sides[1].text), { excludeFalseConflicts: true })) {
+      if (r.ok) { out.push(...r.ok); continue }
+      const c = r.conflict
+      marked = true
+      out.push(...block({ side: sides[0], lines: c.a, base: c.o }, [{ side: sides[1], base: c.o, lines: c.b }]))
+    }
+  } else {
+    const regions = bases.some((b) => (b || '') !== (bases[0] || '')) ? ontoFirst(L(sides[0].text), sides.slice(1).map((s, i) => ({ base: L(bases[i]), lines: L(s.text) }))) : null
+    if (regions) {
+      for (const r of regions) {
+        if (r.ok) { out.push(...r.ok); continue }
+        marked = true
+        out.push(...block({ side: sides[0], lines: r.snap }, sides.slice(1).map((s, i) => ({ side: s, base: r.others[i].base, lines: r.others[i].lines }))))
+      }
+    } else for (const r of nway(L(bases[0]), sides.map((s) => L(s.text)))) {
+      if (r.ok) { out.push(...r.ok); continue }
+      marked = true
+      out.push(...block({ side: sides[0], lines: r.sides[0], base: r.base }, sides.slice(1).map((s, i) => ({ side: s, base: r.base, lines: r.sides[i + 1] }))))
+    }
+  }
+  return (marked ? out : whole()).join('\n') + '\n'
+}
+
+/**
+ * An N-way line merge of `sides` (arrays of lines) that all start from `base`: regions
+ * `{ ok: lines }` where at most one distinct change touches the base lines, and
+ * `{ base, sides }` where two sides changed the same (or touching) base lines differently.
+ */
+export function nway (base, sides) {
+  const all = []
+  sides.forEach((lines, s) => { for (const h of hunks(base, lines)) all.push({ s, a0: h.a[0], a1: h.a[0] + h.a[1], d: h.b[1] - h.a[1] }) })
+  all.sort((x, y) => x.a0 - y.a0 || x.a1 - y.a1)
+  const groups = []
+  for (const h of all) {
+    const g = groups[groups.length - 1]
+    if (g && h.a0 <= g.hi) { g.hi = Math.max(g.hi, h.a1); g.hunks.push(h) } else groups.push({ lo: h.a0, hi: h.a1, hunks: [h] })
+  }
+  const shift = new Array(sides.length).fill(0) // each side's line offset before the current group
+  const out = []
+  let at = 0
+  const ok = (lines) => { if (lines.length) out.push({ ok: lines }) }
+  for (const g of groups) {
+    ok(base.slice(at, g.lo))
+    const changed = new Set(g.hunks.map((h) => h.s))
+    const slice = sides.map((lines, s) => {
+      const d = g.hunks.filter((h) => h.s === s).reduce((n, h) => n + h.d, 0)
+      const part = lines.slice(g.lo + shift[s], g.hi + shift[s] + d)
+      shift[s] += d
+      return part
+    })
+    const versions = new Set([...changed].map((s) => slice[s].join('\n') + '\u0000' + slice[s].length))
+    if (versions.size === 1) ok(slice[[...changed][0]])
+    else out.push({ base: base.slice(g.lo, g.hi), sides: slice })
+    at = g.hi
+  }
+  ok(base.slice(at))
+  return out
+}
+
+/** Maps line positions of `a` to `b` through their hunks; inside a changed run (or on an insertion), `lo` snaps to its start and `hi` to its end. */
+function mapper (a, b) {
+  const hs = hunks(a, b)
+  const at = (p, end) => {
+    let off = 0
+    for (const h of hs) {
+      const [a0, an] = h.a
+      if (end && p === a0 && an === 0) return h.b[0] + h.b[1] // an end on an insertion takes it in
+      if (p <= a0) return p + off
+      if (p < a0 + an) return end ? h.b[0] + h.b[1] : h.b[0]
+      off += h.b[1] - an
+    }
+    return p + off
+  }
+  return { hunks: hs, lo: (p) => at(p, false), hi: (p) => at(p, true) }
+}
+
+/**
+ * Sides on different bases, each laid onto the first side (the snapshot): a side's change lands
+ * where its base lines sit in the first side. Regions `{ ok: lines }` where at most one change
+ * lands and it does not touch lines the first side changed from that base, and `{ snap, others }`
+ * (each other side's base and text over the region) where they clash.
+ */
+export function ontoFirst (first, others) {
+  const regions = []
+  others.forEach((o, i) => {
+    const toFirst = mapper(o.base, first)
+    const toSide = mapper(o.base, o.lines)
+    for (const h of toSide.hunks) {
+      let x0 = h.a[0]; let x1 = h.a[0] + h.a[1]; let clash = false
+      for (let grew = true; grew;) {
+        grew = false
+        for (const c of toFirst.hunks) {
+          const c0 = c.a[0]; const c1 = c.a[0] + c.a[1]
+          if (c0 > x1 || x0 > c1) continue
+          clash = true
+          if (c0 < x0 || c1 > x1) { x0 = Math.min(x0, c0); x1 = Math.max(x1, c1); grew = true }
+        }
+      }
+      regions.push({ i, lo: toFirst.lo(x0), hi: toFirst.hi(x1), clash, text: o.lines.slice(toSide.lo(x0), toSide.hi(x1)) })
+    }
+  })
+  regions.sort((x, y) => x.lo - y.lo || x.hi - y.hi)
+  const groups = []
+  for (const r of regions) {
+    const g = groups[groups.length - 1]
+    if (g && r.lo <= g.hi) { g.hi = Math.max(g.hi, r.hi); g.rs.push(r) } else groups.push({ lo: r.lo, hi: r.hi, rs: [r] })
+  }
+  const out = []
+  let at = 0
+  const ok = (lines) => { if (lines.length) out.push({ ok: lines }) }
+  for (const g of groups) {
+    ok(first.slice(at, g.lo))
+    const same = g.rs.every((r) => !r.clash && r.lo === g.lo && r.hi === g.hi && r.text.join('\n') === g.rs[0].text.join('\n') && r.text.length === g.rs[0].text.length)
+    if (same) ok(g.rs[0].text)
+    else {
+      out.push({
+        snap: first.slice(g.lo, g.hi),
+        others: others.map((o) => {
+          const back = mapper(first, o.base)
+          const fwd = mapper(o.base, o.lines)
+          const [b0, b1] = [back.lo(g.lo), back.hi(g.hi)]
+          return { base: o.base.slice(b0, b1), lines: o.lines.slice(fwd.lo(b0), fwd.hi(b1)) }
+        })
+      })
+    }
+    at = g.hi
+  }
+  ok(first.slice(at))
+  return out
+}
+
+/** The term whole (07's `snapshot` format): every side, then every base, each as its full text. */
+export function snapshotMarkers ({ sides, bases, tag, kind }) {
+  const parts = [`<<<<<<< ${tag} ${kind}`]
+  sides.forEach((s) => parts.push(`+++++++ ${s.label}`, s.text || ''))
+  bases.forEach((b, i) => parts.push(`------- base ${i}`, b || ''))
+  parts.push(`>>>>>>> ${tag}`)
+  return parts.join('\n') + '\n'
+}
+
+/** The term as git's diff3 markers (07's `git` format): two sides, with the `|||||||` base. */
+export function gitMarkers ({ ours, base, theirs, tag }) {
+  const L = (t) => splitLines(t || '')
+  const name = (s, lines, o) => s.text == null || (!lines.length && o.length) ? `${s.label} (deleted by ${s.by || 'someone'})` : s.label
+  const block = (a, o, b) => [`<<<<<<< ${name(ours, a, o)} ${tag}`, ...a, `||||||| base ${tag}`, ...o, '=======', ...b, `>>>>>>> ${name(theirs, b, o)} ${tag}`]
+  const out = []
+  let marked = false
+  for (const r of diff3Merge(L(ours.text), L(base), L(theirs.text), { excludeFalseConflicts: true })) {
+    if (r.ok) { out.push(...r.ok); continue }
+    marked = true
+    out.push(...block(r.conflict.a, r.conflict.o, r.conflict.b))
+  }
+  return (marked ? out : block(L(ours.text), L(base), L(theirs.text))).join('\n') + '\n'
+}
+
+/**
+ * Reads a file with conflict markers back (any of the three formats): `[{ ok: lines }` for merged
+ * text, and `{ format, tag, kind, sides: [{ label, deleted, lines, base }] }` for each block]`.
+ * `base` is a side's base lines where the markers show it (a `diff` side after the first, a `git`
+ * block's two sides). A `snapshot` block also gives each side's exact `text` and the bases as
+ * `removes`, so it reads back to the term it was written from. Only blocks whose first line carries `quilt-conflict` are read; lines that merely look
+ * like markers outside them are text. A block left open or out of order throws `markers_malformed`.
+ */
+export function parseMarkers (text) {
+  const lines = splitLines(text || '')
+  const out = []
+  const bad = (why) => Object.assign(new Error(`conflict markers malformed: ${why}`), { code: 'markers_malformed' })
+  const label = (s) => { const m = /^(.*) \(deleted by [^)]*\)$/.exec(s); return m ? { label: m[1], deleted: true } : { label: s, deleted: false } }
+  let ok = []
+  const flush = () => { if (ok.length) out.push({ ok }); ok = [] }
+  for (let i = 0; i < lines.length; i++) {
+    const open = /^<<<<<<< (quilt-conflict \S+) (\S+)$/.exec(lines[i])
+    const gopen = !open && /^<<<<<<< (.*) (quilt-conflict \S+)$/.exec(lines[i])
+    if (!open && !gopen) { ok.push(lines[i]); continue }
+    flush()
+    const tag = open ? open[1] : gopen[2]
+    const close = open ? `>>>>>>> ${tag}` : null
+    const sides = []
+    const removes = []
+    let cur = null
+    let mode = null
+    for (i++; ; i++) {
+      if (i >= lines.length) throw bad(`block ${tag} is never closed`)
+      const l = lines[i]
+      if (open) {
+        if (l === close) break
+        if (l.startsWith('+++++++ ')) { cur = { ...label(l.slice(8)), lines: [] }; mode = 'snap'; sides.push(cur); continue }
+        if (/^------- base \d+$/.test(l) && mode !== 'diff' && sides.length) { cur = { base: true, lines: [] }; mode = 'snap'; removes.push(cur); continue }
+        if (l.startsWith('%%%%%%% ') && l.endsWith(' (diff from base)') && !removes.length) { cur = { ...label(l.slice(8, -17)), lines: [], base: [] }; mode = 'diff'; sides.push(cur); continue }
+        if (!cur) throw bad(`block ${tag} has text before its first side`)
+        if (mode === 'snap') { cur.lines.push(l); continue }
+        const op = l[0]
+        if (op === ' ') { cur.lines.push(l.slice(1)); cur.base.push(l.slice(1)) } else if (op === '+') cur.lines.push(l.slice(1))
+        else if (op === '-') cur.base.push(l.slice(1))
+        else throw bad(`block ${tag} has a diff line that is not -, + or space`)
+      } else {
+        if (mode === null) { cur = { ...label(gopen[1]), lines: [], base: [] }; sides.push(cur); mode = 'ours' }
+        if (mode === 'ours' && l === `||||||| base ${tag}`) { mode = 'base'; continue }
+        if (mode === 'base' && l === '=======') { mode = 'theirs'; sides.push(cur = { label: '', deleted: false, lines: [], base: sides[0].base }); continue }
+        if (mode === 'theirs' && l.startsWith('>>>>>>> ') && l.endsWith(' ' + tag)) { Object.assign(cur, label(l.slice(8, -tag.length - 1))); break }
+        if (mode === 'base') sides[0].base.push(l)
+        else cur.lines.push(l)
+      }
+    }
+    if (open && !sides.length) throw bad(`block ${tag} has no sides`)
+    if (removes.length) {
+      // A snapshot block holds each text whole: the lines between two markers are the text plus
+      // the newline that joined it to the next marker, so joining them gives the exact bytes.
+      for (const s of sides) { s.text = s.lines.join('\n'); s.lines = splitLines(s.text) }
+      out.push({ format: 'snapshot', tag, kind: open[2], sides, removes: removes.map((r) => r.lines.join('\n')) })
+    } else out.push(open ? { format: 'diff', tag, kind: open[2], sides } : { format: 'git', tag, kind: null, sides })
+  }
+  flush()
+  return out
+}
+
+/** The file with every block resolved to side `k` (what someone who picks that side keeps). */
+export function resolveMarkers (regions, k) {
+  const lines = regions.flatMap((r) => r.ok || r.sides[k].lines)
+  return lines.length ? lines.join('\n') + '\n' : ''
+}

package/lib/quilts/daemon.js

@@ -0,0 +1,174 @@
+// The daemon for one block folder (05 "Cache tiers", slice 1): it watches the folder, sends each
+// changed path to the square's live work as a PATCH /live (the folder's head named, unchanged
+// paths as `clean`), and answers a control API on 127.0.0.1. The API's port and token are in
+// ~/.seam/daemon/<folder id>.json (0600), which only the folder's owner can read; every request
+// carries `Authorization: Bearer <token>`. Routes: GET /status, POST /flush, POST /rebuild, POST /stop.
+// On start it runs block.rebuild and shares every edit made while it was not running.
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import http from 'node:http'
+import crypto from 'node:crypto'
+import { findBlock, livePatch, rebuild, localChanges, touchFolder } from './block.js'
+
+const seamHome = () => process.env.SEAM_HOME || path.join(os.homedir(), '.seam')
+const SKIP = new Set(['.seam', '.git', 'node_modules'])
+
+/** Where the daemon for a block folder keeps its port and token. */
+export const daemonStatusFile = (dir) => path.join(seamHome(), 'daemon', crypto.createHash('sha256').update(path.resolve(dir)).digest('hex').slice(0, 16) + '.json')
+
+/** At most this many daemons on one machine (05 "Several blocks": each costs a native watcher). */
+export const MAX_DAEMONS = 200
+
+/** The daemons running on this machine: their status files whose process is alive. */
+export function runningDaemons () {
+  const d = path.join(seamHome(), 'daemon')
+  const out = []
+  for (const n of fs.existsSync(d) ? fs.readdirSync(d) : []) {
+    if (!n.endsWith('.json')) continue
+    try {
+      const info = JSON.parse(fs.readFileSync(path.join(d, n), 'utf8'))
+      process.kill(info.pid, 0)
+      out.push(info)
+    } catch (err) { if (err.code === 'EPERM') out.push({ file: n }) }
+  }
+  return out
+}
+
+/** Asks the daemon running for a folder (null when none answers). */
+export async function askDaemon (dir, route = 'status', method = 'GET') {
+  let info
+  try { info = JSON.parse(fs.readFileSync(daemonStatusFile(dir), 'utf8')) } catch { return null }
+  try {
+    const res = await fetch(`http://127.0.0.1:${info.port}/${route}`, { method, headers: { authorization: `Bearer ${info.token}` }, signal: AbortSignal.timeout(3000) })
+    return res.ok ? await res.json() : null
+  } catch { return null }
+}
+
+/**
+ * Starts the daemon for the block folder `dir`: { port, status(), flush(), stop() }. A path is sent
+ * `debounceMs` after its last change. A `409 head_moved` keeps the paths pending (state
+ * `head_moved`) until the folder's head is the square's again (seam rebase or seam checkout);
+ * any other failure keeps them for the next try.
+ */
+export async function startDaemon ({ client, dir, debounceMs = 1000, codec = null, touchMs = 10 * 60 * 1000 }) {
+  const found = findBlock(dir)
+  if (!found) throw new Error(`${dir} is not a block folder: run seam checkout first.`)
+  dir = found.dir
+  if (!found.block.square) throw new Error('This block is not on a square, so it has no live work to share: open one with seam square open.')
+  if (found.block.read_only) throw new Error('This block is read-only, so it has no live work to share.')
+  const others = runningDaemons().filter((i) => i.dir !== dir)
+  const max = Number(process.env.SEAM_MAX_DAEMONS) || MAX_DAEMONS
+  if (others.length >= max) throw Object.assign(new Error(`${others.length} seam daemons already run on this machine (at most ${max}): stop one with seam daemon stop in its folder.`), { code: 'daemons_limit' })
+  const pending = new Set()
+  const st = { dir, quilt: found.block.quilt, square: found.block.square, head: found.block.head || null, state: 'watching', sent: 0, last_sent_at: null, last_error: null, pid: process.pid, started_at: new Date().toISOString() }
+  let timer = null
+  let running = null
+  let stopped = false
+  let retryAt = 0
+  let inflight = []
+  let lastRebuild = null
+
+  // block.rebuild (05): finish a move that stopped part way, then queue every edit made while no
+  // daemon watched, so it is shared like one made now.
+  const rebuildNow = async () => {
+    const { block } = findBlock(dir)
+    if (codec) block._codec = codec
+    lastRebuild = await rebuild(client, dir, block)
+    const fresh = findBlock(dir).block
+    for (const c of localChanges(dir, fresh)) pending.add(c.path)
+    for (const p of lastRebuild.kept) pending.add(p)
+    return lastRebuild
+  }
+
+  const flush = async () => {
+    if (running) { await running; if (!pending.size) return }
+    if (!pending.size) return
+    const paths = [...pending].sort()
+    pending.clear()
+    inflight = paths
+    running = (async () => {
+      const { block } = findBlock(dir)
+      st.head = block.head || null
+      try {
+        const patch = livePatch(dir, block, paths.map((p) => path.join(dir, p)))
+        if (patch.changes.length) await client.patchLive(block.quilt, block.square, patch)
+        st.sent += 1
+        st.last_sent_at = new Date().toISOString()
+        st.state = 'watching'
+        st.last_error = null
+      } catch (err) {
+        for (const p of paths) pending.add(p)
+        st.state = err.code === 'head_moved' ? 'head_moved' : 'retrying'
+        retryAt = Date.now() + 10000
+        st.last_error = err.code === 'head_moved' ? `the square's head is ${String(err.head || '').slice(0, 12)}, not this folder's: run seam rebase` : err.message
+      }
+    })()
+    try { await running } finally { running = null; inflight = [] }
+  }
+
+  // The block row's last_seen is touched every 10 minutes while the daemon runs (05); a row the
+  // server closed while the machine was away is opened again on the same square and paths.
+  const touch = async () => {
+    try { const r = await touchFolder(client, dir, findBlock(dir).block); st.block_id = r.block_id; st.last_touch_at = new Date().toISOString(); if (r.reopened) st.reopened_at = st.last_touch_at } catch (err) { st.last_error = err.message }
+  }
+  await rebuildNow()
+  await touch()
+  const schedule = () => { if (stopped) return; clearTimeout(timer); timer = setTimeout(() => { flush().catch(() => {}) }, debounceMs) }
+  const watcher = fs.watch(dir, { recursive: true }, (_ev, name) => {
+    if (!name) return
+    const rel = String(name).split(path.sep).join('/')
+    if (SKIP.has(rel.split('/')[0])) return
+    pending.add(rel)
+    schedule()
+  })
+  if (pending.size) schedule()
+  // A failed send tries again every 10 seconds; a head_moved one once the folder's head changes.
+  const retry = setInterval(() => {
+    if (!pending.size || running) return
+    if (st.state === 'head_moved' && (findBlock(dir)?.block.head || null) === st.head) return
+    if (st.state === 'retrying' && Date.now() < retryAt) return
+    flush().catch(() => {})
+  }, Math.max(debounceMs, 200))
+  retry.unref?.()
+  const toucher = setInterval(() => { touch() }, touchMs)
+  toucher.unref?.()
+
+  const token = crypto.randomBytes(24).toString('base64url')
+  // Waiting = not sent yet, including paths in a send that has not answered.
+  const status = () => ({ ...st, pending: [...new Set([...pending, ...inflight])].sort(), last_rebuild: lastRebuild })
+  const server = http.createServer(async (req, res) => {
+    const send = (code, body) => { res.writeHead(code, { 'content-type': 'application/json' }); res.end(JSON.stringify(body)) }
+    const given = Buffer.from(String(req.headers.authorization || ''))
+    const want = Buffer.from(`Bearer ${token}`)
+    if (given.length !== want.length || !crypto.timingSafeEqual(given, want)) return send(401, { error: 'This daemon needs its token (in ~/.seam/daemon).', code: 'unauthorized' })
+    const route = `${req.method} ${req.url.split('?')[0]}`
+    if (route === 'GET /status') return send(200, status())
+    if (route === 'POST /flush') { await flush(); return send(200, status()) }
+    if (route === 'POST /rebuild') { try { const r = await rebuildNow(); schedule(); return send(200, { ...r, status: status() }) } catch (err) { return send(500, { error: err.message, code: err.code || 'rebuild_failed' }) } }
+    if (route === 'POST /stop') { send(200, { stopping: true }); setImmediate(() => stop()); return }
+    send(404, { error: `No ${route} here: GET /status, POST /flush, POST /rebuild, POST /stop.`, code: 'not_found' })
+  })
+  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolve) })
+  const port = server.address().port
+  const file = daemonStatusFile(dir)
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 })
+  fs.writeFileSync(file, JSON.stringify({ pid: process.pid, port, token, dir }), { mode: 0o600 })
+  fs.chmodSync(file, 0o600)
+
+  let done = null
+  let ended
+  const endedP = new Promise((resolve) => { ended = resolve })
+  const stop = () => done || (done = (async () => {
+    stopped = true
+    clearTimeout(timer)
+    clearInterval(retry)
+    clearInterval(toucher)
+    watcher.close()
+    if (running) await running.catch(() => {})
+    try { if (JSON.parse(fs.readFileSync(file, 'utf8')).token === token) fs.rmSync(file) } catch {}
+    await new Promise((resolve) => { server.close(() => resolve()); server.closeAllConnections?.() })
+    ended()
+  })())
+  return { port, status, flush, stop, stopped: () => endedP }
+}