paperlint 14.4.0 → 14.6.0

package/skills/build-label-page/scripts/label-page-core.ts

@@ -280,7 +280,12 @@ const CARD_FIELDS: Readonly<Record<string, SchemaNode>> = {
   ),
   [READINGS_FIELD]: obj({ a: string(), b: string() }, true, false),
   file: string(false),
-  situation: optional({ summary: string(false), question: string() }),
+  situation: optional({
+    summary: string(false),
+    question: string(),
+    // the source tag over the summary (#400); the question is the page's own and gets none
+    from: string(false),
+  }),
   excerpt: optional({
     file: string(false),
     // the file's language, after its path: "path · Python"
@@ -304,8 +309,15 @@ const CARD_FIELDS: Readonly<Record<string, SchemaNode>> = {
     annotation: string(false),
     caption: string(false),
     mark_label: string(false),
+    // source tags (#400): over the code box, and over the caption under it
+    from: string(false),
+    caption_from: string(false),
+  }),
+  quote: optional({
+    text: string(),
+    source: string(false),
+    from: string(false),
   }),
-  quote: optional({ text: string(), source: string(false) }),
   terms: array(
     obj({
       term: string(),
@@ -451,6 +463,44 @@ const QUESTION_SCHEMA = obj({
   short: string(false),
   options: array(OPTION_SCHEMA, true, 2),
 });
+// Page-level words the blocks use (references/closed-choice-generator.md §«Content blocks»).
+const LABELS = optional({
+  place: string(false),
+  body: string(false),
+  line: string(false),
+  line_part: string(false),
+  repeat: string(false),
+  practice_example: string(false),
+  hidden: string(false),
+  hidden_one: string(false),
+  wait: string(false),
+  how_to: string(false),
+  for_example: string(false),
+});
+// The page's own words in another language (#394): never the quote, code, notes or any card text
+// the labeller judges. Keyed like the page, so a translation names its questions and answers by id.
+const TRANSLATION = obj({
+  title: string(false),
+  intro: string(false),
+  labels: LABELS,
+  // the first question as the cards with a `situation` ask it; `{n}` is the marked line's number
+  situation_question: string(false),
+  // the labels of the page's `sources`, by id; one left out reads as in the page's own language
+  sources: mapping(string(), NAME_PATTERN, 1, false),
+  questions: mapping(
+    obj({
+      text: string(),
+      short: string(false),
+      options: mapping(
+        obj({ label: string(), example: string(), ask_why: string(false) }),
+        NAME_PATTERN,
+        1,
+      ),
+    }),
+    NAME_PATTERN,
+    1,
+  ),
+});
 const configSchema = (kind: Kind): SchemaNode =>
   obj({
     study: string(true, NAME_PATTERN), // becomes a file name
@@ -471,18 +521,12 @@ const configSchema = (kind: Kind): SchemaNode =>
     questions: array(QUESTION_SCHEMA, true, 1),
     practice: array(practiceSchema(kind), true, MIN_PRACTICE),
     practice_round: integer(false),
-    // Page-level words the blocks use (references/closed-choice-generator.md §«Content blocks»).
-    labels: optional({
-      place: string(false),
-      body: string(false),
-      line: string(false),
-      line_part: string(false),
-      repeat: string(false),
-      practice_example: string(false),
-      hidden: string(false),
-      hidden_one: string(false),
-      wait: string(false),
-    }),
+    labels: LABELS,
+    // the source tags a card's blocks carry (#400): id → the tag's label, in colour order
+    sources: mapping(string(), NAME_PATTERN, 1, false),
+    // the language of the page's own words, and the same words in more languages, with a switch
+    lang: string(false, NAME_PATTERN),
+    translations: mapping(TRANSLATION, NAME_PATTERN, 1, false),
     items: array(itemSchema(kind), true, 1),
   });
 /** The declared schema (`schema` prints it): every field, those a kind requires left optional. */
@@ -655,6 +699,7 @@ interface Blocks {
   readonly situation?: {
     readonly summary?: string;
     readonly question: string;
+    readonly from?: string;
   };
   readonly excerpt?: {
     readonly file?: string;
@@ -665,8 +710,14 @@ interface Blocks {
     readonly annotation?: string;
     readonly caption?: string;
     readonly mark_label?: string;
+    readonly from?: string;
+    readonly caption_from?: string;
+  };
+  readonly quote?: {
+    readonly text: string;
+    readonly source?: string;
+    readonly from?: string;
   };
-  readonly quote?: { readonly text: string; readonly source?: string };
   readonly terms?: readonly Term[];
   readonly answer_notes?: Readonly<
     Record<string, Readonly<Record<string, string>>>
@@ -736,8 +787,34 @@ interface Config {
   readonly practice: readonly Practice[];
   readonly practice_round?: number;
   readonly labels?: Readonly<Record<string, string>>;
+  readonly sources?: Readonly<Record<string, string>>;
+  readonly lang?: string;
+  readonly translations?: Readonly<Record<string, Translation>>;
   readonly items: readonly Item[];
 }
+interface QuestionWords {
+  readonly text: string;
+  readonly short?: string;
+  readonly options: Readonly<
+    Record<
+      string,
+      {
+        readonly label: string;
+        readonly example: string;
+        readonly ask_why?: string;
+      }
+    >
+  >;
+}
+/** The page's own words in one more language (#394). */
+interface Translation {
+  readonly title?: string;
+  readonly intro?: string;
+  readonly labels?: Readonly<Record<string, string>>;
+  readonly situation_question?: string;
+  readonly sources?: Readonly<Record<string, string>>;
+  readonly questions: Readonly<Record<string, QuestionWords>>;
+}
 /** The config is typed by passing CONFIG_SCHEMA: `checkValue` refuses (throws) on any departure. */
 function assertConfig(value: Json): asserts value is Json & Config {
   checkValue(value, CONFIG_SCHEMA, "");
@@ -1004,6 +1081,65 @@ function checkBlocks(cfg: Config): void {
       );
   });
 }
+// ── source tags (#400) ────────────────────────────────────────────────────────────────────────
+/** The colours the page has for tags (`.tag.s0` to `.tag.s4` in page-template.html), in `sources` order. */
+export const SOURCE_COLOURS = 5;
+/** Each tag a card asks for: the path of the field that names it, the id it names, the text it sits over. */
+const tagsOf = (at: string, card: Card) => [
+  ...(card.quote?.from === undefined
+    ? []
+    : [{ at: `${at}.quote.from`, id: card.quote.from, over: "text" }]),
+  ...(card.situation?.from === undefined
+    ? []
+    : [
+        {
+          at: `${at}.situation.from`,
+          id: card.situation.from,
+          over: card.situation.summary,
+        },
+      ]),
+  ...(card.excerpt?.from === undefined
+    ? []
+    : [{ at: `${at}.excerpt.from`, id: card.excerpt.from, over: "box" }]),
+  ...(card.excerpt?.caption_from === undefined
+    ? []
+    : [
+        {
+          at: `${at}.excerpt.caption_from`,
+          id: card.excerpt.caption_from,
+          over: card.excerpt.caption,
+        },
+      ]),
+];
+/**
+ * What the schema cannot say about source tags: a tag names an id of the page's `sources`, over a
+ * text the card has, the page has colours for its ids, and an id nothing uses is a dead entry.
+ */
+function checkSources(cfg: Config): void {
+  const tags = cardsOf(cfg).flatMap(([at, card]) => tagsOf(at, card));
+  const ids = Object.keys(cfg.sources ?? {});
+  if (ids.length > SOURCE_COLOURS)
+    fail(
+      `sources: ${String(ids.length)} ids, and the page has ${String(SOURCE_COLOURS)} colours for tags — merge ids, or drop one`,
+    );
+  tags.forEach((t) => {
+    if (cfg.sources === undefined)
+      fail(
+        `${t.at}: names the source ${repr(t.id)}, and the page has no \`sources\` — add them, or take the tag out`,
+      );
+    else if (!has(cfg.sources, t.id))
+      fail(`${t.at}: ${repr(t.id)} is not in \`sources\` (${ids.join(", ")})`);
+    if (t.over === undefined)
+      fail(
+        `${t.at}: tags a text the card does not have — add it, or take the tag out`,
+      );
+  });
+  const dead = ids.find((id) => !tags.some((t) => t.id === id));
+  if (dead !== undefined)
+    fail(
+      `sources.${dead}: no item or practice item names it — a tag nothing carries is a dead entry`,
+    );
+}
 /**
  * The texts a term may open a note from, the words asked about first: the quote, its source, then
  * the excerpt's annotation. The page looks a term up in the same texts, split the same way at
@@ -1157,6 +1293,145 @@ function checkNoSourceShown(cfg: Config): void {
   }
 }
 
+// ── a second language for the page's own words (#394) ─────────────────────────────────────────
+/** The language of the page's own words when items.json does not name it. */
+const BASE_LANG = "en";
+/** In a translated `situation_question`, the number of the card's marked line. */
+const NUMBER_TOKEN = "{n}";
+/** A translated text is given exactly when the page shows the text it translates. */
+function checkPresence(
+  where: string,
+  shown: string | undefined,
+  given: string | undefined,
+): void {
+  if (shown !== undefined && given === undefined)
+    fail(`${where}: is required and missing — ${shown}`);
+  if (shown === undefined && given !== undefined)
+    fail(`${where}: is never shown — the page has no text it translates`);
+}
+/** The cards' first question, translated: given exactly when a card has a `situation`. */
+function checkSituationWords(cfg: Config, at: string, t: Translation): void {
+  const cards = cardsOf(cfg).filter(([, c]) => c.situation !== undefined);
+  const first = cards[0];
+  checkPresence(
+    `${at}.situation_question`,
+    first &&
+      `${first[0]}.situation asks the first question in the card's own words`,
+    t.situation_question,
+  );
+  const q = t.situation_question ?? "";
+  const bare = cards.find(([, c]) => lineOf(c) === undefined);
+  if (
+    bare !== undefined &&
+    [NUMBER_TOKEN, LINE_TOKEN].some((token) => q.includes(token))
+  )
+    fail(
+      `${at}.situation_question: names the marked line, and ${bare[0]} has no \`excerpt\` — add it, or write the question without \`${NUMBER_TOKEN}\` and \`${LINE_TOKEN}\``,
+    );
+}
+/** One answer in the translation's words; refused when the translation leaves it out. */
+const optionIn = (o: Option, words: QuestionWords, where: string): Option => {
+  const w =
+    words.options[o.value] ??
+    fail(
+      `${where}.options.${o.value}: is required and missing — every answer is translated`,
+    );
+  checkPresence(
+    `${where}.options.${o.value}.ask_why`,
+    o.ask_why && "this answer asks why",
+    w.ask_why,
+  );
+  return {
+    ...R.omit(o, ["ask_why"]),
+    label: w.label,
+    example: w.example,
+    ...R.pickBy({ ask_why: w.ask_why }, R.isDefined),
+  };
+};
+/** One question in the translation's words: every answer of it, no answer it does not have. */
+function questionIn(q: Question, t: Translation, at: string): Question {
+  const where = `${at}.questions.${q.id}`;
+  const words =
+    t.questions[q.id] ??
+    fail(
+      `${where}: is required and missing — every question of the page is translated`,
+    );
+  const values = q.options.map((o) => o.value);
+  const stray = Object.keys(words.options).find((v) => !values.includes(v));
+  if (stray !== undefined)
+    fail(`${where}.options.${stray}: not one of ${values.join(", ")}`);
+  const options = q.options.map((o) => optionIn(o, words, where));
+  const twice = firstRepeat(options.map((o) => o.label));
+  if (twice !== undefined)
+    fail(
+      `${where}.options.${String(values[twice.at])}.label: ${repr(options[twice.at]?.label)} reads the same as options.${String(values[twice.earlier])}.label — each button needs its own label`,
+    );
+  return {
+    id: q.id,
+    text: words.text,
+    ...R.pickBy({ short: words.short }, R.isDefined),
+    options,
+  };
+}
+/** A translated tag label names an id of the page's `sources`. */
+function checkTranslatedSources(cfg: Config, at: string, t: Translation): void {
+  const known = Object.keys(cfg.sources ?? {});
+  const stray = Object.keys(t.sources ?? {}).find((id) => !known.includes(id));
+  if (stray !== undefined)
+    fail(
+      `${at}.sources.${stray}: not one of the page's \`sources\` (${known.join(", ") || "none"})`,
+    );
+}
+/** The translated words a translation may leave out. */
+const optionalWords = (t: Translation) =>
+  R.pickBy(
+    { situation_question: t.situation_question, sources: t.sources },
+    R.isDefined,
+  );
+/**
+ * Every language of the page with its words whole, the translations checked: each covers every
+ * question and answer of the page and names none it does not have, and gives an intro, a reason
+ * prompt and a situation question exactly where the page shows one. A label it leaves out reads as
+ * in the page's own language.
+ */
+function translationsOf(cfg: Config) {
+  const base = cfg.lang ?? BASE_LANG;
+  return R.mapValues(cfg.translations ?? {}, (t, lang) => {
+    const at = `translations.${lang}`;
+    if (lang === base)
+      fail(
+        `${at}: is the page's own language (\`lang\` is ${repr(base)}) — translate into another one`,
+      );
+    checkPresence(
+      `${at}.intro`,
+      cfg.intro && "the page has an `intro`",
+      t.intro,
+    );
+    checkSituationWords(cfg, at, t);
+    checkTranslatedSources(cfg, at, t);
+    const ids = cfg.questions.map((q) => q.id);
+    const stray = Object.keys(t.questions).find((id) => !ids.includes(id));
+    if (stray !== undefined)
+      fail(
+        `${at}.questions.${stray}: not a question of this page (${ids.join(", ")})`,
+      );
+    return {
+      title: t.title ?? cfg.title,
+      intro: t.intro ?? "",
+      labels: { ...DEFAULT_LABELS, ...cfg.labels, ...t.labels },
+      ...optionalWords(t),
+      questions: cfg.questions.map((q) => questionIn(q, t, at)),
+    };
+  });
+}
+type Translated = ReturnType<typeof translationsOf>;
+/** The languages: the page's own when items.json names it, and with translations always (English when unnamed).
+ *  A page that names neither is as it was. */
+const languagesOf = (cfg: Config, translated: Translated) =>
+  cfg.translations === undefined
+    ? R.pickBy({ lang: cfg.lang }, R.isDefined)
+    : { lang: cfg.lang ?? BASE_LANG, translations: translated };
+
 // ── ids: neutral, in an order fixed by the seed, kept across rebuilds ─────────────────────────
 interface KeyEntry {
   readonly source_id: string;
@@ -1222,7 +1497,10 @@ const situationShown = (item: Card) =>
     ? {}
     : {
         situation: {
-          ...R.pickBy({ summary: item.situation.summary }, R.isDefined),
+          ...R.pickBy(
+            { summary: item.situation.summary, from: item.situation.from },
+            R.isDefined,
+          ),
           question: item.situation.question,
           ...(usesLine(item) ? { line: lineOf(item) } : {}),
         },
@@ -1320,7 +1598,19 @@ const DEFAULT_LABELS: Readonly<Record<string, string>> = {
   hidden: "lines {from}\u2013{to}",
   hidden_one: "line {from}",
   wait: "\u23f3 You can answer in {s} s",
+  how_to: "📖 How to answer",
+  for_example: "For example: ",
 };
+/** The tags' ids and labels in colour order, only when items.json has `sources`: a page without them is as it was. */
+const sourcesShown = (cfg: Config) =>
+  cfg.sources === undefined
+    ? {}
+    : {
+        sources: Object.entries(cfg.sources).map(([id, label]) => ({
+          id,
+          label,
+        })),
+      };
 /** The answerers and the dwell, only when items.json sets them: a page without them is as it was. */
 const twoKeys = (cfg: Config) =>
   R.pickBy(
@@ -1332,6 +1622,7 @@ function payloadOf(
   cfg: Config,
   page: ReturnType<typeof itemsOnPage>,
   described: Described,
+  translated: Translated,
 ) {
   const used = Object.keys(cfg.groups).filter((g) =>
     page.items.some((i) => i.group === g),
@@ -1340,6 +1631,7 @@ function payloadOf(
     title: cfg.title,
     intro: cfg.intro ?? "",
     labels: { ...DEFAULT_LABELS, ...cfg.labels },
+    ...sourcesShown(cfg),
     groups: used.map((g) => ({ id: g, label: String(cfg.groups[g]) })),
     familiarity_question: asksFamiliarity(cfg)
       ? (cfg.familiarity_question ?? "How well do you know {group}?")
@@ -1347,6 +1639,7 @@ function payloadOf(
     familiarity: asksFamiliarity(cfg) ? FAMILIARITY : [],
     allowed: allowedValues(cfg.questions, asksFamiliarity(cfg)),
     ...twoKeys(cfg),
+    ...languagesOf(cfg, translated),
     questions: cfg.questions,
     practice: {
       round: practiceRound(cfg),
@@ -1444,7 +1737,9 @@ export function prepareBuild(configPath: string, outDir: string) {
   checkUnits(cfg);
   checkBlocks(cfg);
   checkCardText(cfg);
+  checkSources(cfg);
   checkNoSourceShown(cfg);
+  const translated = translationsOf(cfg);
   const described = describeRules(cfg, dirname(configPath));
   mkdirSync(outDir, { recursive: true });
   const keyPath = join(outDir, "key.json");
@@ -1452,7 +1747,7 @@ export function prepareBuild(configPath: string, outDir: string) {
   const page = itemsOnPage(cfg, keyPath);
   writeJson(keyPath, keyOf(cfg, page, earlier));
   return {
-    payload: payloadOf(cfg, page, described),
+    payload: payloadOf(cfg, page, described, translated),
     dropped: cfg.items.length - page.items.length,
   };
 }

package/skills/build-label-page/scripts/label-page-sources.test.ts

@@ -0,0 +1,231 @@
+/**
+ * Source tags (#400): the page-level `sources`, the `from` and `caption_from` fields that name one,
+ * what the build refuses by path, and what the page is handed.
+ */
+import assert from "node:assert/strict";
+import { join } from "node:path";
+import { test } from "vitest";
+import { z } from "zod";
+import {
+  ITEMS,
+  PRACTICE,
+  build,
+  config,
+  run,
+  setup,
+} from "../../../test/label-page-kit.ts";
+
+const SOURCES = { repo: "From the repository", ours: "Our restatement" };
+const EXCERPT = { lines: [{ n: 3, text: "x = 1", mark: true }] };
+const [FIRST, SECOND, ...REST] = ITEMS;
+assert.ok(FIRST !== undefined && SECOND !== undefined);
+
+/** A page whose first two cards carry a quote, a situation and an excerpt, each tagged by `tags`. */
+function tagged(
+  tags: {
+    readonly quote?: string;
+    readonly situation?: string;
+    readonly excerpt?: string;
+    readonly caption?: string;
+  },
+  over: Record<string, unknown> = {},
+) {
+  return config({
+    sources: SOURCES,
+    items: [
+      {
+        ...FIRST,
+        quote: { text: "Use tabs", ...pick("from", tags.quote) },
+        situation: {
+          summary: "A reviewer objected.",
+          question: "Is line 3 right?",
+          ...pick("from", tags.situation),
+        },
+        excerpt: {
+          ...EXCERPT,
+          caption: "The reviewer wrote: no.",
+          ...pick("from", tags.excerpt),
+          ...pick("caption_from", tags.caption),
+        },
+      },
+      SECOND,
+      ...REST,
+    ],
+    ...over,
+  });
+}
+const pick = (key: string, value: string | undefined) =>
+  value === undefined ? {} : { [key]: value };
+const ALL = {
+  quote: "repo",
+  situation: "ours",
+  excerpt: "repo",
+  caption: "ours",
+};
+
+const Data = z
+  .object({
+    sources: z
+      .array(z.object({ id: z.string(), label: z.string() }))
+      .optional(),
+    items: z.array(z.record(z.string(), z.unknown())),
+  })
+  .loose();
+const dataOf = (page: string) =>
+  Data.parse(
+    JSON.parse(
+      String(
+        page
+          .split('<script type="application/json" id="data">')[1]
+          ?.split("</script>")[0],
+      ).replaceAll("<\\/", "</"),
+    ),
+  );
+
+test("🔴 sources and the four tags reach the page whole, in colour order; a page without sources carries none of it", () => {
+  const data = dataOf(build(setup("src-happy", tagged(ALL))).page);
+  assert.deepEqual(
+    [
+      data.sources,
+      ...["quote", "situation", "excerpt"].map(
+        (k) =>
+          z
+            .object({ from: z.string() })
+            .loose()
+            .parse(data.items.find((i) => k in i)?.[k]).from,
+      ),
+      z
+        .object({ caption_from: z.string() })
+        .loose()
+        .parse(data.items.find((i) => "excerpt" in i)?.["excerpt"])
+        .caption_from,
+    ],
+    [
+      [
+        { id: "repo", label: SOURCES.repo },
+        { id: "ours", label: SOURCES.ours },
+      ],
+      "repo",
+      "ours",
+      "repo",
+      "ours",
+    ],
+  );
+  const plain = build(setup("src-none", config())).page;
+  // Guards: no sources, no key on the page, so it is as it was.
+  assert.equal(Object.hasOwn(dataOf(plain), "sources"), false);
+  assert.equal(plain.includes('"from"'), false);
+});
+
+const PRACTICE_TAGGED = config({
+  sources: { repo: "From the repository" },
+  practice: [
+    {
+      body: "p",
+      quote: { text: "q", from: "repo" },
+      expected: { label: "yes", boundary: "clear" },
+      why: "w",
+    },
+    ...PRACTICE.slice(1),
+  ],
+});
+
+/** Pages the build refuses, each with its whole refusal. */
+const REFUSED: readonly (readonly [string, Record<string, unknown>, string])[] =
+  [
+    [
+      "src-no-sources",
+      config({
+        items: [
+          { ...FIRST, quote: { text: "t", from: "repo" } },
+          SECOND,
+          ...REST,
+        ],
+      }),
+      "items[0].quote.from: names the source 'repo', and the page has no `sources` — add them, or take the tag out",
+    ],
+    [
+      "src-unknown-id",
+      tagged({ quote: "repo", situation: "nope" }),
+      "items[0].situation.from: 'nope' is not in `sources` (repo, ours)",
+    ],
+    [
+      "src-unknown-caption",
+      tagged({ quote: "repo", caption: "nope" }),
+      "items[0].excerpt.caption_from: 'nope' is not in `sources` (repo, ours)",
+    ],
+    [
+      "src-dead-entry",
+      tagged({ quote: "repo" }, { sources: { ...SOURCES, spare: "Spare" } }),
+      "sources.ours: no item or practice item names it — a tag nothing carries is a dead entry",
+    ],
+    [
+      "src-empty-label",
+      tagged(
+        { quote: "repo", situation: "ours" },
+        { sources: { repo: "", ours: "O" } },
+      ),
+      "sources.repo: must be a non-empty string, got ''",
+    ],
+    [
+      "src-too-many",
+      tagged(
+        { quote: "a" },
+        { sources: Object.fromEntries("abcdef".split("").map((c) => [c, c])) },
+      ),
+      "sources: 6 ids, and the page has 5 colours for tags — merge ids, or drop one",
+    ],
+    [
+      "src-no-caption",
+      config({
+        sources: SOURCES,
+        items: [
+          { ...FIRST, excerpt: { ...EXCERPT, caption_from: "repo" } },
+          { ...SECOND, quote: { text: "t", from: "ours" } },
+          ...REST,
+        ],
+      }),
+      "items[0].excerpt.caption_from: tags a text the card does not have — add it, or take the tag out",
+    ],
+    [
+      "src-no-summary",
+      config({
+        sources: SOURCES,
+        items: [
+          {
+            ...FIRST,
+            situation: { question: "Is line 3 right?", from: "repo" },
+            excerpt: EXCERPT,
+          },
+          { ...SECOND, quote: { text: "t", from: "ours" } },
+          ...REST,
+        ],
+      }),
+      "items[0].situation.from: tags a text the card does not have — add it, or take the tag out",
+    ],
+  ];
+
+test("🔴 the build refuses a tag with no sources, an id not in sources, a dead entry, an empty label, more ids than colours, and a tag over a text the card lacks", () => {
+  assert.deepEqual(
+    REFUSED.map(([name, cfg]) => {
+      const dir = setup(name, cfg);
+      return run(["build", join(dir, "items.json"), join(dir, "out")]);
+    }),
+    REFUSED.map(([, , message]) => ({
+      status: 1,
+      out: `REFUSED: ${message}\n`,
+    })),
+  );
+});
+
+test("a practice item may carry a tag, and it counts as using the source", () => {
+  const { page } = build(
+    setup("src-practice", {
+      ...PRACTICE_TAGGED,
+      items: [{ ...FIRST }, ...ITEMS.slice(1)],
+    }),
+  );
+  assert.deepEqual(dataOf(page).sources, [
+    { id: "repo", label: "From the repository" },
+  ]);
+});