@sovovs/bycli 1.8.0 → 2.0.0

package/clis/suno/utils.test.js

@@ -1,329 +0,0 @@
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
-import {
-    DEFAULT_FORMATS,
-    SUPPORTED_FORMATS,
-    SUNO_MODELS,
-    clampSlider,
-    normalizeBooleanFlag,
-    requireNonNegativeInt,
-    parseFormats,
-    requirePositiveInt,
-    resolveSunoOutputDir,
-    sanitizeTitleForFilename,
-    unwrapEvaluateResult,
-    pollSunoClips,
-    ensureSunoSession,
-    parseSunoBillingInfo,
-} from './utils.js';
-
-describe('suno utils — parseFormats', () => {
-    it('returns the default format set when input is empty or missing', () => {
-        expect(parseFormats(undefined)).toEqual(DEFAULT_FORMATS);
-        expect(parseFormats(null)).toEqual(DEFAULT_FORMATS);
-        expect(parseFormats('')).toEqual(DEFAULT_FORMATS);
-        expect(parseFormats('   ')).toEqual(DEFAULT_FORMATS);
-    });
-
-    it('parses comma-separated input and trims whitespace', () => {
-        expect(parseFormats('mp3, wav, metadata')).toEqual(['mp3', 'wav', 'metadata']);
-    });
-
-    it('lowercases and deduplicates input', () => {
-        expect(parseFormats('MP3,Mp3,mp3,WAV')).toEqual(['mp3', 'wav']);
-    });
-
-    it('accepts array inputs (e.g. when caller passes pre-split values)', () => {
-        expect(parseFormats(['mp3', 'metadata'])).toEqual(['mp3', 'metadata']);
-    });
-
-    it('throws ArgumentError on unsupported format and lists the supported set', () => {
-        try {
-            parseFormats('mp3,flac');
-            throw new Error('should have thrown');
-        } catch (err) {
-            expect(err).toBeInstanceOf(ArgumentError);
-            expect(err.message).toContain('flac');
-            expect(err.hint).toContain(SUPPORTED_FORMATS.join(', '));
-        }
-    });
-});
-
-describe('suno utils — resolveSunoOutputDir', () => {
-    it('falls back to ~/Music/suno when no path is given', () => {
-        expect(resolveSunoOutputDir()).toBe(path.join(os.homedir(), 'Music', 'suno'));
-        expect(resolveSunoOutputDir('')).toBe(path.join(os.homedir(), 'Music', 'suno'));
-    });
-
-    it('expands ~ and ~/-prefixed relative paths to the home directory', () => {
-        expect(resolveSunoOutputDir('~')).toBe(os.homedir());
-        expect(resolveSunoOutputDir('~/Music/test')).toBe(path.join(os.homedir(), 'Music', 'test'));
-    });
-
-    it('absolute paths are returned as-is (resolved)', () => {
-        expect(resolveSunoOutputDir('/tmp/suno')).toBe('/tmp/suno');
-    });
-});
-
-describe('suno utils — sanitizeTitleForFilename', () => {
-    it('replaces filesystem-hostile characters with hyphens', () => {
-        expect(sanitizeTitleForFilename('foo/bar:baz?')).toBe('foo-bar-baz-');
-    });
-
-    it('collapses whitespace and trims', () => {
-        expect(sanitizeTitleForFilename('  hello   world  ')).toBe('hello world');
-    });
-
-    it('caps length at 60 characters', () => {
-        const long = 'a'.repeat(120);
-        expect(sanitizeTitleForFilename(long).length).toBe(60);
-    });
-
-    it('returns fallback for empty input', () => {
-        expect(sanitizeTitleForFilename('', 'untitled')).toBe('untitled');
-        expect(sanitizeTitleForFilename(null, 'fallback')).toBe('fallback');
-    });
-});
-
-describe('suno utils — clampSlider', () => {
-    it('returns the default when input is missing', () => {
-        expect(clampSlider(undefined, '--weirdness', 0.5)).toBe(0.5);
-        expect(clampSlider('', '--weirdness', 0.5)).toBe(0.5);
-        expect(clampSlider(null, '--weirdness', 0.5)).toBe(0.5);
-    });
-
-    it('parses numeric strings and accepts 0..1', () => {
-        expect(clampSlider('0', '--x', 0.5)).toBe(0);
-        expect(clampSlider('0.74', '--x', 0.5)).toBe(0.74);
-        expect(clampSlider('1', '--x', 0.5)).toBe(1);
-    });
-
-    it('rejects out-of-range or non-numeric values', () => {
-        expect(() => clampSlider('1.5', '--x', 0.5)).toThrowError(ArgumentError);
-        expect(() => clampSlider('-0.1', '--x', 0.5)).toThrowError(ArgumentError);
-        expect(() => clampSlider('hello', '--x', 0.5)).toThrowError(ArgumentError);
-    });
-});
-
-describe('suno utils — normalizeBooleanFlag', () => {
-    it('treats the canonical true-ish strings as true', () => {
-        for (const v of ['true', '1', 'yes', 'on', 'TRUE', 'On']) {
-            expect(normalizeBooleanFlag(v)).toBe(true);
-        }
-    });
-
-    it('treats unset / empty / unrecognized values as the fallback', () => {
-        expect(normalizeBooleanFlag(undefined)).toBe(false);
-        expect(normalizeBooleanFlag('', true)).toBe(true);
-        expect(normalizeBooleanFlag('maybe')).toBe(false);
-    });
-
-    it('passes through actual booleans', () => {
-        expect(normalizeBooleanFlag(true)).toBe(true);
-        expect(normalizeBooleanFlag(false)).toBe(false);
-    });
-});
-
-describe('suno utils — requirePositiveInt', () => {
-    it('returns positive integers as numbers', () => {
-        expect(requirePositiveInt(5, '--limit')).toBe(5);
-        expect(requirePositiveInt('10', '--limit')).toBe(10);
-    });
-
-    it('rejects zero, negative, and non-integer values', () => {
-        expect(() => requirePositiveInt(0, '--limit')).toThrowError(ArgumentError);
-        expect(() => requirePositiveInt(-3, '--limit')).toThrowError(ArgumentError);
-        expect(() => requirePositiveInt(1.5, '--limit')).toThrowError(ArgumentError);
-        expect(() => requirePositiveInt('not a number', '--limit')).toThrowError(ArgumentError);
-    });
-});
-
-describe('suno utils — requireNonNegativeInt', () => {
-    it('returns zero and positive integers as numbers', () => {
-        expect(requireNonNegativeInt(0, '--page')).toBe(0);
-        expect(requireNonNegativeInt('3', '--page')).toBe(3);
-    });
-
-    it('rejects negative or non-integer values', () => {
-        expect(() => requireNonNegativeInt(-1, '--page')).toThrowError(ArgumentError);
-        expect(() => requireNonNegativeInt(1.5, '--page')).toThrowError(ArgumentError);
-        expect(() => requireNonNegativeInt('nope', '--page')).toThrowError(ArgumentError);
-    });
-});
-
-describe('suno utils — unwrapEvaluateResult', () => {
-    it('unwraps Browser Bridge envelopes at evaluate boundaries', () => {
-        const payload = { ok: true, clips: [] };
-        expect(unwrapEvaluateResult({ session: 'browser:default', data: payload })).toBe(payload);
-        expect(unwrapEvaluateResult(payload)).toBe(payload);
-    });
-});
-
-describe('suno utils — parseSunoBillingInfo', () => {
-    it('resolves the free-tier plan when subscription_type is false (#1704)', () => {
-        const parsed = parseSunoBillingInfo({
-            subscription_type: false,
-            credits: 0,
-            monthly_limit: 50,
-            monthly_usage: 10,
-            total_credits_left: 40,
-            credit_packs: [],
-            plans: [
-                { id: '4497580c-f4eb-4f86-9f0e-960eb7c48d7d', name: 'Free Plan', plan_key: 'free', level: 0 },
-                { id: '3eaebef3-ef46-446a-931c-3d50cd1514f1', name: 'Pro Plan', plan_key: 'pro', level: 10 },
-            ],
-        });
-        expect(parsed.planId).toBe('4497580c-f4eb-4f86-9f0e-960eb7c48d7d');
-        expect(parsed.planKey).toBe('free');
-        expect(parsed.totalCreditsAvailable).toBe(40);
-        expect(parsed.breakdown.monthlyRemaining).toBe(40);
-        expect(parsed.breakdown.monthlyLimit).toBe(50);
-    });
-
-    it('resolves the paid-tier plan when subscription_type matches a plan_key', () => {
-        const parsed = parseSunoBillingInfo({
-            subscription_type: 'pro',
-            credits: 0,
-            monthly_limit: 2500,
-            monthly_usage: 100,
-            total_credits_left: 2400,
-            credit_packs: [{ id: 'pack-1', amount: 500 }],
-            plans: [
-                { id: 'free-uuid', name: 'Free Plan', plan_key: 'free', level: 0 },
-                { id: 'pro-uuid', name: 'Pro Plan', plan_key: 'pro', level: 10 },
-            ],
-        });
-        expect(parsed.planId).toBe('pro-uuid');
-        expect(parsed.planKey).toBe('pro');
-        expect(parsed.totalCreditsAvailable).toBe(2400);
-    });
-
-    it('falls back to subscription_type as planKey when plans[] lookup misses', () => {
-        const parsed = parseSunoBillingInfo({
-            subscription_type: 'enterprise',
-            plans: [{ plan_key: 'pro' }, { plan_key: 'premier' }],
-        });
-        expect(parsed.planId).toBeNull();
-        expect(parsed.planKey).toBe('enterprise');
-    });
-
-    it('returns planId null when plans[] is missing and there is no legacy plan field', () => {
-        const parsed = parseSunoBillingInfo({ subscription_type: false });
-        expect(parsed.planId).toBeNull();
-        expect(parsed.planKey).toBe('free');
-    });
-
-    it('honours the legacy data.plan field when plans[] does not surface a match', () => {
-        const parsed = parseSunoBillingInfo({
-            subscription_type: false,
-            plan: { id: 'legacy-uuid', plan_key: 'legacy' },
-        });
-        expect(parsed.planId).toBe('legacy-uuid');
-        expect(parsed.planKey).toBe('legacy');
-    });
-
-    it('sums credit_packs by amount and falls back to legacy credits field', () => {
-        const parsed = parseSunoBillingInfo({
-            subscription_type: false,
-            credits: 5,
-            monthly_limit: 0,
-            monthly_usage: 0,
-            credit_packs: [{ amount: 100 }, { credits: 50 }],
-            plans: [{ plan_key: 'free' }],
-        });
-        expect(parsed.breakdown.pack).toBe(5);
-        expect(parsed.breakdown.purchasedPacks).toBe(150);
-        expect(parsed.totalCreditsAvailable).toBe(155);
-    });
-});
-
-describe('suno utils — ensureSunoSession typed failures', () => {
-    function createSessionPage(sessionCheckResult) {
-        const evaluate = async (script) => {
-            if (script.includes('querySelectorAll')) return undefined;
-            if (script.includes('!!(window.Clerk && window.Clerk.session)')) return true;
-            if (script.includes('suno_device_id')) return 'device-id';
-            if (script.includes('/api/billing/info/')) return sessionCheckResult;
-            throw new Error(`unexpected evaluate script: ${script.slice(0, 80)}`);
-        };
-        return {
-            goto: async () => undefined,
-            wait: async () => undefined,
-            evaluate,
-        };
-    }
-
-    it('maps explicit logged-out session state to AuthRequiredError', async () => {
-        await expect(ensureSunoSession(createSessionPage({
-            ok: false,
-            auth: true,
-            error: 'Clerk session unavailable',
-        }))).rejects.toThrowError(AuthRequiredError);
-    });
-
-    it('does not classify billing/parser drift as logged out', async () => {
-        await expect(ensureSunoSession(createSessionPage({
-            ok: false,
-            error: 'Malformed billing/info JSON: Unexpected token <',
-        }))).rejects.toThrowError(CommandExecutionError);
-    });
-
-    it('resolves a free-tier session without throwing when subscription_type is false (#1704)', async () => {
-        const session = await ensureSunoSession(createSessionPage({
-            ok: true,
-            planId: '4497580c-f4eb-4f86-9f0e-960eb7c48d7d',
-            planKey: 'free',
-            planName: 'Free Plan',
-            totalCreditsAvailable: 40,
-            breakdown: { pack: 0, purchasedPacks: 0, monthlyRemaining: 40, monthlyLimit: 50, monthlyUsed: 10 },
-        }));
-        expect(session.planKey).toBe('free');
-        expect(session.planId).toBe('4497580c-f4eb-4f86-9f0e-960eb7c48d7d');
-        expect(session.totalCreditsAvailable).toBe(40);
-    });
-
-    it('still resolves when planId is null so read commands work even on unparseable plan shapes', async () => {
-        const session = await ensureSunoSession(createSessionPage({
-            ok: true,
-            planId: null,
-            planKey: 'free',
-            planName: null,
-            totalCreditsAvailable: 0,
-            breakdown: { pack: 0, purchasedPacks: 0, monthlyRemaining: 0, monthlyLimit: 0, monthlyUsed: 0 },
-        }));
-        expect(session.planId).toBeNull();
-        expect(session.planKey).toBe('free');
-    });
-});
-
-describe('suno utils — model + format exports', () => {
-    it('exposes the four shipping models with chirp-fenix first', () => {
-        expect(SUNO_MODELS).toContain('chirp-fenix');
-        expect(SUNO_MODELS).toContain('chirp-bluejay');
-        expect(SUNO_MODELS[0]).toBe('chirp-fenix');
-    });
-
-    it('declares mp3 + metadata as the default download set', () => {
-        expect(DEFAULT_FORMATS).toEqual(['mp3', 'metadata']);
-    });
-});
-
-describe('suno utils — pollSunoClips', () => {
-    it('fails typed on malformed feed JSON while polling generation status', async () => {
-        const page = {
-            evaluate: async () => ({ status: 200, body: null }),
-            wait: async () => {},
-        };
-        await expect(pollSunoClips(page, ['clip-a'], 1, 'device-id', 0)).rejects.toThrowError(CommandExecutionError);
-    });
-
-    it('fails typed on non-auth HTTP feed failures while polling generation status', async () => {
-        const page = {
-            evaluate: async () => ({ status: 500, body: { clips: [] } }),
-            wait: async () => {},
-        };
-        await expect(pollSunoClips(page, ['clip-a'], 1, 'device-id', 0)).rejects.toThrowError(CommandExecutionError);
-    });
-});

