@eunjae/il 0.0.1

package/dist/lib/__tests__/aliasRepo.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { allocateAliasInMap, parseAlias } from '../aliasRepo';
+const emptyAliases = () => ({ T: {}, R: {} });
+describe('aliasRepo', () => {
+    it('parses aliases with prefixes', () => {
+        expect(parseAlias('T01')).toEqual({ prefix: 'T', key: '01' });
+        expect(parseAlias('R12')).toEqual({ prefix: 'R', key: '12' });
+        expect(parseAlias('X99')).toBeNull();
+    });
+    it('allocates sequential aliases', () => {
+        const aliases = emptyAliases();
+        const first = allocateAliasInMap(aliases, 'T', 'T01');
+        expect(first.alias).toBe('T01');
+        const second = allocateAliasInMap(aliases, 'T', 'T02');
+        expect(second.alias).toBe('T02');
+    });
+});

package/dist/lib/__tests__/edit.test.js

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { applyTaskEdit } from '../edit';
+import { buildTask } from '../taskFactory';
+const createTask = () => buildTask({
+    type: 'regular',
+    title: 'Original title',
+    metadata: {}
+});
+describe('applyTaskEdit', () => {
+    it('updates basic fields', () => {
+        const task = createTask();
+        const updated = applyTaskEdit(task, 'title', 'Updated title');
+        expect(updated.title).toBe('Updated title');
+    });
+    it('updates nested metadata fields', () => {
+        const task = createTask();
+        const updated = applyTaskEdit(task, 'metadata.url', 'https://example.com');
+        expect(updated.metadata.url).toBe('https://example.com');
+    });
+    it('parses PR URLs when updating metadata.pr.url', () => {
+        const task = createTask();
+        const updated = applyTaskEdit(task, 'metadata.pr.url', 'https://github.com/acme/repo/pull/42');
+        expect(updated.metadata.pr?.url).toBe('https://github.com/acme/repo/pull/42');
+        expect(updated.metadata.pr?.repo?.owner).toBe('acme');
+        expect(updated.metadata.pr?.repo?.name).toBe('repo');
+        expect(updated.metadata.pr?.number).toBe(42);
+    });
+    it('rejects direct status edits', () => {
+        const task = createTask();
+        expect(() => applyTaskEdit(task, 'status', 'active')).toThrow('Use status commands');
+    });
+});

package/dist/lib/__tests__/fsm.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { getNextStatus } from '../fsm';
+const cases = [
+    ['backlog', 'start', 'active'],
+    ['backlog', 'cancel', 'cancelled'],
+    ['active', 'pause', 'paused'],
+    ['active', 'complete', 'completed'],
+    ['active', 'cancel', 'cancelled'],
+    ['paused', 'start', 'active'],
+    ['paused', 'complete', 'completed'],
+    ['paused', 'cancel', 'cancelled']
+];
+describe('getNextStatus', () => {
+    for (const [current, action, next] of cases) {
+        it(`transitions ${current} via ${action}`, () => {
+            expect(getNextStatus(current, action)).toBe(next);
+        });
+    }
+    it('throws on invalid transition', () => {
+        expect(() => getNextStatus('completed', 'start')).toThrow('Invalid transition');
+    });
+});

package/dist/lib/__tests__/id.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import { generateStableRef, generateTaskId } from '../id';
+const stableRefPattern = /^[TR]-[A-Z2-7]{6}$/;
+describe('generateTaskId', () => {
+    it('prefixes regular tasks with T', () => {
+        const id = generateTaskId('regular');
+        expect(id.startsWith('T')).toBe(true);
+    });
+    it('prefixes PR review tasks with R', () => {
+        const id = generateTaskId('pr_review');
+        expect(id.startsWith('R')).toBe(true);
+    });
+});
+describe('generateStableRef', () => {
+    it('generates deterministic refs for a task ID', () => {
+        const id = 'T01J2ABCDEF4X9YQK7M3R8Z2';
+        expect(generateStableRef('regular', id)).toBe(generateStableRef('regular', id));
+    });
+    it('uses correct prefix and format', () => {
+        const id = 'R01J2ABCDEF4X9YQK7M3R8Z2';
+        const ref = generateStableRef('pr_review', id);
+        expect(ref).toMatch(stableRefPattern);
+        expect(ref.startsWith('R-')).toBe(true);
+    });
+});

