@shadevkumar/agent-wrapped 0.0.0-stage → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +25 -0
- package/README.md +71 -2
- package/dist/build.js +50 -0
- package/dist/cli.js +48 -0
- package/dist/files.js +114 -0
- package/dist/letter.js +64 -0
- package/dist/moments.js +324 -0
- package/dist/personality.js +65 -0
- package/dist/pricing.js +97 -0
- package/dist/sources/claude.js +139 -0
- package/dist/sources/codex.js +196 -0
- package/dist/story/fonts/OFL-Geist.txt +93 -0
- package/dist/story/fonts/OFL-Newsreader.txt +93 -0
- package/dist/story/fonts/geist-normal.woff2 +0 -0
- package/dist/story/fonts/newsreader-italic.woff2 +0 -0
- package/dist/story/fonts/newsreader-normal.woff2 +0 -0
- package/dist/story/index.html +318 -0
- package/dist/story/story.js +1274 -0
- package/dist/story.js +47 -0
- package/dist/types.js +33 -0
- package/dist/words.js +234 -0
- package/package.json +46 -4
package/dist/story.js
ADDED
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
// Phrases everyone types; a catchphrase should sound like this person.
|
|
2
|
+
const PLAIN_OPENINGS = /^(let me|tell me|can you|could you|what we|then we|i want|i need|do you|is there|we have|we need)\b/;
|
|
3
|
+
export function pickCatchphrase(list) {
|
|
4
|
+
return list.find((c) => !PLAIN_OPENINGS.test(c.text)) ?? null;
|
|
5
|
+
}
|
|
6
|
+
// A count this small isn't a habit yet.
|
|
7
|
+
const HABIT = 20;
|
|
8
|
+
export function storyData(w, personality, letter) {
|
|
9
|
+
const family = w.voice.typos.find((f) => f.spellings.length >= 5) ?? null;
|
|
10
|
+
const streak = w.rhythm.longestStreak;
|
|
11
|
+
const nickname = w.voice.nicknames[0] && w.voice.nicknames[0].count >= HABIT ? w.voice.nicknames[0] : null;
|
|
12
|
+
const please = w.voice.lexicon.please ?? 0;
|
|
13
|
+
const thanks = w.voice.lexicon.thanks ?? 0;
|
|
14
|
+
const wk = w.work;
|
|
15
|
+
return {
|
|
16
|
+
range: w.totals.firstDay && w.totals.lastDay ? { from: w.totals.firstDay, to: w.totals.lastDay } : null,
|
|
17
|
+
prompts: w.totals.prompts,
|
|
18
|
+
activeDays: w.totals.activeDays,
|
|
19
|
+
sessions: w.totals.sessions,
|
|
20
|
+
topTypo: w.voice.topTypo && w.voice.topTypo.count >= 10 ? w.voice.topTypo : null,
|
|
21
|
+
spellings: family ? { word: family.word, spellings: family.spellings.map((s) => s.spelling) } : null,
|
|
22
|
+
slip: w.voice.keySlips.neighbours[0] && w.voice.keySlips.neighbours[0].count >= 10 ? w.voice.keySlips.neighbours[0] : null,
|
|
23
|
+
topPrompts: w.voice.topPrompts.slice(0, 4),
|
|
24
|
+
catchphrase: pickCatchphrase(w.voice.catchphrases),
|
|
25
|
+
night: w.rhythm.lateNight.latest && w.rhythm.lateNight.prompts >= 5
|
|
26
|
+
? { latest: w.rhythm.lateNight.latest, prompts: w.rhythm.lateNight.prompts }
|
|
27
|
+
: null,
|
|
28
|
+
streak: streak && streak.days >= 5 ? streak : null,
|
|
29
|
+
agents: w.totals.prompts
|
|
30
|
+
? {
|
|
31
|
+
claude: w.loyalty.claudeShare,
|
|
32
|
+
codex: w.loyalty.codexShare,
|
|
33
|
+
hours: w.totals.agentHours,
|
|
34
|
+
bothDays: w.loyalty.bothAgentDays,
|
|
35
|
+
}
|
|
36
|
+
: null,
|
|
37
|
+
money: w.cost.atLeastUsd >= 1 ? { atLeastUsd: w.cost.atLeastUsd, pricesAsOf: w.cost.pricesAsOf } : null,
|
|
38
|
+
talk: nickname || please + thanks >= HABIT || w.voice.checkIns >= HABIT
|
|
39
|
+
? { nickname, please, thanks, checkIns: w.voice.checkIns }
|
|
40
|
+
: null,
|
|
41
|
+
work: wk.since && wk.tests + wk.commits >= 10
|
|
42
|
+
? { since: wk.since, tests: wk.tests, commits: wk.commits, stops: wk.stops, languages: wk.languages.slice(0, 2).map((l) => l.name) }
|
|
43
|
+
: null,
|
|
44
|
+
personality,
|
|
45
|
+
letter,
|
|
46
|
+
};
|
|
47
|
+
}
|
package/dist/types.js
ADDED
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
// Everything read from disk lands in a Harvest. A Harvest is private: it holds
|
|
2
|
+
// raw prompt text and never leaves the process. Only `share.ts` output is safe
|
|
3
|
+
// to show or export.
|
|
4
|
+
export function usageTokens(u) {
|
|
5
|
+
return u.input + u.cacheRead + u.cacheWrite + u.cacheWrite1h + u.output;
|
|
6
|
+
}
|
|
7
|
+
// Commands that run a project's tests, and ones that make a commit.
|
|
8
|
+
const TEST_COMMAND = /\b(pytest|vitest|jest|mocha|go test|cargo test|npm (run )?test|pnpm (run )?test|yarn test|bun test|node --test|tests?\.sh|phpunit|rspec)\b/;
|
|
9
|
+
const COMMIT_COMMAND = /\bgit commit\b/;
|
|
10
|
+
export function commandKind(command) {
|
|
11
|
+
if (COMMIT_COMMAND.test(command))
|
|
12
|
+
return "commit";
|
|
13
|
+
if (TEST_COMMAND.test(command))
|
|
14
|
+
return "test";
|
|
15
|
+
return null;
|
|
16
|
+
}
|
|
17
|
+
export function emptyHarvest() {
|
|
18
|
+
return { prompts: [], usage: [], totals: [], turns: [], actions: [], coverage: [], privateNames: new Set() };
|
|
19
|
+
}
|
|
20
|
+
export function mergeHarvests(parts) {
|
|
21
|
+
const out = emptyHarvest();
|
|
22
|
+
for (const p of parts) {
|
|
23
|
+
out.prompts.push(...p.prompts);
|
|
24
|
+
out.usage.push(...p.usage);
|
|
25
|
+
out.totals.push(...p.totals);
|
|
26
|
+
out.turns.push(...p.turns);
|
|
27
|
+
out.actions.push(...p.actions);
|
|
28
|
+
out.coverage.push(...p.coverage);
|
|
29
|
+
for (const n of p.privateNames)
|
|
30
|
+
out.privateNames.add(n);
|
|
31
|
+
}
|
|
32
|
+
return out;
|
|
33
|
+
}
|
package/dist/words.js
ADDED
|
@@ -0,0 +1,234 @@
|
|
|
1
|
+
import { existsSync, readFileSync } from "node:fs";
|
|
2
|
+
// Words and typos. Also the privacy gate: `safeQuote` decides which of the
|
|
3
|
+
// person's own words may appear on a card.
|
|
4
|
+
const SYSTEM_DICTIONARY = "/usr/share/dict/words";
|
|
5
|
+
// Everyday words the system dictionary (Webster's, 1934) doesn't know.
|
|
6
|
+
const MODERN = new Set(("okay ok hey yeah yep nope bro dude lol lmao pls plz thx btw gonna wanna gotta kinda " +
|
|
7
|
+
"email emails app apps api apis ui ux pr prs repo repos bug bugs code coding fix fixes " +
|
|
8
|
+
"online offline login logout signup website web dev devs frontend backend deploy deployed " +
|
|
9
|
+
"prod staging commit commits merge merged push pushed test tests tested lint debug debugging " +
|
|
10
|
+
"dashboard dashboards workflow workflows feature features screenshot screenshots tab tabs " +
|
|
11
|
+
"chat chats chatbot bot bots ai llm prompt prompts token tokens model models agent agents " +
|
|
12
|
+
"data database json url urls link links laptop smartphone video videos " +
|
|
13
|
+
"async await sync config configs env auth oauth cli npm yaml regex cron webhook webhooks " +
|
|
14
|
+
"param params args arg enum const func init pre repo localhost wifi admin").split(" "));
|
|
15
|
+
// Words too plain to make a catchphrase on their own.
|
|
16
|
+
const STOPWORDS = new Set("a an the to of in on at for and or is are was be it this that i you we me my your with as do so if".split(" "));
|
|
17
|
+
export class Words {
|
|
18
|
+
dict;
|
|
19
|
+
blocked;
|
|
20
|
+
// `names` are private names (folders, repos, orgs) that never appear in a
|
|
21
|
+
// quote. A name is always blocked; its parts ("acme" in "acme-portal") are
|
|
22
|
+
// blocked unless they are everyday words ("the" in "bridge-the-gap").
|
|
23
|
+
constructor(names, dict) {
|
|
24
|
+
this.dict = dict ?? loadDictionary(SYSTEM_DICTIONARY);
|
|
25
|
+
this.blocked = new Set();
|
|
26
|
+
for (const name of names) {
|
|
27
|
+
const lower = name.toLowerCase();
|
|
28
|
+
this.blocked.add(lower);
|
|
29
|
+
for (const part of lower.split(/[-_.]/)) {
|
|
30
|
+
if (part.length >= 3 && part !== lower && !this.isKnown(part))
|
|
31
|
+
this.blocked.add(part);
|
|
32
|
+
}
|
|
33
|
+
}
|
|
34
|
+
}
|
|
35
|
+
isBlocked(word) {
|
|
36
|
+
return this.blocked.has(word);
|
|
37
|
+
}
|
|
38
|
+
// A real everyday word, including plain inflections the dictionary lacks.
|
|
39
|
+
isKnown(word) {
|
|
40
|
+
if (this.dict.has(word) || MODERN.has(word))
|
|
41
|
+
return true;
|
|
42
|
+
for (const base of baseForms(word)) {
|
|
43
|
+
if (this.dict.has(base) || MODERN.has(base))
|
|
44
|
+
return true;
|
|
45
|
+
}
|
|
46
|
+
return false;
|
|
47
|
+
}
|
|
48
|
+
// A quote is safe when every word is a known word or a known typo of one,
|
|
49
|
+
// and none is a private name. Anything else (names, jargon, ids) drops the quote.
|
|
50
|
+
safeQuote(text, typos) {
|
|
51
|
+
const words = tokenize(text);
|
|
52
|
+
if (words.length === 0 || words.length > 12)
|
|
53
|
+
return null;
|
|
54
|
+
for (const w of words) {
|
|
55
|
+
if (this.isBlocked(w))
|
|
56
|
+
return null;
|
|
57
|
+
const canonical = typos.get(w);
|
|
58
|
+
if (canonical && !this.isBlocked(canonical))
|
|
59
|
+
continue;
|
|
60
|
+
if (!this.isKnown(w))
|
|
61
|
+
return null;
|
|
62
|
+
}
|
|
63
|
+
return words.join(" ");
|
|
64
|
+
}
|
|
65
|
+
isStopword(word) {
|
|
66
|
+
return STOPWORDS.has(word);
|
|
67
|
+
}
|
|
68
|
+
}
|
|
69
|
+
export function loadDictionary(path) {
|
|
70
|
+
if (!existsSync(path))
|
|
71
|
+
return new Set();
|
|
72
|
+
const words = new Set();
|
|
73
|
+
for (const line of readFileSync(path, "utf8").split("\n")) {
|
|
74
|
+
// Capitalized entries are names, so they are left out.
|
|
75
|
+
if (line && line === line.toLowerCase())
|
|
76
|
+
words.add(line);
|
|
77
|
+
}
|
|
78
|
+
return words;
|
|
79
|
+
}
|
|
80
|
+
// Lowercase words, after removing code, links, paths and addresses.
|
|
81
|
+
export function tokenize(text) {
|
|
82
|
+
const plain = text
|
|
83
|
+
.replace(/```[\s\S]*?```/g, " ")
|
|
84
|
+
.replace(/`[^`]*`/g, " ")
|
|
85
|
+
.replace(/\[([^\]]*)\]\([^)]*\)/g, " ")
|
|
86
|
+
.replace(/\b[\w.+-]+@[\w-]+\.[\w.]+\b/g, " ")
|
|
87
|
+
.replace(/\b(?:https?|ftp|file|plugin):\/\/\S+/gi, " ")
|
|
88
|
+
.replace(/\bwww\.\S+/gi, " ")
|
|
89
|
+
.replace(/(?:~|\.{1,2})?\/[\w./-]+/g, " ")
|
|
90
|
+
.replace(/\b[\w-]+\.(?:ts|tsx|js|py|md|json|html|css|sql|yml|yaml|toml|sh|txt)\b/gi, " ")
|
|
91
|
+
.toLowerCase();
|
|
92
|
+
return plain.match(/[a-z]+(?:'[a-z]+)?/g) ?? [];
|
|
93
|
+
}
|
|
94
|
+
function baseForms(w) {
|
|
95
|
+
const out = [];
|
|
96
|
+
const strip = (suffix) => (w.endsWith(suffix) && w.length > suffix.length + 2 ? w.slice(0, -suffix.length) : null);
|
|
97
|
+
for (const s of ["s", "es", "ed", "d", "ing", "ly", "er", "ers"]) {
|
|
98
|
+
const b = strip(s);
|
|
99
|
+
if (!b)
|
|
100
|
+
continue;
|
|
101
|
+
out.push(b, b + "e");
|
|
102
|
+
// stopped -> stop, running -> run
|
|
103
|
+
if (b.length > 2 && b.at(-1) === b.at(-2))
|
|
104
|
+
out.push(b.slice(0, -1));
|
|
105
|
+
}
|
|
106
|
+
const ies = strip("ies");
|
|
107
|
+
if (ies)
|
|
108
|
+
out.push(ies + "y");
|
|
109
|
+
const ied = strip("ied");
|
|
110
|
+
if (ied)
|
|
111
|
+
out.push(ied + "y");
|
|
112
|
+
return out;
|
|
113
|
+
}
|
|
114
|
+
const ROWS = ["qwertyuiop", "asdfghjkl", "zxcvbnm"];
|
|
115
|
+
const KEY_POS = new Map();
|
|
116
|
+
ROWS.forEach((row, r) => [...row].forEach((ch, c) => KEY_POS.set(ch, [r, c + r * 0.5])));
|
|
117
|
+
function adjacentKeys(a, b) {
|
|
118
|
+
const pa = KEY_POS.get(a);
|
|
119
|
+
const pb = KEY_POS.get(b);
|
|
120
|
+
if (!pa || !pb || a === b)
|
|
121
|
+
return false;
|
|
122
|
+
return Math.abs(pa[0] - pb[0]) <= 1 && Math.abs(pa[1] - pb[1]) <= 1;
|
|
123
|
+
}
|
|
124
|
+
// How `typed` is `intended` with one slip of the fingers: two letters
|
|
125
|
+
// swapped, a neighbouring key hit instead, a letter missed, or a stray
|
|
126
|
+
// neighbouring/doubled key added. Other one-letter differences are usually
|
|
127
|
+
// different words ("code" / "codex"), so they return null.
|
|
128
|
+
export function fingerSlip(intended, typed) {
|
|
129
|
+
if (intended === typed)
|
|
130
|
+
return null;
|
|
131
|
+
const a = intended;
|
|
132
|
+
const b = typed;
|
|
133
|
+
if (a.length === b.length) {
|
|
134
|
+
const diff = [];
|
|
135
|
+
for (let i = 0; i < a.length; i++)
|
|
136
|
+
if (a[i] !== b[i])
|
|
137
|
+
diff.push(i);
|
|
138
|
+
if (diff.length === 1) {
|
|
139
|
+
const meant = a[diff[0]];
|
|
140
|
+
const hit = b[diff[0]];
|
|
141
|
+
return a.length >= 4 && adjacentKeys(meant, hit) ? { kind: "neighbour", meant, hit } : null;
|
|
142
|
+
}
|
|
143
|
+
if (diff.length === 2) {
|
|
144
|
+
const [i, j] = diff;
|
|
145
|
+
return j === i + 1 && a[i] === b[j] && a[j] === b[i] ? { kind: "swap" } : null;
|
|
146
|
+
}
|
|
147
|
+
return null;
|
|
148
|
+
}
|
|
149
|
+
if (a.length < 4)
|
|
150
|
+
return null;
|
|
151
|
+
if (b.length === a.length - 1) {
|
|
152
|
+
for (let i = 0; i < a.length; i++)
|
|
153
|
+
if (a.slice(0, i) + a.slice(i + 1) === b)
|
|
154
|
+
return { kind: "missed", meant: a[i] };
|
|
155
|
+
return null;
|
|
156
|
+
}
|
|
157
|
+
if (b.length === a.length + 1) {
|
|
158
|
+
for (let i = 0; i < b.length; i++) {
|
|
159
|
+
if (b.slice(0, i) + b.slice(i + 1) !== a)
|
|
160
|
+
continue;
|
|
161
|
+
const hit = b[i];
|
|
162
|
+
const left = b[i - 1];
|
|
163
|
+
const right = b[i + 1];
|
|
164
|
+
if (hit === left || hit === right)
|
|
165
|
+
return { kind: "extra", hit };
|
|
166
|
+
if ((left && adjacentKeys(hit, left)) || (right && adjacentKeys(hit, right)))
|
|
167
|
+
return { kind: "extra", hit };
|
|
168
|
+
}
|
|
169
|
+
}
|
|
170
|
+
return null;
|
|
171
|
+
}
|
|
172
|
+
export function isFingerSlip(intended, typed) {
|
|
173
|
+
return fingerSlip(intended, typed) !== null;
|
|
174
|
+
}
|
|
175
|
+
// Adds up every slip inside the typo families, weighted by how often each spelling was typed.
|
|
176
|
+
export function keySlips(families) {
|
|
177
|
+
const pairs = new Map();
|
|
178
|
+
const out = { neighbours: [], swaps: 0, missed: 0, extra: 0 };
|
|
179
|
+
for (const fam of families) {
|
|
180
|
+
for (const { spelling, count } of fam.spellings) {
|
|
181
|
+
const slip = fingerSlip(fam.word, spelling);
|
|
182
|
+
if (!slip)
|
|
183
|
+
continue;
|
|
184
|
+
if (slip.kind === "neighbour") {
|
|
185
|
+
const key = slip.meant + slip.hit;
|
|
186
|
+
pairs.set(key, (pairs.get(key) ?? 0) + count);
|
|
187
|
+
}
|
|
188
|
+
else if (slip.kind === "swap")
|
|
189
|
+
out.swaps += count;
|
|
190
|
+
else if (slip.kind === "missed")
|
|
191
|
+
out.missed += count;
|
|
192
|
+
else
|
|
193
|
+
out.extra += count;
|
|
194
|
+
}
|
|
195
|
+
}
|
|
196
|
+
out.neighbours = [...pairs]
|
|
197
|
+
.map(([k, count]) => ({ meant: k[0], hit: k[1], count }))
|
|
198
|
+
.sort((x, y) => y.count - x.count)
|
|
199
|
+
.slice(0, 5);
|
|
200
|
+
return out;
|
|
201
|
+
}
|
|
202
|
+
// Groups unknown spellings under the common word they were meant to be.
|
|
203
|
+
export function findTypos(counts, words) {
|
|
204
|
+
const common = [...counts.entries()]
|
|
205
|
+
.filter(([w, n]) => n >= 5 && w.length >= 3 && words.isKnown(w) && !words.isBlocked(w))
|
|
206
|
+
.sort((x, y) => y[1] - x[1]);
|
|
207
|
+
const byFirst = new Map();
|
|
208
|
+
for (const entry of common) {
|
|
209
|
+
const list = byFirst.get(entry[0][0]) ?? [];
|
|
210
|
+
list.push(entry);
|
|
211
|
+
byFirst.set(entry[0][0], list);
|
|
212
|
+
}
|
|
213
|
+
const canonical = new Map();
|
|
214
|
+
const families = new Map();
|
|
215
|
+
for (const [typed, n] of counts) {
|
|
216
|
+
if (typed.length < 3 || words.isKnown(typed) || words.isBlocked(typed))
|
|
217
|
+
continue;
|
|
218
|
+
// Most frequent match wins; a "typo" as common as the word is a word of its own.
|
|
219
|
+
// The second letter's list catches swapped first letters ("hte").
|
|
220
|
+
const candidates = [...(byFirst.get(typed[0]) ?? []), ...(byFirst.get(typed[1]) ?? [])].sort((x, y) => y[1] - x[1]);
|
|
221
|
+
const match = candidates.find(([w, wn]) => n * 3 <= wn && isFingerSlip(w, typed));
|
|
222
|
+
if (!match)
|
|
223
|
+
continue;
|
|
224
|
+
canonical.set(typed, match[0]);
|
|
225
|
+
const fam = families.get(match[0]) ?? { word: match[0], spellings: [], total: 0 };
|
|
226
|
+
fam.spellings.push({ spelling: typed, count: n });
|
|
227
|
+
fam.total += n;
|
|
228
|
+
families.set(match[0], fam);
|
|
229
|
+
}
|
|
230
|
+
for (const fam of families.values())
|
|
231
|
+
fam.spellings.sort((x, y) => y.count - x.count);
|
|
232
|
+
const ranked = [...families.values()].sort((x, y) => y.spellings.length - x.spellings.length || y.total - x.total);
|
|
233
|
+
return { families: ranked, canonical };
|
|
234
|
+
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,48 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@shadevkumar/agent-wrapped",
|
|
3
|
-
"version": "0.
|
|
4
|
-
"
|
|
5
|
-
"
|
|
6
|
-
|
|
3
|
+
"version": "0.2.0",
|
|
4
|
+
"description": "Your year with AI coding agents, played back in keyboard keys. Reads Claude Code and Codex logs on your computer.",
|
|
5
|
+
"keywords": [
|
|
6
|
+
"claude-code",
|
|
7
|
+
"codex",
|
|
8
|
+
"ai",
|
|
9
|
+
"wrapped",
|
|
10
|
+
"year-in-review",
|
|
11
|
+
"cli"
|
|
12
|
+
],
|
|
13
|
+
"homepage": "https://agent-wrapped.shadev.space/",
|
|
14
|
+
"repository": {
|
|
15
|
+
"type": "git",
|
|
16
|
+
"url": "git+https://github.com/shadevkumar/agent-wrapped.git"
|
|
17
|
+
},
|
|
18
|
+
"bugs": {
|
|
19
|
+
"url": "https://github.com/shadevkumar/agent-wrapped/issues"
|
|
20
|
+
},
|
|
21
|
+
"author": "Shadev Kumar",
|
|
22
|
+
"license": "MIT",
|
|
23
|
+
"publishConfig": {
|
|
24
|
+
"access": "public"
|
|
25
|
+
},
|
|
26
|
+
"type": "module",
|
|
27
|
+
"bin": {
|
|
28
|
+
"agent-wrapped": "dist/cli.js"
|
|
29
|
+
},
|
|
30
|
+
"files": [
|
|
31
|
+
"dist"
|
|
32
|
+
],
|
|
33
|
+
"engines": {
|
|
34
|
+
"node": ">=22.13"
|
|
35
|
+
},
|
|
36
|
+
"scripts": {
|
|
37
|
+
"dev": "node --disable-warning=ExperimentalWarning src/cli.ts",
|
|
38
|
+
"test": "TZ=UTC node --test --disable-warning=ExperimentalWarning 'test/**/*.test.ts'",
|
|
39
|
+
"typecheck": "tsc --noEmit",
|
|
40
|
+
"build": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json && node -e \"require('fs').cpSync('src/story', 'dist/story', { recursive: true })\"",
|
|
41
|
+
"prepack": "npm run build",
|
|
42
|
+
"build:player": "node --disable-warning=ExperimentalWarning scripts/build-player.ts"
|
|
43
|
+
},
|
|
44
|
+
"devDependencies": {
|
|
45
|
+
"@types/node": "^26.6.5",
|
|
46
|
+
"typescript": "^7.0.2"
|
|
47
|
+
}
|
|
48
|
+
}
|