package/clis/taobao/commands.test.js

@@ -1,41 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './search.js';
-import './detail.js';
-import './reviews.js';
-import './cart.js';
-import './add-cart.js';
-import { createPageMock } from '../test-utils.js';
-describe('taobao command registration', () => {
-    it('registers all taobao shopping commands', () => {
-        for (const name of ['search', 'detail', 'reviews', 'cart', 'add-cart']) {
-            expect(getRegistry().get(`taobao/${name}`)).toBeDefined();
-        }
-    });
-});
-describe('taobao command safety', () => {
-    it('rejects invalid numeric ids before evaluating page scripts', async () => {
-        const page = createPageMock();
-        const detail = getRegistry().get('taobao/detail');
-        await expect(detail.func(page, { id: 'bad-id' })).rejects.toMatchObject({
-            name: 'ArgumentError',
-            code: 'ARGUMENT',
-        });
-        expect(page.goto).not.toHaveBeenCalled();
-        expect(page.evaluate).not.toHaveBeenCalled();
-    });
-    it('supports dry-run for add-cart without clicking add-to-cart', async () => {
-        const page = createPageMock();
-        const addCart = getRegistry().get('taobao/add-cart');
-        const result = await addCart.func(page, { id: '827563850178', 'dry-run': true, spec: '红色 XL' });
-        expect(result).toEqual([
-            expect.objectContaining({
-                status: 'dry-run',
-                item_id: '827563850178',
-            }),
-        ]);
-        expect(page.goto).toHaveBeenCalledTimes(1);
-        expect(page.goto).toHaveBeenCalledWith('https://www.taobao.com');
-        expect(page.evaluate).toHaveBeenCalledTimes(2);
-    });
-});

