@codyswann/lisa 4.73.9 → 4.74.1

package/expo/copy-overwrite/jest.setup.pre.js

@@ -66,8 +66,22 @@ global.nativeFabricUIManager = {};
 // Mock TurboModuleRegistry using external mock configuration
 const mockModules = require("./jest.config.react-native-mock");
 
+// Baseline native modules needed to load real View/Text under Jest. These
+// fallbacks also support older project-owned registries without editing them.
+// SourceCode matches @react-native/jest-preset's null scriptURL unit seam;
+// PaperUIManager reads getConstants during initialization, with no native views.
+const defaultMockModules = {
+  SourceCode: { getConstants: () => ({ scriptURL: null }) },
+  UIManager: { getConstants: () => ({}) },
+};
+
 global.__turboModuleProxy = function (moduleName) {
-  return mockModules[moduleName] || null;
+  return (
+    mockModules[moduleName] ??
+    (Object.hasOwn(defaultMockModules, moduleName)
+      ? defaultMockModules[moduleName]
+      : null)
+  );
 };
 
 // Ensure global timers are available (required by @testing-library/react-native)

package/expo/copy-overwrite/scripts/bdd/ci-summary.mjs

@@ -0,0 +1,37 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Publish the calculated aggregate from the same run that sets the CLI exit. */
+import * as fs from "node:fs";
+
+import { cell } from "./markdown-cell.mjs";
+import { renderBurndown } from "./render.mjs";
+
+/**
+ * Append a native GitHub job summary without rerunning or weakening the gate.
+ * Invalid input has no trustworthy totals, even if diagnostic data exists.
+ * @param {object} gateRun - Actual report, final status and original defects.
+ * @param {string|undefined} destination - Native GITHUB_STEP_SUMMARY path.
+ * @returns {void}
+ */
+export function appendCiSummary(gateRun, destination) {
+  if (!destination) return;
+  const aggregate =
+    gateRun.report && gateRun.status !== "invalid"
+      ? renderBurndown(gateRun.report).trim()
+      : "**Global totals unavailable:** the behavior contract could not be evaluated.";
+  const findings = gateRun.defects.length
+    ? [
+        "| Finding | Detail |",
+        "|---|---|",
+        ...gateRun.defects.map(
+          item => `| ${cell(item.code)} | ${cell(item.message)} |`
+        ),
+      ].join("\n")
+    : "No findings.";
+  fs.appendFileSync(
+    destination,
+    `\n### BDD aggregate result: ${cell(gateRun.status)}\n\n${aggregate}\n\n${findings}\n`,
+    "utf8"
+  );
+}

package/expo/copy-overwrite/scripts/bdd/projection-model.mjs

