@devrik-tools/claude-gates 0.2.0 → 0.3.0

package/cli/__tests__/config.test.mjs

@@ -1,113 +0,0 @@
-import assert from 'node:assert/strict';
-import {
-  mkdtempSync,
-  mkdirSync,
-  writeFileSync,
-  readFileSync,
-  existsSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { test } from 'node:test';
-import {
-  SCOPES,
-  findProjectRoot,
-  configPathFor,
-  readConfig,
-  mergeConfig,
-  writeConfig,
-} from '../config.mjs';
-
-function temporaryDirectory() {
-  return mkdtempSync(join(tmpdir(), 'claude-gates-'));
-}
-
-test('findProjectRoot climbs to the .git directory and falls back to the start', () => {
-  const root = temporaryDirectory();
-  mkdirSync(join(root, '.git'));
-  const nested = join(root, 'src', 'deep');
-  mkdirSync(nested, { recursive: true });
-  assert.equal(findProjectRoot(nested), root);
-
-  const loose = temporaryDirectory();
-  assert.equal(findProjectRoot(loose), loose);
-});
-
-test('findProjectRoot never climbs into the home directory', () => {
-  const fakeHome = temporaryDirectory();
-  mkdirSync(join(fakeHome, '.ai'));
-  const project = join(fakeHome, 'repos', 'app');
-  mkdirSync(project, { recursive: true });
-  assert.equal(findProjectRoot(project, { home: fakeHome }), project);
-});
-
-test('configPathFor resolves both scopes', () => {
-  const home = temporaryDirectory();
-  const project = temporaryDirectory();
-  mkdirSync(join(project, '.ai'));
-  assert.equal(
-    configPathFor(SCOPES.GLOBAL, { home }),
-    join(home, '.claude', 'claude-gates', 'config.json'),
-  );
-  assert.equal(
-    configPathFor(SCOPES.PROJECT, { cwd: project }),
-    join(project, '.ai', 'config.json'),
-  );
-  assert.throws(() => configPathFor('nope'), /Unknown scope/);
-});
-
-test('readConfig distinguishes missing, valid and corrupt', () => {
-  const directory = temporaryDirectory();
-  const path = join(directory, 'config.json');
-  assert.deepEqual(readConfig(path), {
-    exists: false,
-    data: {},
-    corrupt: false,
-  });
-  writeFileSync(path, '{"autoCommit":true}');
-  assert.deepEqual(readConfig(path), {
-    exists: true,
-    data: { autoCommit: true },
-    corrupt: false,
-  });
-  writeFileSync(path, '{nope');
-  assert.equal(readConfig(path).corrupt, true);
-});
-
-test('readConfig strips a leading UTF-8 BOM instead of treating the file as corrupt', () => {
-  const directory = temporaryDirectory();
-  const path = join(directory, 'config.json');
-  const bom = '';
-  writeFileSync(path, bom + '{"autoCommit":true}');
-  assert.deepEqual(readConfig(path), {
-    exists: true,
-    data: { autoCommit: true },
-    corrupt: false,
-  });
-});
-
-test('mergeConfig keeps unrelated keys and unknown gates, overrides known ones', () => {
-  const existing = {
-    autoCommit: true,
-    gates: { oldGate: true, blockX: false },
-  };
-  const merged = mergeConfig(existing, {
-    adopted: 'partial',
-    gates: { blockX: true, blockY: false },
-    gateVersion: '3.0.0',
-  });
-  assert.deepEqual(merged, {
-    autoCommit: true,
-    adopted: 'partial',
-    gateVersion: '3.0.0',
-    gates: { oldGate: true, blockX: true, blockY: false },
-  });
-});
-
-test('writeConfig creates parent folders and writes pretty JSON with trailing newline', () => {
-  const directory = temporaryDirectory();
-  const path = join(directory, 'a', 'b', 'config.json');
-  writeConfig(path, { adopted: true });
-  assert.ok(existsSync(path));
-  assert.equal(readFileSync(path, 'utf8'), '{\n  "adopted": true\n}\n');
-});

package/cli/__tests__/init-flags.test.mjs

@@ -1,111 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import {
-  mkdtempSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-  existsSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, dirname } from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-import { normalizeOptions } from '../init.mjs';
-
-const CLI = join(dirname(fileURLToPath(import.meta.url)), '..', 'index.mjs');
-
-test('normalizeOptions maps commander options', () => {
-  assert.deepEqual(
-    normalizeOptions({
-      global: true,
-      families: ['security', 'quality'],
-      yes: true,
-      dryRun: true,
-    }),
-    {
-      scope: 'global',
-      mode: 'families',
-      families: ['security', 'quality'],
-      gates: [],
-      yes: true,
-      dryRun: true,
-      install: undefined,
-    },
-  );
-  assert.equal(normalizeOptions({ gates: ['bash-commands'] }).mode, 'granular');
-  assert.equal(normalizeOptions({}).mode, null);
-  assert.throws(() => normalizeOptions({ all: true, none: true }), /Pick one/);
-  assert.throws(
-    () => normalizeOptions({ project: true, global: true }),
-    /Pick one/,
-  );
-});
-
-test('non-interactive init writes .ai/config.json at the project root', () => {
-  const project = mkdtempSync(join(tmpdir(), 'claude-gates-proj-'));
-  mkdirSync(join(project, '.git'));
-  const nested = join(project, 'src');
-  mkdirSync(nested);
-
-  execFileSync(
-    process.execPath,
-    [
-      CLI,
-      'init',
-      '--project',
-      '--families',
-      'security',
-      '--yes',
-      '--no-install',
-    ],
-    { cwd: nested, encoding: 'utf8' },
-  );
-
-  const path = join(project, '.ai', 'config.json');
-  assert.ok(existsSync(path), 'config written at git root, not at cwd');
-  const config = JSON.parse(readFileSync(path, 'utf8'));
-  assert.equal(config.adopted, 'partial');
-  // Gates with params are materialized as { enabled, ...defaults } so the knobs are editable.
-  assert.equal(config.gates.blockDestructiveShellCommands.enabled, true);
-  assert.equal(config.gates.requireBriefBeforeDelegating.enabled, false);
-  assert.match(config.gateVersion, /^\d+\.\d+\.\d+$/);
-});
-
-test('--dry-run writes nothing', () => {
-  const project = mkdtempSync(join(tmpdir(), 'claude-gates-dry-'));
-  execFileSync(
-    process.execPath,
-    [CLI, 'init', '--project', '--all', '--yes', '--dry-run'],
-    { cwd: project, encoding: 'utf8' },
-  );
-  assert.ok(!existsSync(join(project, '.ai', 'config.json')));
-});
-
-test('--none records an explicit refusal', () => {
-  const project = mkdtempSync(join(tmpdir(), 'claude-gates-none-'));
-  execFileSync(
-    process.execPath,
-    [CLI, 'init', '--project', '--none', '--yes', '--no-install'],
-    { cwd: project, encoding: 'utf8' },
-  );
-  const config = JSON.parse(
-    readFileSync(join(project, '.ai', 'config.json'), 'utf8'),
-  );
-  assert.equal(config.adopted, false);
-});
-
-test('a corrupt existing config aborts without writing', () => {
-  const project = mkdtempSync(join(tmpdir(), 'claude-gates-corrupt-'));
-  mkdirSync(join(project, '.ai'));
-  const path = join(project, '.ai', 'config.json');
-  writeFileSync(path, '{broken');
-  assert.throws(() =>
-    execFileSync(
-      process.execPath,
-      [CLI, 'init', '--project', '--all', '--yes'],
-      { cwd: project, encoding: 'utf8', stdio: 'pipe' },
-    ),
-  );
-  assert.equal(readFileSync(path, 'utf8'), '{broken');
-});

package/cli/__tests__/install.test.mjs

@@ -1,102 +0,0 @@
-// installPlugin used to install only the marketplace's FIRST plugin (`const [plugin] =
-// manifest.plugins`), so a second plugin (like `tasks`) never got installed by `init`. These
-// tests exercise the fixed multi-plugin behavior with a fake `runClaude` — never the real
-// `claude` binary, which would actually install plugins on the machine running the test.
-
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { SCOPES } from '../config.mjs';
-import { installPlugin, pluginInstallCommands } from '../install.mjs';
-import { REPOSITORY_ROOT } from '../constants.mjs';
-
-test('pluginInstallCommands lists one command per plugin the marketplace declares (gates AND tasks)', () => {
-  const commands = pluginInstallCommands();
-  assert.ok(
-    commands.some((command) => command.includes('install gates@')),
-    'gates must still be installable',
-  );
-  assert.ok(
-    commands.some((command) => command.includes('install tasks@')),
-    'tasks must now be installable too — this was the whole point of the fix',
-  );
-});
-
-test('installPlugin installs EVERY plugin, not just the first', () => {
-  const invocations = [];
-  const runClaude = (args) => {
-    invocations.push(args);
-    return '';
-  };
-
-  const result = installPlugin(SCOPES.PROJECT, { cwd: REPOSITORY_ROOT, runClaude });
-
-  assert.equal(result.installed, true);
-  const installedPlugins = result.results.map((entry) => entry.plugin);
-  assert.ok(installedPlugins.includes('gates'));
-  assert.ok(installedPlugins.includes('tasks'));
-  assert.equal(result.results.every((entry) => entry.installed), true);
-
-  // One marketplace add + one install call per plugin.
-  const installCalls = invocations.filter((args) => args[1] === 'install');
-  assert.equal(installCalls.length, result.results.length);
-});
-
-test('installPlugin: one plugin failing does not stop the rest from being attempted', () => {
-  const runClaude = (args) => {
-    if (args[0] === 'plugin' && args[1] === 'install' && args[2].startsWith('gates@')) {
-      throw new Error('boom: gates install failed');
-    }
-    return '';
-  };
-
-  const result = installPlugin(SCOPES.GLOBAL, { cwd: REPOSITORY_ROOT, runClaude });
-
-  assert.equal(result.installed, false, 'overall result reflects the partial failure');
-  const gatesEntry = result.results.find((entry) => entry.plugin === 'gates');
-  const tasksEntry = result.results.find((entry) => entry.plugin === 'tasks');
-  assert.equal(gatesEntry.installed, false);
-  assert.match(gatesEntry.reason, /boom/);
-  assert.equal(
-    tasksEntry.installed,
-    true,
-    'tasks must still install even though gates failed',
-  );
-  assert.match(result.reason, /gates/);
-});
-
-test('installPlugin uses the marketplace name Claude Code actually registered, not the manifest name', () => {
-  // The repo's manifest name is `claude-gates`, but if the user added this same directory
-  // earlier under a different name, Claude Code keeps that name. installPlugin must install as
-  // plugin@<registered-name>, or `claude` answers "not found in marketplace claude-gates".
-  const installCalls = [];
-  const runClaude = (args) => {
-    if (args[1] === 'marketplace' && args[2] === 'list') {
-      // A listing where THIS repo is registered under the name `devrik`.
-      return `Configured marketplaces:\n\n  ❯ devrik\n    Source: Directory (${REPOSITORY_ROOT})\n`;
-    }
-    if (args[1] === 'install') installCalls.push(args[2]);
-    return '';
-  };
-
-  const result = installPlugin(SCOPES.GLOBAL, { cwd: REPOSITORY_ROOT, runClaude });
-
-  assert.equal(result.installed, true);
-  assert.ok(
-    installCalls.every((target) => target.endsWith('@devrik')),
-    `every install must target @devrik, got: ${installCalls.join(', ')}`,
-  );
-});
-
-test('installPlugin degrades gracefully when the claude binary is entirely unreachable', () => {
-  const runClaude = () => {
-    const error = new Error('spawn claude ENOENT');
-    error.code = 'ENOENT';
-    throw error;
-  };
-
-  const result = installPlugin(SCOPES.PROJECT, { cwd: REPOSITORY_ROOT, runClaude });
-
-  assert.equal(result.installed, false);
-  assert.ok(result.results.every((entry) => !entry.installed));
-  assert.ok(result.results.every((entry) => /not found on PATH/.test(entry.reason)));
-});

package/cli/__tests__/materialize.test.mjs

@@ -1,95 +0,0 @@
-// materializeGates only computes the NEW selection's map; how much of an existing gate
-// entry survives depends on the run's mode. This test exercises that combination the same
-// way init.mjs does — a bug here reads as "materialize wiped my config" even though
-// materializeGates and mergeConfig are individually simple.
-
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { mergeConfig } from '../config.mjs';
-import { materializeGates } from '../materialize.mjs';
-import { loadRegistry, allGates } from '../registry.mjs';
-import { resolveSelection, MODES } from '../selection.mjs';
-
-const registry = loadRegistry();
-const gates = allGates(registry);
-const paramGate = gates.find(
-  (gate) => Array.isArray(gate.params) && gate.params.length > 0,
-);
-
-function mergedGatesAfter(mode, existingGates) {
-  const existing = {
-    adopted: 'partial',
-    gateVersion: registry.gateVersion,
-    gates: existingGates,
-  };
-  const selection = resolveSelection(registry, mode, {
-    gates: [paramGate.id],
-    families: [paramGate.family],
-  });
-  const materialized = materializeGates(registry, selection, existing.gates, mode);
-  return mergeConfig(existing, {
-    adopted: 'partial',
-    gates: materialized,
-    gateVersion: registry.gateVersion,
-  }).gates;
-}
-
-test('registry has at least one gate with params, for these tests to exercise', () => {
-  assert.ok(paramGate, 'registry must have at least one gate with params');
-});
-
-test('DEFAULTS re-run preserves a gate the user already disabled, with its custom params, untouched', () => {
-  const merged = mergedGatesAfter(MODES.DEFAULTS, {
-    [paramGate.configKey]: { enabled: false, __userTuned: 'kept-value' },
-  });
-
-  assert.equal(
-    merged[paramGate.configKey].enabled,
-    false,
-    'a gate the user disabled must stay disabled after a defaults re-run',
-  );
-  assert.equal(
-    merged[paramGate.configKey].__userTuned,
-    'kept-value',
-    "the user's own param edit must not be replaced by the gate's built-in default",
-  );
-
-  const untouched = gates.find((gate) => gate.configKey !== paramGate.configKey);
-  assert.ok(
-    Object.prototype.hasOwnProperty.call(merged, untouched.configKey),
-    'a gate absent from the existing config must still appear after materializing',
-  );
-});
-
-test('an explicit GRANULAR pick overrides a previously disabled gate: the named choice wins', () => {
-  const merged = mergedGatesAfter(MODES.GRANULAR, {
-    [paramGate.configKey]: { enabled: false, __userTuned: 'kept-value' },
-  });
-
-  assert.equal(
-    merged[paramGate.configKey].enabled,
-    true,
-    'naming a gate in --gates must re-enable it even if the config had it disabled',
-  );
-});
-
-test('an explicit GRANULAR pick still preserves the user\'s own params (no new values were passed)', () => {
-  const merged = mergedGatesAfter(MODES.GRANULAR, {
-    [paramGate.configKey]: { enabled: false, __userTuned: 'kept-value' },
-  });
-
-  assert.equal(
-    merged[paramGate.configKey].__userTuned,
-    'kept-value',
-    'params the user tuned by hand survive an explicit pick that only changes enabled',
-  );
-});
-
-test('FAMILIES mode behaves the same as GRANULAR for an already-configured gate', () => {
-  const merged = mergedGatesAfter(MODES.FAMILIES, {
-    [paramGate.configKey]: { enabled: false, __userTuned: 'kept-value' },
-  });
-
-  assert.equal(merged[paramGate.configKey].enabled, true);
-  assert.equal(merged[paramGate.configKey].__userTuned, 'kept-value');
-});

package/cli/__tests__/registry-gates-consistency.test.mjs

@@ -1,52 +0,0 @@
-// The registry and the gates on disk must agree: every PreToolUse gate the registry
-// declares has to have a script, and every gate folder on disk has to be declared. A
-// mismatch (a registry entry with no file, like the old `autocommit`, or an orphan folder)
-// is what made `init` spawn a non-existent gate — this test blocks it from returning.
-
-import assert from 'node:assert/strict';
-import { existsSync, readdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-import { loadRegistry, allGates } from '../registry.mjs';
-
-const REPO = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
-const GATES_DIR = join(REPO, 'plugins', 'gates', 'hooks', 'gates');
-
-const registry = loadRegistry();
-const preToolUseGates = allGates(registry).filter(
-  (gate) => gate.event === 'PreToolUse',
-);
-// Gates that live one-per-folder under plugins/gates/hooks/gates/ — regardless of which
-// event they hook (most are PreToolUse, but e.g. stop-pending is Stop). Session-scoped
-// hooks (doctor.mjs, ask-adoption.mjs, ...) are top-level scripts outside this folder and
-// are intentionally excluded, matching the `gates/x.mjs` vs `x.mjs` convention documented
-// in registry.mjs's SCRIPT_PATTERN.
-const folderGates = allGates(registry).filter((gate) =>
-  gate.script.startsWith('gates/'),
-);
-
-test('every PreToolUse gate in the registry has its script on disk', () => {
-  for (const gate of preToolUseGates) {
-    const scriptPath = join(REPO, 'plugins', 'gates', 'hooks', gate.script);
-    assert.ok(
-      existsSync(scriptPath),
-      `registry declares gate "${gate.id}" (script ${gate.script}) but the file is missing`,
-    );
-  }
-});
-
-test('every gate folder on disk is declared in the registry', () => {
-  const declaredScripts = new Set(folderGates.map((gate) => gate.script));
-  const folders = readdirSync(GATES_DIR, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => entry.name);
-
-  for (const folder of folders) {
-    const expectedScript = `gates/${folder}/index.mjs`;
-    assert.ok(
-      declaredScripts.has(expectedScript),
-      `gate folder "${folder}" exists on disk but no registry entry points to ${expectedScript}`,
-    );
-  }
-});

package/cli/__tests__/selection.test.mjs

@@ -1,200 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { loadRegistry, validateRegistry, allGates } from '../registry.mjs';
-import {
-  MODES,
-  resolveSelection,
-  adoptionOf,
-  summarize,
-} from '../selection.mjs';
-
-const registry = loadRegistry();
-const keys = allGates(registry).map((gate) => gate.configKey);
-
-test('the shipped registry is valid', () => {
-  assert.deepEqual(validateRegistry(registry), []);
-});
-
-test('validateRegistry catches duplicate configKey and unknown event', () => {
-  const broken = {
-    gateVersion: '1.0.0',
-    families: [
-      {
-        id: 'x',
-        name: 'X',
-        gates: [
-          {
-            id: 'a',
-            configKey: 'k',
-            default: true,
-            event: 'PreToolUse',
-            tools: [],
-            description: 'a',
-          },
-          {
-            id: 'b',
-            configKey: 'k',
-            default: true,
-            event: 'Nope',
-            tools: [],
-            description: 'b',
-          },
-        ],
-      },
-    ],
-  };
-  const problems = validateRegistry(broken);
-  assert.ok(problems.some((problem) => /duplicate configKey: k/.test(problem)));
-  assert.ok(problems.some((problem) => /gates\.1\.event/.test(problem)));
-});
-
-// A one-gate registry whose gate fields are overridable, so each test tweaks only the
-// field it checks. Every level carries its required description/name.
-function oneGateRegistry(gateOverrides) {
-  return {
-    gateVersion: '1.0.0',
-    families: [
-      {
-        id: 'x',
-        name: 'X',
-        description: 'family x',
-        gates: [
-          {
-            id: 'a',
-            configKey: 'k',
-            default: true,
-            event: 'PreToolUse',
-            tools: [],
-            script: 'gates/a.mjs',
-            description: 'gate a',
-            ...gateOverrides,
-          },
-        ],
-      },
-    ],
-  };
-}
-
-const ABSOLUTE_SCRIPT = `${'/'}etc/evil.mjs`;
-
-test('validateRegistry requires a valid relative .mjs script per gate', () => {
-  const withoutScript = oneGateRegistry({});
-  delete withoutScript.families[0].gates[0].script;
-  assert.ok(validateRegistry(withoutScript).some((p) => /script/.test(p)));
-
-  assert.ok(
-    validateRegistry(oneGateRegistry({ script: ABSOLUTE_SCRIPT })).some((p) =>
-      /script/.test(p),
-    ),
-  );
-  assert.ok(
-    validateRegistry(oneGateRegistry({ script: '../escape.mjs' })).some((p) =>
-      /script/.test(p),
-    ),
-  );
-  assert.deepEqual(
-    validateRegistry(oneGateRegistry({ script: 'gates/ok.mjs' })),
-    [],
-  );
-});
-
-test('validateRegistry rejects a param that is not camelCase or has a bad type', () => {
-  assert.ok(
-    validateRegistry(
-      oneGateRegistry({
-        params: [{ name: 'Bad-Name', type: 'string', description: 'd' }],
-      }),
-    ).length > 0,
-  );
-  assert.ok(
-    validateRegistry(
-      oneGateRegistry({
-        params: [{ name: 'ok', type: 'regex', description: 'd' }],
-      }),
-    ).length > 0,
-  );
-  assert.deepEqual(
-    validateRegistry(
-      oneGateRegistry({
-        params: [{ name: 'ok', type: 'string[]', description: 'd' }],
-      }),
-    ),
-    [],
-  );
-});
-
-test('ALL enables every key; NONE disables every key; both cover all keys', () => {
-  const all = resolveSelection(registry, MODES.ALL);
-  const none = resolveSelection(registry, MODES.NONE);
-  assert.deepEqual(Object.keys(all).sort(), [...keys].sort());
-  assert.ok(Object.values(all).every((v) => v === true));
-  assert.ok(Object.values(none).every((v) => v === false));
-});
-
-test("DEFAULTS mirrors the registry's default flags", () => {
-  const map = resolveSelection(registry, MODES.DEFAULTS);
-  for (const gate of allGates(registry))
-    assert.equal(map[gate.configKey], gate.default, gate.id);
-});
-
-test('FAMILIES enables exactly the picked families', () => {
-  const map = resolveSelection(registry, MODES.FAMILIES, {
-    families: ['security'],
-  });
-  for (const gate of allGates(registry))
-    assert.equal(map[gate.configKey], gate.family === 'security', gate.id);
-});
-
-test('GRANULAR enables exactly the picked gates', () => {
-  const map = resolveSelection(registry, MODES.GRANULAR, {
-    gates: ['bash-commands', 'no-reconfirm'],
-  });
-  const enabled = Object.entries(map)
-    .filter(([, v]) => v)
-    .map(([k]) => k)
-    .sort();
-  assert.deepEqual(
-    enabled,
-    ['blockDestructiveShellCommands', 'requireNoReconfirmOfApproved'].sort(),
-  );
-});
-
-test('unknown ids fail loudly instead of being ignored', () => {
-  assert.throws(
-    () => resolveSelection(registry, MODES.FAMILIES, { families: ['nope'] }),
-    /Unknown family/,
-  );
-  assert.throws(
-    () => resolveSelection(registry, MODES.GRANULAR, { gates: ['nope'] }),
-    /Unknown gate/,
-  );
-  assert.throws(
-    () => resolveSelection(registry, 'weird'),
-    /Unknown selection mode/,
-  );
-});
-
-test('adoptionOf: true / false / partial', () => {
-  assert.equal(adoptionOf(resolveSelection(registry, MODES.ALL)), true);
-  assert.equal(adoptionOf(resolveSelection(registry, MODES.NONE)), false);
-  assert.equal(
-    adoptionOf(
-      resolveSelection(registry, MODES.FAMILIES, { families: ['security'] }),
-    ),
-    'partial',
-  );
-});
-
-test('summarize counts per family', () => {
-  const rows = summarize(
-    registry,
-    resolveSelection(registry, MODES.FAMILIES, { families: ['security'] }),
-  );
-  const security = rows.find((row) => row.family === 'security');
-  assert.equal(security.enabled.length, security.total);
-  assert.ok(
-    rows
-      .filter((row) => row.family !== 'security')
-      .every((row) => row.enabled.length === 0),
-  );
-});