package/clis/tdx/hot-rank.test.js

@@ -1,59 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './hot-rank.js';
-
-describe('tdx hot-rank command', () => {
-  it('registers the command with correct metadata', () => {
-    const command = getRegistry().get('tdx/hot-rank');
-    expect(command).toBeDefined();
-    expect(command).toMatchObject({
-      site: 'tdx',
-      name: 'hot-rank',
-      description: expect.stringContaining('通达信'),
-      domain: 'pul.tdx.com.cn',
-      navigateBefore: true,
-    });
-    expect(command.columns).toEqual(['rank', 'symbol', 'name', 'changePercent', 'heat', 'tags']);
-  });
-
-  it('returns hot stock data from the page', async () => {
-    const command = getRegistry().get('tdx/hot-rank');
-    const mockData = [
-      { rank: 1, symbol: '600519', name: '贵州茅台', changePercent: '+2.35%', heat: '1285', tags: '白酒', },
-      { rank: 2, symbol: '000001', name: '平安银行', changePercent: '-0.80%', heat: '856', tags: '银行', },
-    ];
-    const page = {
-      goto: vi.fn().mockResolvedValue(undefined),
-      wait: vi.fn().mockResolvedValue(undefined),
-      evaluate: vi.fn().mockResolvedValue(mockData),
-    };
-    const result = await command.func(page, { limit: 20 });
-    expect(result).toHaveLength(2);
-    expect(result[0]).toEqual(mockData[0]);
-  });
-
-  it('respects the limit parameter', async () => {
-    const command = getRegistry().get('tdx/hot-rank');
-    const mockData = Array.from({ length: 30 }, (_, i) => ({
-      rank: i + 1, symbol: `${i}`, name: `stock${i}`, changePercent: '0%', heat: '0', tags: '',
-    }));
-    const page = {
-      goto: vi.fn().mockResolvedValue(undefined),
-      wait: vi.fn().mockResolvedValue(undefined),
-      evaluate: vi.fn().mockResolvedValue(mockData),
-    };
-    const result = await command.func(page, { limit: 10 });
-    expect(result).toHaveLength(10);
-  });
-
-  it('returns empty array when evaluate returns non-array', async () => {
-    const command = getRegistry().get('tdx/hot-rank');
-    const page = {
-      goto: vi.fn().mockResolvedValue(undefined),
-      wait: vi.fn().mockResolvedValue(undefined),
-      evaluate: vi.fn().mockResolvedValue(null),
-    };
-    const result = await command.func(page, { limit: 20 });
-    expect(result).toEqual([]);
-  });
-});