@@ -0,0 +1,157 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Feature-local facts, sharing the gate's genuine evidence and result joins. */
+import { byCodeUnit, trackerUrl } from "./contract.mjs";
+import { indexResults } from "./report.mjs";
+import { evidenceResolves } from "./validate.mjs";
+import {
+  FEATURE_PROJECTION_SCHEMA,
+  PROJECTION_GENERATOR,
+  projectionSourceFile,
+  validateProjectionCollisions,
+} from "./projection-paths.mjs";
+
+/** Malformed optional collections remain the original validator's concern. */
+const list = value => (Array.isArray(value) ? value : []);
+/** Stable local vocabulary without modifying the parsed declaration. */
+const words = value => [...list(value)].sort(byCodeUnit);
+/** Preserve complete associated records instead of substituting a boolean. */
+const recordsFor = (records, id) =>
+  list(records).filter(
+    record =>
+      record !== null && typeof record === "object" && record.scenario === id
+  );
+
+/** Avoid crashing reportable red input solely while constructing its paperwork. */
+function referenceUrl(reference, trackers) {
+  if (
+    reference.scheme !== "gh" &&
+    typeof trackers?.keyUrlTemplate !== "string"
+  ) {
+    return null;
+  }
+  return trackerUrl(reference, trackers);
+}
+
+/** Preserve supplied/absent/not-run and the original worst-result precedence. */
+function mappingExecution(mapping, results, supplied) {
+  if (!supplied)
+    return { supplied: false, status: "not supplied", runId: null };
+  const result = results.get(
+    `${mapping.runner}|${mapping.file}|${mapping.evidence}`
+  );
+  return {
+    supplied: true,
+    status: result?.status ?? "not run",
+    runId: result?.runId ?? null,
+  };
+}
+
+/** Keep every declared mapping and its actual evidence verdict visible. */
+function mappingRows(root, scenario, context) {
+  return recordsFor(context.contract.mappings, scenario.id)
+    .map(mapping => ({
+      ...mapping,
+      scenario: mapping.scenario ?? null,
+      runner: mapping.runner ?? null,
+      file: mapping.file ?? null,
+      evidence: mapping.evidence ?? null,
+      platforms: words(mapping.platforms),
+      evidenceResolution: evidenceResolves(root, mapping, context.cache),
+      execution: mappingExecution(mapping, context.results, context.supplied),
+    }))
+    .sort((left, right) =>
+      byCodeUnit(
+        JSON.stringify([left.runner, left.file, left.evidence, left.platforms]),
+        JSON.stringify([
+          right.runner,
+          right.file,
+          right.evidence,
+          right.platforms,
+        ])
+      )
+    );
+}
+
+/** A waiver is outside the obligation denominator and is never coverage. */
+function obligation(platform, mappings, waivers, runnerPlatforms) {
+  const waived = waivers.some(record =>
+    list(record.platforms).includes(platform)
+  );
+  const covered =
+    !waived &&
+    mappings.some(
+      mapping =>
+        mapping.platforms.includes(platform) && mapping.evidenceResolution.ok
+    );
+  const runners = Object.keys(runnerPlatforms ?? {})
+    .filter(runner => list(runnerPlatforms[runner]).includes(platform))
+    .sort(byCodeUnit);
+  return { platform, runners, covered, waived, gap: !covered && !waived };
+}
+
+/** One complete scenario row; no global tally, inventory or run roster. */
+function scenarioRow(root, scenario, context) {
+  const mappings = mappingRows(root, scenario, context);
+  const waivers = recordsFor(context.contract.platformWaivers, scenario.id);
+  return {
+    id: scenario.id ?? null,
+    name: scenario.name,
+    feature: scenario.feature,
+    line: scenario.line,
+    featureLine: scenario.featureLine,
+    tags: words(scenario.tags),
+    ownTags: words(scenario.ownTags),
+    inheritedTags: words(scenario.inheritedTags),
+    featureIdTags: words(scenario.featureIdTags),
+    platforms: words(scenario.platforms),
+    lifecycle: words(scenario.lifecycle),
+    required: scenario.required,
+    provenance: words(scenario.provenance),
+    trackers: list(scenario.trackers)
+      .map(reference => ({
+        ...reference,
+        url: referenceUrl(reference, context.contract.trackers),
+      }))
+      .sort((left, right) => byCodeUnit(left.tag, right.tag)),
+    primarySteps: [...list(scenario.primarySteps)],
+    mappings,
+    obligations: scenario.required
+      ? words(scenario.platforms).map(platform =>
+          obligation(
+            platform,
+            mappings,
+            waivers,
+            context.contract.runnerPlatforms
+          )
+        )
+      : [],
+    waivers,
+    retirements: recordsFor(context.contract.retirements, scenario.id),
+  };
+}
+
+/** Group by source path, never by a potentially duplicate Feature title. */
+export function buildFeatureModels(
+  root,
+  { contract, scenarios, runs = [], cache = new Map() }
+) {
+  const sourcePaths = [...new Set(scenarios.map(scenario => scenario.file))];
+  validateProjectionCollisions(sourcePaths);
+  const context = {
+    contract,
+    cache,
+    results: indexResults(runs),
+    supplied: runs.length > 0,
+  };
+  return sourcePaths.sort(byCodeUnit).map(sourceFile => ({
+    schemaVersion: FEATURE_PROJECTION_SCHEMA,
+    generator: PROJECTION_GENERATOR,
+    sourceFile: projectionSourceFile(sourceFile),
+    scenarios: scenarios
+      .filter(scenario => scenario.file === sourceFile)
+      .sort((left, right) => left.line - right.line)
+      .map(scenario => scenarioRow(root, scenario, context)),
+  }));
+}