package/dist/lib/__tests__/schema.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { taskSchema } from '../schema';
+import { buildTask } from '../taskFactory';
+const baseTask = () => buildTask({
+    type: 'regular',
+    title: 'Sample task',
+    metadata: {}
+});
+describe('taskSchema', () => {
+    it('accepts regular tasks without PR metadata', () => {
+        const task = baseTask();
+        expect(() => taskSchema.parse(task)).not.toThrow();
+    });
+    it('rejects PR review tasks without PR URL', () => {
+        const task = { ...baseTask(), type: 'pr_review', metadata: {} };
+        expect(() => taskSchema.parse(task)).toThrow('PR review tasks require metadata.pr.url');
+    });
+    it('accepts PR review tasks with PR metadata', () => {
+        const task = {
+            ...baseTask(),
+            type: 'pr_review',
+            metadata: {
+                pr: {
+                    url: 'https://github.com/acme/repo/pull/1',
+                    provider: 'github',
+                    repo: {
+                        host: 'github.com',
+                        owner: 'acme',
+                        name: 'repo'
+                    },
+                    number: 1
+                }
+            }
+        };
+        expect(() => taskSchema.parse(task)).not.toThrow();
+    });
+});

package/dist/lib/__tests__/taskOperations.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { appendDayAssignment, appendLog, applyTransition, isAssignedOnDate } from '../taskOperations';
+import { buildTask } from '../taskFactory';
+const createTask = () => buildTask({
+    type: 'regular',
+    title: 'Work task',
+    metadata: {}
+});
+describe('taskOperations', () => {
+    it('appends logs with optional status', () => {
+        const task = createTask();
+        const updated = appendLog(task, 'Progress update', 'active');
+        expect(updated.logs).toHaveLength(1);
+        expect(updated.logs[0].msg).toBe('Progress update');
+        expect(updated.logs[0].status).toBe('active');
+    });
+    it('applies transitions with default messages', () => {
+        const task = createTask();
+        const result = applyTransition(task, 'start');
+        expect(result.nextStatus).toBe('active');
+        expect(result.task.status).toBe('active');
+        expect(result.task.logs.at(-1)?.msg).toBe('Started task');
+    });
+    it('tracks day assignment state', () => {
+        const task = createTask();
+        const date = '2026-01-22';
+        expect(isAssignedOnDate(task, date)).toBe(false);
+        const assigned = appendDayAssignment(task, date, 'assign');
+        expect(isAssignedOnDate(assigned, date)).toBe(true);
+        const unassigned = appendDayAssignment(assigned, date, 'unassign');
+        expect(isAssignedOnDate(unassigned, date)).toBe(false);
+    });
+});

package/dist/lib/aliasReconcile.js

@@ -0,0 +1,28 @@
+import { allocateAliasInMap, readAliases, writeAliases } from './aliasRepo';
+import { listAllTasks } from './taskRepo';
+export const reconcileAliases = async (workspaceRoot) => {
+    const aliases = await readAliases(workspaceRoot);
+    const tasks = await listAllTasks(workspaceRoot);
+    const tasksById = new Map(tasks.map((stored) => [stored.task.id, stored.task]));
+    const normalizePrefix = (prefix) => {
+        const next = {};
+        for (const [key, value] of Object.entries(aliases[prefix])) {
+            if (tasksById.has(value)) {
+                next[key] = value;
+            }
+        }
+        aliases[prefix] = next;
+    };
+    normalizePrefix('T');
+    normalizePrefix('R');
+    const existingIds = new Set([...Object.values(aliases.T), ...Object.values(aliases.R)]);
+    const missing = tasks
+        .filter((stored) => !existingIds.has(stored.task.id))
+        .sort((a, b) => a.task.created_at.localeCompare(b.task.created_at));
+    for (const stored of missing) {
+        const prefix = stored.task.type === 'pr_review' ? 'R' : 'T';
+        allocateAliasInMap(aliases, prefix, stored.task.id);
+    }
+    await writeAliases(workspaceRoot, aliases);
+    return { updated: true };
+};