package/clis/ths/hot-rank.test.js

@@ -1,64 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './hot-rank.js';
-
-describe('ths hot-rank command', () => {
-  it('registers the command with correct metadata', () => {
-    const command = getRegistry().get('ths/hot-rank');
-    expect(command).toBeDefined();
-    expect(command).toMatchObject({
-      site: 'ths',
-      name: 'hot-rank',
-      description: expect.stringContaining('同花顺'),
-      domain: 'eq.10jqka.com.cn',
-      navigateBefore: true,
-    });
-    expect(command.columns).toEqual(['rank', 'name', 'changePercent', 'heat', 'tags']);
-  });
-
-  it('includes tags column', () => {
-    const command = getRegistry().get('ths/hot-rank');
-    expect(command.columns).toContain('tags');
-  });
-
-  it('returns hot stock data with tags field', async () => {
-    const command = getRegistry().get('ths/hot-rank');
-    const mockData = [
-      { rank: 1, name: '圣阳股份', changePercent: '+10.00%', heat: '28.5万', tags: '动力电池回收,钠离子电池' },
-    ];
-    const page = {
-      goto: vi.fn().mockResolvedValue(undefined),
-      wait: vi.fn().mockResolvedValue(undefined),
-      evaluate: vi.fn().mockResolvedValue(mockData),
-    };
-    const result = await command.func(page, { limit: 20 });
-    expect(result).toHaveLength(1);
-    expect(result[0].tags).toBe('动力电池回收,钠离子电池');
-    expect(result[0].name).toBe('圣阳股份');
-  });
-
-  it('respects the limit parameter', async () => {
-    const command = getRegistry().get('ths/hot-rank');
-    const mockData = Array.from({ length: 30 }, (_, i) => ({
-      rank: i + 1, name: `stock${i}`, changePercent: '0%', heat: '0', tags: '',
-    }));
-    const page = {
-      goto: vi.fn().mockResolvedValue(undefined),
-      wait: vi.fn().mockResolvedValue(undefined),
-      evaluate: vi.fn().mockResolvedValue(mockData),
-    };
-    const result = await command.func(page, { limit: 10 });
-    expect(result).toHaveLength(10);
-  });
-
-  it('returns empty array when evaluate returns non-array', async () => {
-    const command = getRegistry().get('ths/hot-rank');
-    const page = {
-      goto: vi.fn().mockResolvedValue(undefined),
-      wait: vi.fn().mockResolvedValue(undefined),
-      evaluate: vi.fn().mockResolvedValue(null),
-    };
-    const result = await command.func(page, { limit: 20 });
-    expect(result).toEqual([]);
-  });
-});