package/expo/copy-overwrite/scripts/bdd/projection-ownership.mjs

@@ -0,0 +1,300 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Refuse ambiguous ownership before writing or removing any generated leaf. */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  FEATURE_PROJECTION_SCHEMA,
+  PROJECTION_GENERATOR,
+  PROJECTION_DIRECTORIES,
+  featureArtifactPaths,
+  inspectProjectionPath,
+  listProjectionPaths,
+  projectionStat,
+  refuseProjection,
+  validateProjectionCollisions,
+} from "./projection-paths.mjs";
+import {
+  STATIC_ARTIFACTS,
+  MATRIX_COMMAND,
+  COVERAGE_COMMAND,
+  PROJECTION_INDEX_SCHEMA,
+  REPORT_COMMAND,
+  AGGREGATE_MATRIX_COMMAND,
+} from "./projection-render.mjs";
+
+const MATRIX_TITLE = "# BDD scenario traceability matrix\n";
+
+/** Unknown JSON is preserved; desired occupation is rejected separately. */
+function parseJson(body) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return null;
+  }
+}
+
+/** Structural checks identify the versioned complete-local format. */
+function validScenario(row) {
+  const arrays = [
+    "tags",
+    "ownTags",
+    "inheritedTags",
+    "featureIdTags",
+    "platforms",
+    "lifecycle",
+    "provenance",
+    "trackers",
+    "primarySteps",
+    "mappings",
+    "obligations",
+    "waivers",
+    "retirements",
+  ];
+  if (
+    !row ||
+    typeof row !== "object" ||
+    !arrays.every(key => Array.isArray(row[key]))
+  )
+    return false;
+  if (
+    typeof row.name !== "string" ||
+    typeof row.feature !== "string" ||
+    typeof row.required !== "boolean"
+  )
+    return false;
+  if (!Number.isInteger(row.line) || !Number.isInteger(row.featureLine))
+    return false;
+  return (
+    row.mappings.every(
+      mapping =>
+        mapping?.evidenceResolution &&
+        typeof mapping.evidenceResolution.ok === "boolean" &&
+        typeof mapping.execution?.supplied === "boolean" &&
+        Array.isArray(mapping.platforms)
+    ) &&
+    row.obligations.every(
+      value =>
+        typeof value?.platform === "string" &&
+        [value.covered, value.waived, value.gap].every(
+          flag => typeof flag === "boolean"
+        )
+    )
+  );
+}
+
+/** A claimed schema is never treated as anonymous handwritten content. */
+function jsonOwnership(relative, body) {
+  const value = parseJson(body);
+  const claimed =
+    value?.generator === PROJECTION_GENERATOR ||
+    String(value?.schemaVersion ?? "").startsWith(
+      "lisa-bdd-feature-projection-"
+    );
+  if (!claimed) return false;
+  if (
+    value.schemaVersion !== FEATURE_PROJECTION_SCHEMA ||
+    value.generator !== PROJECTION_GENERATOR ||
+    !Array.isArray(value.scenarios) ||
+    !value.scenarios.every(validScenario)
+  ) {
+    refuseProjection(`unknown or malformed owned JSON schema: ${relative}`);
+  }
+  if (featureArtifactPaths(value.sourceFile)[0] !== relative) {
+    refuseProjection(`JSON ownership/source path mismatch: ${relative}`);
+  }
+  return true;
+}
+
+/** Markdown markers encode their source and distinguish the two document kinds. */
+function markdownOwnership(relative, body) {
+  if (!body.startsWith("<!-- lisa-bdd-feature-projection-")) return false;
+  const marker =
+    /^<!-- (lisa-bdd-feature-projection-[^\s]+) (\S+) source=([^\s]+) -->\n/.exec(
+      body
+    );
+  if (
+    !marker ||
+    marker[1] !== FEATURE_PROJECTION_SCHEMA ||
+    !["matrix", "coverage"].includes(marker[2])
+  ) {
+    refuseProjection(`unknown or malformed owned Markdown schema: ${relative}`);
+  }
+  let source;
+  try {
+    source = decodeURIComponent(marker[3]);
+  } catch {
+    refuseProjection(`invalid Markdown source encoding: ${relative}`);
+  }
+  const index = marker[2] === "matrix" ? 1 : 2;
+  const title =
+    index === 1
+      ? MATRIX_TITLE
+      : "# BDD behavior contract — feature coverage burndown\n";
+  if (
+    featureArtifactPaths(source)[index] !== relative ||
+    !body.slice(marker[0].length).startsWith(title)
+  ) {
+    refuseProjection(`Markdown ownership/source path mismatch: ${relative}`);
+  }
+  return true;
+}
+
+/** Only explicit versioned leaves qualify for obsolete cleanup. */
+export function ownedFeatureLeaf(relative, body) {
+  return relative.endsWith(".json")
+    ? jsonOwnership(relative, body)
+    : markdownOwnership(relative, body);
+}
+
+/** Recognize the previous aggregate format, never arbitrary JSON at its path. */
+function legacyJson(body) {
+  const value = parseJson(body);
+  const objects = [
+    "scenarios",
+    "traceability",
+    "execution",
+    "testInventory",
+    "waived",
+    "floor",
+    "trackers",
+  ];
+  return (
+    value?.schemaVersion === 3 &&
+    objects.every(
+      key =>
+        value[key] &&
+        typeof value[key] === "object" &&
+        !Array.isArray(value[key])
+    ) &&
+    Array.isArray(value.gaps)
+  );
+}
+
+/** Migration is limited to canonical old headings, commands and content signatures. */
+function legacyEntrypoint(relative, body) {
+  if (relative === "bdd/coverage-report.json") return legacyJson(body);
+  if (relative === "docs/bdd-scenario-matrix.md") {
+    return (
+      body.startsWith(MATRIX_TITLE) &&
+      body.includes(`Generated by \`${MATRIX_COMMAND}\`; never hand-edited.`) &&
+      body.includes("scenarios declared")
+    );
+  }
+  return (
+    body.startsWith("# BDD behavior contract — coverage burndown\n") &&
+    body.includes(
+      "Generated from `bdd/features/*.feature` and `bdd/coverage-map.json`"
+    ) &&
+    body.includes(
+      `Regenerated by \`${COVERAGE_COMMAND}\`; never hand-edited.`
+    ) &&
+    body.includes("## What each number means\n")
+  );
+}
+
+/** Known index versions remain refreshable when generated guidance changes. */
+function ownedEntrypoint(relative, body) {
+  if (relative === "bdd/coverage-report.json") {
+    const value = parseJson(body);
+    return (
+      value?.schemaVersion === PROJECTION_INDEX_SCHEMA &&
+      value.generator === PROJECTION_GENERATOR &&
+      value.featureReports === "bdd/reports/v1/features/" &&
+      value.scenarioMatrices === "docs/bdd-scenario-matrix/" &&
+      value.coverageDocuments === "docs/e2e-bdd-coverage/" &&
+      value.sourceIdentity ===
+        "Full repository-relative bdd/features/*.feature path" &&
+      value.commands?.matrix === MATRIX_COMMAND &&
+      value.commands?.coverage === COVERAGE_COMMAND &&
+      value.aggregateCommands?.matrix === AGGREGATE_MATRIX_COMMAND &&
+      value.aggregateCommands?.coverage === REPORT_COMMAND &&
+      typeof value.aggregate === "string"
+    );
+  }
+  const matrix = relative === "docs/bdd-scenario-matrix.md";
+  const title = matrix
+    ? MATRIX_TITLE
+    : "# BDD behavior contract — coverage burndown\n";
+  const command = matrix
+    ? `Generated by \`${MATRIX_COMMAND}\`; never hand-edited.`
+    : `Regenerated by \`${COVERAGE_COMMAND}\`; never hand-edited.`;
+  return (
+    body.startsWith(title) &&
+    body.includes(command) &&
+    body.includes("../bdd/reports/v1/features/") &&
+    body.includes(
+      matrix
+        ? "[bdd-scenario-matrix/](bdd-scenario-matrix/)"
+        : "[e2e-bdd-coverage/](e2e-bdd-coverage/)"
+    ) &&
+    body.includes(
+      "This entrypoint intentionally stores no feature list or global counts."
+    )
+  );
+}
+
+/** Existing case/NFC aliases in ancestors are unsafe even on a permissive disk. */
+function inspectAliases(root, relative) {
+  let directory = root;
+  for (const component of relative.split("/")) {
+    if (!projectionStat(directory)) return;
+    const key = component.normalize("NFC").toLowerCase();
+    const alias = fs
+      .readdirSync(directory)
+      .find(
+        name =>
+          name !== component && name.normalize("NFC").toLowerCase() === key
+      );
+    if (alias !== undefined)
+      refuseProjection(`case/NFC path collision: ${relative} aliases ${alias}`);
+    directory = path.join(directory, component);
+  }
+}
+
+/** Validate existing bytes without mutating desired targets or unknown neighbors. */
+export function validateProjectionTarget(root, relative, desired) {
+  if (!inspectProjectionPath(root, relative)) return null;
+  const body = fs.readFileSync(path.join(root, relative), "utf8");
+  if (STATIC_ARTIFACTS.has(relative)) {
+    if (
+      body !== desired &&
+      !legacyEntrypoint(relative, body) &&
+      !ownedEntrypoint(relative, body)
+    ) {
+      refuseProjection(
+        `unowned static entrypoint or unsupported schema: ${relative}`
+      );
+    }
+  } else if (!ownedFeatureLeaf(relative, body)) {
+    refuseProjection(`unowned content occupies generated path: ${relative}`);
+  }
+  return body;
+}
+
+/** Full safety/ownership inventory precedes all directory and file mutation. */
+export function prepareProjectionWrite(root, artifacts) {
+  const candidates = PROJECTION_DIRECTORIES.flatMap(directory =>
+    listProjectionPaths(root, directory)
+  );
+  const allPaths = [...artifacts.keys(), ...candidates];
+  validateProjectionCollisions(allPaths);
+  for (const relative of artifacts.keys()) {
+    inspectProjectionPath(root, relative);
+    inspectAliases(root, relative);
+  }
+  const obsolete = [];
+  for (const relative of candidates) {
+    if (!projectionStat(path.join(root, relative)).isFile()) continue;
+    const body = fs.readFileSync(path.join(root, relative), "utf8");
+    const owned = ownedFeatureLeaf(relative, body);
+    if (owned && !artifacts.has(relative)) obsolete.push({ relative, body });
+  }
+  const changed = [];
+  for (const [relative, body] of artifacts) {
+    const previous = validateProjectionTarget(root, relative, body);
+    if (previous !== body) changed.push({ relative, body, previous });
+  }
+  return { changed, obsolete };
+}