package/dist/lib/aliasRepo.js

@@ -0,0 +1,58 @@
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import { readJsonFile, writeJsonAtomic } from './json';
+const emptyAliases = () => ({ T: {}, R: {} });
+const aliasFilePath = (workspaceRoot) => path.join(workspaceRoot, 'aliases.json');
+const fileExists = async (filePath) => {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const readAliases = async (workspaceRoot) => {
+    const filePath = aliasFilePath(workspaceRoot);
+    if (!(await fileExists(filePath))) {
+        return emptyAliases();
+    }
+    const data = await readJsonFile(filePath);
+    return {
+        T: data.T ?? {},
+        R: data.R ?? {}
+    };
+};
+export const writeAliases = async (workspaceRoot, aliases) => {
+    await writeJsonAtomic(aliasFilePath(workspaceRoot), aliases);
+};
+export const parseAlias = (alias) => {
+    const match = alias.match(/^([TR])(\d+)$/);
+    if (!match) {
+        return null;
+    }
+    return { prefix: match[1], key: match[2] };
+};
+const formatAliasKey = (value) => String(value).padStart(2, '0');
+export const allocateAliasInMap = (aliases, prefix, taskId) => {
+    const used = new Set(Object.keys(aliases[prefix]).map((key) => Number.parseInt(key, 10)));
+    let next = 1;
+    while (used.has(next)) {
+        next += 1;
+    }
+    const key = formatAliasKey(next);
+    aliases[prefix][key] = taskId;
+    return { alias: `${prefix}${key}`, aliases };
+};
+export const allocateAlias = async (workspaceRoot, prefix, taskId) => {
+    const aliases = await readAliases(workspaceRoot);
+    return allocateAliasInMap(aliases, prefix, taskId);
+};
+export const resolveAlias = async (workspaceRoot, alias) => {
+    const parsed = parseAlias(alias);
+    if (!parsed) {
+        return null;
+    }
+    const aliases = await readAliases(workspaceRoot);
+    return aliases[parsed.prefix][parsed.key] ?? null;
+};

package/dist/lib/config.js

@@ -0,0 +1,35 @@
+import { access } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { APP_NAME } from './constants';
+import { readJsonFile } from './json';
+const fileExists = async (filePath) => {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const resolveGlobalConfigPath = () => {
+    const configHome = process.env.XDG_CONFIG_HOME ?? path.join(homedir(), '.config');
+    return path.join(configHome, APP_NAME, 'config.json');
+};
+export const readConfigFile = async (filePath) => {
+    if (!(await fileExists(filePath))) {
+        return {};
+    }
+    return (await readJsonFile(filePath)) ?? {};
+};
+export const resolveGithubToken = async (workspaceRoot) => {
+    if (process.env.IL_GITHUB_TOKEN) {
+        return process.env.IL_GITHUB_TOKEN;
+    }
+    const workspaceConfig = await readConfigFile(path.join(workspaceRoot, 'config.json'));
+    if (workspaceConfig.github?.token) {
+        return workspaceConfig.github.token;
+    }
+    const globalConfig = await readConfigFile(resolveGlobalConfigPath());
+    return globalConfig.github?.token ?? null;
+};

package/dist/lib/constants.js

@@ -0,0 +1,6 @@
+export const APP_NAME = 'il';
+export const APP_DIR = `.${APP_NAME}`;
+export const LOCK_DIR = '.lock';
+export const LOCK_FILE = 'store.lock';
+export const TASKS_DIR = 'tasks';
+export const STATUS_ORDER = ['backlog', 'active', 'paused', 'completed', 'cancelled'];

package/dist/lib/edit.js

@@ -0,0 +1,47 @@
+import { buildPrAttachment, parseGitHubPrUrl } from './pr';
+import { validateTaskOrThrow } from './schema';
+import { nowIso } from './time';
+const parseValue = (raw) => {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+};
+export const applyTaskEdit = (task, dottedPath, rawValue) => {
+    if (dottedPath === 'status' || dottedPath.startsWith('status.')) {
+        throw new Error('Use status commands to change status');
+    }
+    const value = parseValue(rawValue);
+    const updated = structuredClone(task);
+    const segments = dottedPath.split('.');
+    let current = updated;
+    for (const segment of segments.slice(0, -1)) {
+        if (!(segment in current)) {
+            current[segment] = {};
+        }
+        const next = current[segment];
+        if (typeof next !== 'object' || next === null || Array.isArray(next)) {
+            throw new Error(`Cannot set ${dottedPath} on non-object path`);
+        }
+        current = next;
+    }
+    const last = segments[segments.length - 1];
+    current[last] = value;
+    if (dottedPath === 'metadata.pr.url') {
+        if (typeof value !== 'string') {
+            throw new Error('metadata.pr.url must be a string');
+        }
+        const parsed = parseGitHubPrUrl(value);
+        if (!parsed) {
+            throw new Error('Invalid PR URL');
+        }
+        updated.metadata.pr = buildPrAttachment(parsed, updated.metadata.pr?.fetched);
+    }
+    const nextTask = {
+        ...updated,
+        updated_at: nowIso()
+    };
+    return validateTaskOrThrow(nextTask);
+};

package/dist/lib/format.js

@@ -0,0 +1,52 @@
+export const buildAliasLookup = (aliases) => {
+    const map = new Map();
+    for (const [key, value] of Object.entries(aliases.T)) {
+        map.set(value, `T${key}`);
+    }
+    for (const [key, value] of Object.entries(aliases.R)) {
+        map.set(value, `R${key}`);
+    }
+    return map;
+};
+export const formatTaskListLine = (task, alias) => {
+    const aliasText = alias ?? '--';
+    return `${aliasText.padEnd(4)} ${task.ref.padEnd(9)} ${task.status.padEnd(9)} ${task.title}`;
+};
+export const formatTaskDetails = (task, alias) => {
+    const lines = [];
+    lines.push(`${alias ?? '--'} ${task.ref} ${task.title}`);
+    lines.push(`id: ${task.id}`);
+    lines.push(`type: ${task.type}`);
+    lines.push(`status: ${task.status}`);
+    lines.push(`created: ${task.created_at}`);
+    lines.push(`updated: ${task.updated_at}`);
+    if (task.metadata.url) {
+        lines.push(`url: ${task.metadata.url}`);
+    }
+    if (task.metadata.pr?.url) {
+        lines.push(`pr: ${task.metadata.pr.url}`);
+        if (task.metadata.pr.fetched) {
+            const fetched = task.metadata.pr.fetched;
+            lines.push(`pr_state: ${fetched.state}`);
+            lines.push(`pr_title: ${fetched.title}`);
+            lines.push(`pr_author: ${fetched.author.login}`);
+            lines.push(`pr_updated_at: ${fetched.updated_at}`);
+            lines.push(`pr_refreshed_at: ${fetched.at}`);
+        }
+    }
+    if (task.logs.length > 0) {
+        lines.push('logs:');
+        for (const log of task.logs) {
+            const status = log.status ? ` [${log.status}]` : '';
+            lines.push(`- ${log.ts}${status} ${log.msg}`);
+        }
+    }
+    if (task.day_assignments.length > 0) {
+        lines.push('day_assignments:');
+        for (const entry of task.day_assignments) {
+            const msg = entry.msg ? ` (${entry.msg})` : '';
+            lines.push(`- ${entry.date} ${entry.action} ${entry.ts}${msg}`);
+        }
+    }
+    return lines.join('\n');
+};

package/dist/lib/fsm.js

@@ -0,0 +1,25 @@
+export const transitionTable = {
+    backlog: {
+        start: 'active',
+        cancel: 'cancelled'
+    },
+    active: {
+        pause: 'paused',
+        complete: 'completed',
+        cancel: 'cancelled'
+    },
+    paused: {
+        start: 'active',
+        complete: 'completed',
+        cancel: 'cancelled'
+    },
+    completed: {},
+    cancelled: {}
+};
+export const getNextStatus = (current, action) => {
+    const next = transitionTable[current][action];
+    if (!next) {
+        throw new Error(`Invalid transition: ${current} -> ${action}`);
+    }
+    return next;
+};

package/dist/lib/gitignore.js

@@ -0,0 +1,21 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { APP_DIR } from './constants';
+const lockEntry = `${APP_DIR}/.lock/`;
+export const ensureLockIgnored = async (repoRoot) => {
+    const gitignorePath = path.join(repoRoot, '.gitignore');
+    let current = '';
+    try {
+        current = await readFile(gitignorePath, 'utf8');
+    }
+    catch {
+        current = '';
+    }
+    if (current.split('\n').some((line) => line.trim() === lockEntry)) {
+        return false;
+    }
+    const separator = current.endsWith('\n') || current.length === 0 ? '' : '\n';
+    const next = `${current}${separator}${lockEntry}\n`;
+    await writeFile(gitignorePath, next, 'utf8');
+    return true;
+};

package/dist/lib/id.js

@@ -0,0 +1,30 @@
+import { createHash } from 'node:crypto';
+import { ulid } from 'ulid';
+const BASE32_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+const base32Encode = (input) => {
+    let bits = 0;
+    let value = 0;
+    let output = '';
+    for (const byte of input) {
+        value = (value << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            output += BASE32_ALPHABET[(value >>> (bits - 5)) & 31];
+            bits -= 5;
+        }
+    }
+    if (bits > 0) {
+        output += BASE32_ALPHABET[(value << (5 - bits)) & 31];
+    }
+    return output;
+};
+export const generateTaskId = (taskType) => {
+    const prefix = taskType === 'pr_review' ? 'R' : 'T';
+    return `${prefix}${ulid()}`;
+};
+export const generateStableRef = (taskType, taskId) => {
+    const prefix = taskType === 'pr_review' ? 'R' : 'T';
+    const hash = createHash('sha256').update(taskId).digest();
+    const encoded = base32Encode(hash).slice(0, 6);
+    return `${prefix}-${encoded}`;
+};

package/dist/lib/json.js

@@ -0,0 +1,10 @@
+import { readFile } from 'node:fs/promises';
+import writeFileAtomic from 'write-file-atomic';
+export const readJsonFile = async (filePath) => {
+    const raw = await readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+};
+export const writeJsonAtomic = async (filePath, data) => {
+    const payload = `${JSON.stringify(data, null, 2)}\n`;
+    await writeFileAtomic(filePath, payload, { encoding: 'utf8', fsync: true });
+};

package/dist/lib/lock.js

@@ -0,0 +1,25 @@
+import { writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import lockfile from 'proper-lockfile';
+import { LOCK_DIR, LOCK_FILE } from './constants';
+import { ensureWorkspaceLayout } from './workspace';
+export const withWorkspaceLock = async (workspaceRoot, fn) => {
+    await ensureWorkspaceLayout(workspaceRoot);
+    const lockPath = path.join(workspaceRoot, LOCK_DIR, LOCK_FILE);
+    await writeFile(lockPath, '', { flag: 'a' });
+    const release = await lockfile.lock(lockPath, {
+        stale: 60_000,
+        retries: {
+            retries: 5,
+            factor: 1.5,
+            minTimeout: 50,
+            maxTimeout: 1_000
+        }
+    });
+    try {
+        return await fn();
+    }
+    finally {
+        await release();
+    }
+};

package/dist/lib/pr.js

@@ -0,0 +1,64 @@
+import { Octokit } from 'octokit';
+import { nowIso } from './time';
+export const parseGitHubPrUrl = (value) => {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return null;
+    }
+    const parts = url.pathname.split('/').filter(Boolean);
+    if (parts.length < 4 || parts[2] !== 'pull') {
+        return null;
+    }
+    const number = Number(parts[3]);
+    if (!Number.isInteger(number)) {
+        return null;
+    }
+    return {
+        url: value,
+        provider: 'github',
+        repo: {
+            host: url.host,
+            owner: parts[0],
+            name: parts[1]
+        },
+        number
+    };
+};
+export const buildPrAttachment = (parsed, fetched) => {
+    return {
+        url: parsed.url,
+        provider: 'github',
+        repo: parsed.repo,
+        number: parsed.number,
+        fetched
+    };
+};
+export const fetchGitHubPr = async (parsed, token) => {
+    if (!parsed.repo || !parsed.number) {
+        return null;
+    }
+    if (!token) {
+        return null;
+    }
+    const octokit = new Octokit({ auth: token });
+    const response = await octokit.rest.pulls.get({
+        owner: parsed.repo.owner,
+        repo: parsed.repo.name,
+        pull_number: parsed.number
+    });
+    const data = response.data;
+    const state = data.merged ? 'merged' : data.state === 'open' ? 'open' : 'closed';
+    return {
+        at: nowIso(),
+        title: data.title,
+        author: {
+            login: data.user?.login ?? 'unknown'
+        },
+        state,
+        draft: data.draft ?? false,
+        updated_at: data.updated_at
+    };
+};

package/dist/lib/schema.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { taskStatuses, taskTypes } from './types';
+export const logEntrySchema = z.object({
+    ts: z.string(),
+    msg: z.string(),
+    status: z.enum(taskStatuses).optional()
+});
+export const dayAssignmentSchema = z.object({
+    date: z.string(),
+    action: z.enum(['assign', 'unassign']),
+    ts: z.string(),
+    msg: z.string().optional()
+});
+const prRepoSchema = z.object({
+    host: z.string(),
+    owner: z.string(),
+    name: z.string()
+});
+const prFetchedSchema = z.object({
+    at: z.string(),
+    title: z.string(),
+    author: z.object({
+        login: z.string()
+    }),
+    state: z.enum(['open', 'closed', 'merged']),
+    draft: z.boolean(),
+    updated_at: z.string()
+});
+export const prAttachmentSchema = z.object({
+    url: z.string(),
+    provider: z.literal('github'),
+    repo: prRepoSchema.optional(),
+    number: z.number().int().positive().optional(),
+    fetched: prFetchedSchema.optional()
+});
+export const taskMetadataSchema = z.object({
+    url: z.string().optional(),
+    pr: prAttachmentSchema.optional()
+});
+export const taskSchema = z
+    .object({
+    id: z.string(),
+    ref: z.string(),
+    type: z.enum(taskTypes),
+    title: z.string(),
+    status: z.enum(taskStatuses),
+    created_at: z.string(),
+    updated_at: z.string(),
+    metadata: taskMetadataSchema,
+    logs: z.array(logEntrySchema),
+    day_assignments: z.array(dayAssignmentSchema)
+})
+    .superRefine((task, ctx) => {
+    if (task.type === 'pr_review' && !task.metadata.pr?.url) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'PR review tasks require metadata.pr.url',
+            path: ['metadata', 'pr', 'url']
+        });
+    }
+});
+export const validateTaskOrThrow = (task) => {
+    return taskSchema.parse(task);
+};

package/dist/lib/search.js

@@ -0,0 +1,17 @@
+export const taskMatchesQuery = (task, query) => {
+    const needle = query.toLowerCase();
+    const contains = (value) => value ? value.toLowerCase().includes(needle) : false;
+    if (contains(task.title)) {
+        return true;
+    }
+    if (task.logs.some((log) => contains(log.msg))) {
+        return true;
+    }
+    if (contains(task.metadata.pr?.url)) {
+        return true;
+    }
+    if (contains(task.metadata.pr?.fetched?.title)) {
+        return true;
+    }
+    return false;
+};