package/clis/tieba/commands.test.js

@@ -1,79 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Strategy, getRegistry } from '@sovovs/bycli/registry';
-import './hot.js';
-import './posts.js';
-import './read.js';
-import './search.js';
-describe('tieba commands', () => {
-    it('registers all tieba commands as TypeScript adapters', () => {
-        const hot = getRegistry().get('tieba/hot');
-        const posts = getRegistry().get('tieba/posts');
-        const search = getRegistry().get('tieba/search');
-        const read = getRegistry().get('tieba/read');
-        expect(hot).toBeDefined();
-        expect(posts).toBeDefined();
-        expect(search).toBeDefined();
-        expect(read).toBeDefined();
-        expect(typeof hot?.func).toBe('function');
-        expect(typeof posts?.func).toBe('function');
-        expect(typeof search?.func).toBe('function');
-        expect(typeof read?.func).toBe('function');
-    });
-    it('keeps the intended browser strategies', () => {
-        const hot = getRegistry().get('tieba/hot');
-        const posts = getRegistry().get('tieba/posts');
-        const search = getRegistry().get('tieba/search');
-        const read = getRegistry().get('tieba/read');
-        expect(hot?.strategy).toBe(Strategy.PUBLIC);
-        expect(posts?.strategy).toBe(Strategy.COOKIE);
-        expect(search?.strategy).toBe(Strategy.COOKIE);
-        expect(read?.strategy).toBe(Strategy.COOKIE);
-        expect(hot?.browser).toBe(true);
-        expect(posts?.browser).toBe(true);
-        expect(search?.browser).toBe(true);
-        expect(read?.browser).toBe(true);
-    });
-    it('keeps the public limit contract at 20 items for list commands', () => {
-        const hot = getRegistry().get('tieba/hot');
-        const posts = getRegistry().get('tieba/posts');
-        const search = getRegistry().get('tieba/search');
-        expect(hot?.args.find((arg) => arg.name === 'limit')?.default).toBe(20);
-        expect(posts?.args.find((arg) => arg.name === 'limit')?.default).toBe(20);
-        expect(search?.args.find((arg) => arg.name === 'limit')?.default).toBe(20);
-    });
-    it('rejects tieba read results when navigation lands on the wrong page number', async () => {
-        const read = getRegistry().get('tieba/read');
-        expect(read).toBeDefined();
-        expect(typeof read?.func).toBe('function');
-        const run = read?.func;
-        if (!run)
-            throw new Error('tieba/read did not register a handler');
-        const page = {
-            goto: async () => undefined,
-            evaluate: async () => ({
-                pageMeta: {
-                    pathname: '/p/10163164720',
-                    pn: '1',
-                },
-                mainPost: {
-                    title: '测试帖子',
-                    author: '作者',
-                    contentText: '正文',
-                    structuredText: '',
-                    visibleTime: '2026-03-29 12:00',
-                    structuredTime: 0,
-                    hasMedia: false,
-                },
-                replies: [],
-            }),
-        };
-        await expect(run(page, {
-            id: '10163164720',
-            page: 2,
-            limit: 5,
-        })).rejects.toMatchObject({
-            code: 'EMPTY_RESULT',
-            hint: expect.stringMatching(/requested page/i),
-        });
-    });
-});