package/expo/copy-overwrite/scripts/bdd/projection-paths.mjs

@@ -0,0 +1,152 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Portable identities and filesystem boundaries for committed BDD leaves. */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { byCodeUnit } from "./contract.mjs";
+
+export const FEATURE_PROJECTION_SCHEMA = "lisa-bdd-feature-projection-v1";
+export const PROJECTION_GENERATOR = "lisa-bdd-feature-projection";
+export const PROJECTION_DIRECTORIES = Object.freeze([
+  "bdd/reports/v1/features",
+  "docs/bdd-scenario-matrix",
+  "docs/e2e-bdd-coverage",
+]);
+
+/** Refuse an unsafe or ambiguous plan with an operator-readable diagnosis. */
+export function refuseProjection(message) {
+  throw new Error(`BDD projection: ${message}`);
+}
+
+/** Validate untrusted relative paths before normalization can hide traversal. */
+export function relativeProjectionPath(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    refuseProjection("path is missing");
+  }
+  if (path.isAbsolute(value) || /^[A-Za-z]:/.test(value)) {
+    refuseProjection(`path must be repository-relative: ${value}`);
+  }
+  if (/[/\\]$|\\|[\u0000-\u001f\u007f]/.test(value)) {
+    refuseProjection(`unsafe path spelling: ${value}`);
+  }
+  const parts = value.split("/");
+  if (parts.some(part => !part || part === "." || part === "..")) {
+    refuseProjection(`path contains empty or traversal components: ${value}`);
+  }
+  return value.normalize("NFC");
+}
+
+/** Full source identity, independent of its display Feature title. */
+export function projectionSourceFile(value) {
+  const normalized = relativeProjectionPath(value);
+  if (
+    !normalized.startsWith("bdd/features/") ||
+    !normalized.endsWith(".feature")
+  ) {
+    refuseProjection(`source must be a bdd/features .feature path: ${value}`);
+  }
+  return normalized;
+}
+
+/** Retain the complete repository-relative source path in every suffix. */
+export function featureArtifactPaths(sourceFile) {
+  const source = projectionSourceFile(sourceFile);
+  return PROJECTION_DIRECTORIES.map(
+    (directory, index) =>
+      `${directory}/${source}.${index === 0 ? "json" : "md"}`
+  );
+}
+
+/** Refuse both leaf and ancestor case/NFC aliases before any mutation. */
+export function validateProjectionCollisions(paths) {
+  const spellings = new Map();
+  for (const value of paths) {
+    relativeProjectionPath(value);
+    const components = value.split("/");
+    for (let count = 1; count <= components.length; count += 1) {
+      const prefix = components.slice(0, count).join("/");
+      const key = prefix.normalize("NFC").toLowerCase();
+      const previous = spellings.get(key);
+      if (previous !== undefined && previous !== prefix) {
+        refuseProjection(`case/NFC path collision: ${previous} and ${prefix}`);
+      }
+      spellings.set(key, prefix);
+    }
+  }
+}
+
+/** A planned file may not also be an ancestor directory of another file. */
+export function validateProjectionTargets(paths) {
+  const targets = new Set(paths);
+  validateProjectionCollisions(targets);
+  for (const relative of targets) {
+    const parts = relative.split("/");
+    for (let count = 1; count < parts.length; count += 1) {
+      const ancestor = parts.slice(0, count).join("/");
+      if (targets.has(ancestor)) {
+        refuseProjection(
+          `planned file/directory collision: ${ancestor} and ${relative}`
+        );
+      }
+    }
+  }
+}
+
+/** lstat without following a final symlink, including dangling ones. */
+export function projectionStat(absolute) {
+  try {
+    return fs.lstatSync(absolute);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+/** Validate every existing ancestor and target, refusing any symlink. */
+export function inspectProjectionPath(root, relative, kind = "file") {
+  relativeProjectionPath(relative);
+  const parts = relative.split("/");
+  let current = root;
+  for (let index = 0; index < parts.length; index += 1) {
+    current = path.join(current, parts[index]);
+    const stat = projectionStat(current);
+    if (!stat) return null;
+    if (stat.isSymbolicLink()) refuseProjection(`symlink refused: ${relative}`);
+    const directory = index < parts.length - 1 || kind === "directory";
+    if (directory ? !stat.isDirectory() : !stat.isFile()) {
+      refuseProjection(`file/directory or special-file collision: ${relative}`);
+    }
+  }
+  return projectionStat(current);
+}
+
+/** List regular leaf candidates without following generated-directory links. */
+export function listProjectionPaths(root, directory) {
+  if (!inspectProjectionPath(root, directory, "directory")) return [];
+  const result = [];
+  const pending = [directory];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    for (const entry of fs.readdirSync(path.join(root, current), {
+      withFileTypes: true,
+    })) {
+      const relative = `${current}/${entry.name}`;
+      result.push(relative);
+      if (entry.isDirectory()) {
+        inspectProjectionPath(root, relative, "directory");
+        pending.push(relative);
+      } else {
+        inspectProjectionPath(root, relative);
+      }
+    }
+  }
+  return result.sort(byCodeUnit);
+}
+
+/** Preserve raw disk spelling while selecting regular ownership candidates. */
+export function listProjectionFiles(root, directory) {
+  return listProjectionPaths(root, directory).filter(relative =>
+    projectionStat(path.join(root, relative)).isFile()
+  );
+}