@flemist/test-variants 2.0.4 → 3.0.0

package/dist/lib/index.cjs

@@ -4,10 +4,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var testVariants_saveErrorVariants = require('./test-variants/saveErrorVariants.cjs');
 var testVariants_createTestVariants = require('./test-variants/createTestVariants.cjs');
+var testVariants_testVariantsIterator = require('./test-variants/testVariantsIterator.cjs');
 require('tslib');
 require('fs');
 require('path');
-require('./test-variants/testVariantsIterable.cjs');
 require('./test-variants/testVariantsCreateTestRun.cjs');
 require('@flemist/async-utils');
 require('./test-variants/argsToString.cjs');
@@ -20,3 +20,4 @@ require('./garbage-collect/garbageCollect.cjs');
 
 exports.generateErrorVariantFilePath = testVariants_saveErrorVariants.generateErrorVariantFilePath;
 exports.createTestVariants = testVariants_createTestVariants.createTestVariants;
+exports.testVariantsIterator = testVariants_testVariantsIterator.testVariantsIterator;

package/dist/lib/index.d.ts

@@ -2,5 +2,6 @@ export { type Obj, type GenerateErrorVariantFilePathOptions, type SaveErrorVaria
 export { generateErrorVariantFilePath, } from "./test-variants/saveErrorVariants";
 export { type TestVariantsTemplate, type TestVariantsTemplates, type TestVariantsTemplatesExt, } from "./test-variants/testVariantsIterable";
 export { type ErrorEvent, type OnErrorCallback, type TestVariantsTest, type TestVariantsTestResult, type TestVariantsCreateTestRunOptions, type TestVariantsTestRun, type TestVariantsTestRunResult, } from "./test-variants/testVariantsCreateTestRun";
-export { type GetSeedParams, type TestVariantsFindBestErrorOptions, type TestVariantsRunOptions, type TestVariantsBestError, type TestVariantsRunResult, } from "./test-variants/testVariantsRun";
+export { type TestVariantsFindBestErrorOptions, type TestVariantsRunOptions, type TestVariantsBestError, type TestVariantsRunResult, } from "./test-variants/testVariantsRun";
 export { type TestVariantsSetArgs, type TestVariantsCall, createTestVariants, } from './test-variants/createTestVariants';
+export { type GetSeedParams, type LimitArgOnErrorOptions, type LimitArgOnError, type TestVariantsIteratorOptions, type TestVariantsIteratorLimit, type AddLimitOptions, type TestVariantsIterator, testVariantsIterator, } from "./test-variants/testVariantsIterator";

package/dist/lib/index.mjs

@@ -1,9 +1,9 @@
 export { generateErrorVariantFilePath } from './test-variants/saveErrorVariants.mjs';
 export { createTestVariants } from './test-variants/createTestVariants.mjs';
+export { testVariantsIterator } from './test-variants/testVariantsIterator.mjs';
 import 'tslib';
 import 'fs';
 import 'path';
-import './test-variants/testVariantsIterable.mjs';
 import './test-variants/testVariantsCreateTestRun.mjs';
 import '@flemist/async-utils';
 import './test-variants/argsToString.mjs';

package/dist/lib/test-variants/createTestVariants.cjs

@@ -3,9 +3,9 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
-var testVariants_testVariantsIterable = require('./testVariantsIterable.cjs');
 var testVariants_testVariantsCreateTestRun = require('./testVariantsCreateTestRun.cjs');
 var testVariants_testVariantsRun = require('./testVariantsRun.cjs');
+var testVariants_testVariantsIterator = require('./testVariantsIterator.cjs');
 require('@flemist/async-utils');
 require('./argsToString.cjs');
 require('@flemist/abort-controller-fast');
@@ -18,12 +18,15 @@ require('path');
 function createTestVariants(test) {
     return function testVariantsArgs(args) {
         return function testVariantsCall(options) {
+            var _a, _b;
             return tslib.__awaiter(this, void 0, void 0, function* () {
                 const testRun = testVariants_testVariantsCreateTestRun.testVariantsCreateTestRun(test, {
                     onError: options === null || options === void 0 ? void 0 : options.onError,
                 });
-                const variants = testVariants_testVariantsIterable.testVariantsIterable({
+                const variants = testVariants_testVariantsIterator.testVariantsIterator({
                     argsTemplates: args,
+                    getSeed: (_a = options === null || options === void 0 ? void 0 : options.findBestError) === null || _a === void 0 ? void 0 : _a.getSeed,
+                    repeatsPerVariant: (_b = options === null || options === void 0 ? void 0 : options.findBestError) === null || _b === void 0 ? void 0 : _b.repeatsPerVariant,
                 });
                 return testVariants_testVariantsRun.testVariantsRun(testRun, variants, options);
             });

package/dist/lib/test-variants/createTestVariants.mjs

@@ -1,7 +1,7 @@
 import { __awaiter } from 'tslib';
-import { testVariantsIterable } from './testVariantsIterable.mjs';
 import { testVariantsCreateTestRun } from './testVariantsCreateTestRun.mjs';
 import { testVariantsRun } from './testVariantsRun.mjs';
+import { testVariantsIterator } from './testVariantsIterator.mjs';
 import '@flemist/async-utils';
 import './argsToString.mjs';
 import '@flemist/abort-controller-fast';
@@ -14,12 +14,15 @@ import 'path';
 function createTestVariants(test) {
     return function testVariantsArgs(args) {
         return function testVariantsCall(options) {
+            var _a, _b;
             return __awaiter(this, void 0, void 0, function* () {
                 const testRun = testVariantsCreateTestRun(test, {
                     onError: options === null || options === void 0 ? void 0 : options.onError,
                 });
-                const variants = testVariantsIterable({
+                const variants = testVariantsIterator({
                     argsTemplates: args,
+                    getSeed: (_a = options === null || options === void 0 ? void 0 : options.findBestError) === null || _a === void 0 ? void 0 : _a.getSeed,
+                    repeatsPerVariant: (_b = options === null || options === void 0 ? void 0 : options.findBestError) === null || _b === void 0 ? void 0 : _b.repeatsPerVariant,
                 });
                 return testVariantsRun(testRun, variants, options);
             });

package/dist/lib/test-variants/createTestVariants.perf.cjs

@@ -3,7 +3,6 @@
 var tslib = require('tslib');
 var node = require('rdtsc/node');
 var testVariants_createTestVariants = require('./createTestVariants.cjs');
-require('./testVariantsIterable.cjs');
 require('./testVariantsCreateTestRun.cjs');
 require('@flemist/async-utils');
 require('./argsToString.cjs');
@@ -14,6 +13,7 @@ require('../garbage-collect/garbageCollect.cjs');
 require('./saveErrorVariants.cjs');
 require('fs');
 require('path');
+require('./testVariantsIterator.cjs');
 
 describe('test > testVariants perf', function () {
     this.timeout(300000);

package/dist/lib/test-variants/createTestVariants.perf.mjs

@@ -1,7 +1,6 @@
 import { __awaiter } from 'tslib';
 import { calcPerformance } from 'rdtsc/node';
 import { createTestVariants } from './createTestVariants.mjs';
-import './testVariantsIterable.mjs';
 import './testVariantsCreateTestRun.mjs';
 import '@flemist/async-utils';
 import './argsToString.mjs';
@@ -12,6 +11,7 @@ import '../garbage-collect/garbageCollect.mjs';
 import './saveErrorVariants.mjs';
 import 'fs';
 import 'path';
+import './testVariantsIterator.mjs';
 
 describe('test > testVariants perf', function () {
     this.timeout(300000);

package/dist/lib/test-variants/testVariantsIterable.cjs

@@ -2,6 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+/**
+ * @deprecated Use testVariantsIterator instead
+ */
 function testVariantsIterable({ argsTemplates, }) {
     return {
         [Symbol.iterator]() {

package/dist/lib/test-variants/testVariantsIterable.d.ts

@@ -9,4 +9,7 @@ export declare type TestVariantsTemplatesExt<Args extends Obj, ArgsExtra extends
 export declare type TestVariantsIterableOptions<Args extends Obj, ArgsExtra extends Obj> = {
     argsTemplates: TestVariantsTemplatesExt<Args, ArgsExtra>;
 };
+/**
+ * @deprecated Use testVariantsIterator instead
+ */
 export declare function testVariantsIterable<Args extends Obj, ArgsExtra extends Obj>({ argsTemplates, }: TestVariantsIterableOptions<Args, ArgsExtra>): Iterable<Args>;

package/dist/lib/test-variants/testVariantsIterable.mjs

@@ -1,3 +1,6 @@
+/**
+ * @deprecated Use testVariantsIterator instead
+ */
 function testVariantsIterable({ argsTemplates, }) {
     return {
         [Symbol.iterator]() {

package/dist/lib/test-variants/testVariantsIterator.cjs

@@ -0,0 +1,357 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/** Find last index of value in array; uses custom equals or strict equality */
+function findLastIndex(values, value, equals) {
+    if (equals) {
+        for (let i = values.length - 1; i >= 0; i--) {
+            if (equals(values[i], value)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    for (let i = values.length - 1; i >= 0; i--) {
+        if (values[i] === value) {
+            return i;
+        }
+    }
+    return -1;
+}
+/** Calculate template values for given key index */
+function calcTemplateValues(templates, args, keyIndex) {
+    const template = templates[keyIndex];
+    if (typeof template === 'function') {
+        return template(args);
+    }
+    return template;
+}
+/** Reset iterator state for new cycle */
+function resetIteratorState(state, templates, keysCount) {
+    state.index = -1;
+    state.repeatIndex = 0;
+    for (let i = 0; i < keysCount; i++) {
+        state.indexes[i] = -1;
+        state.variants[i] = [];
+    }
+    if (keysCount > 0) {
+        state.variants[0] = calcTemplateValues(templates, state.args, 0);
+    }
+}
+/** Get effective max index for an arg (considering argLimit) */
+function getMaxIndex(state, keyIndex) {
+    const variantsLen = state.variants[keyIndex].length;
+    const argLimit = state.argLimits[keyIndex];
+    if (argLimit == null) {
+        return variantsLen;
+    }
+    return argLimit < variantsLen ? argLimit : variantsLen;
+}
+/** Advance to next variant in cartesian product; returns true if successful */
+function advanceVariant(state, templates, keys, keysCount) {
+    var _a;
+    for (let keyIndex = keysCount - 1; keyIndex >= 0; keyIndex--) {
+        const valueIndex = state.indexes[keyIndex] + 1;
+        const maxIndex = getMaxIndex(state, keyIndex);
+        if (valueIndex < maxIndex) {
+            const key = keys[keyIndex];
+            const value = state.variants[keyIndex][valueIndex];
+            state.indexes[keyIndex] = valueIndex;
+            state.args[key] = value;
+            for (keyIndex++; keyIndex < keysCount; keyIndex++) {
+                const keyVariants = calcTemplateValues(templates, state.args, keyIndex);
+                const keyMaxIndex = (_a = state.argLimits[keyIndex]) !== null && _a !== void 0 ? _a : keyVariants.length;
+                if (keyVariants.length === 0 || keyMaxIndex <= 0) {
+                    break;
+                }
+                state.indexes[keyIndex] = 0;
+                state.variants[keyIndex] = keyVariants;
+                const key = keys[keyIndex];
+                const value = keyVariants[0];
+                state.args[key] = value;
+            }
+            if (keyIndex >= keysCount) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/** Validate saved args keys match iterator's arg names (ignoring "seed" key) */
+function validateArgsKeys(savedArgs, keysSet, keysCount) {
+    const savedKeys = Object.keys(savedArgs).filter(k => k !== 'seed');
+    if (savedKeys.length !== keysCount) {
+        return false;
+    }
+    for (const key of savedKeys) {
+        if (!keysSet.has(key)) {
+            return false;
+        }
+    }
+    return true;
+}
+/** For static templates, verify arg value exists in template values */
+function validateStaticArgsValues(savedArgs, templates, keys, keysCount, equals) {
+    for (let i = 0; i < keysCount; i++) {
+        const template = templates[i];
+        if (typeof template !== 'function') {
+            const value = savedArgs[keys[i]];
+            if (findLastIndex(template, value, equals) < 0) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/** Check if current position >= pending args position; returns false if current < pending or all args skipped */
+function isPositionReached(state, pendingArgs, keys, keysCount, equals) {
+    let anyCompared = false;
+    for (let i = 0; i < keysCount; i++) {
+        const currentValueIndex = state.indexes[i];
+        const pendingValue = pendingArgs[keys[i]];
+        const pendingValueIndex = findLastIndex(state.variants[i], pendingValue, equals);
+        // Dynamic template value not found - skip this arg from comparison
+        if (pendingValueIndex < 0) {
+            continue;
+        }
+        anyCompared = true;
+        if (currentValueIndex < pendingValueIndex) {
+            return false;
+        }
+        if (currentValueIndex > pendingValueIndex) {
+            return true;
+        }
+    }
+    // All compared args are equal - position reached; or all args skipped - keep pending
+    return anyCompared;
+}
+/** Update per-arg limits from args values */
+function updateArgLimits(state, limitArgs, templates, keys, keysCount, equals, limitArgOnError) {
+    if (!limitArgOnError) {
+        return;
+    }
+    for (let i = 0; i < keysCount; i++) {
+        const key = keys[i];
+        const value = limitArgs[key];
+        const values = state.variants[i].length > 0
+            ? state.variants[i]
+            : calcTemplateValues(templates, state.args, i);
+        const valueIndex = findLastIndex(values, value, equals);
+        // Skip if value not found or already at index 0
+        if (valueIndex <= 0) {
+            continue;
+        }
+        // Check callback if provided
+        if (typeof limitArgOnError === 'function') {
+            const shouldLimit = limitArgOnError({
+                name: key,
+                valueIndex,
+                values,
+                maxValueIndex: state.argLimits[i],
+            });
+            if (!shouldLimit) {
+                continue;
+            }
+        }
+        // Update limit: argLimit = min(current argLimit, valueIndex)
+        const currentLimit = state.argLimits[i];
+        if (currentLimit == null || valueIndex < currentLimit) {
+            state.argLimits[i] = valueIndex;
+        }
+    }
+}
+/** Process pending limits; returns true if any limit was applied */
+function processPendingLimits(state, templates, keys, keysCount, equals, limitArgOnError) {
+    let applied = false;
+    for (let i = state.pendingLimits.length - 1; i >= 0; i--) {
+        const pending = state.pendingLimits[i];
+        if (isPositionReached(state, pending.args, keys, keysCount, equals)) {
+            // Current position >= pending position: apply limit
+            if (state.count == null || state.index < state.count) {
+                state.count = state.index;
+                state.limit = typeof pending.error !== 'undefined'
+                    ? { args: pending.args, error: pending.error }
+                    : { args: pending.args };
+                updateArgLimits(state, pending.args, templates, keys, keysCount, equals, limitArgOnError);
+                applied = true;
+            }
+            // Remove from pending
+            state.pendingLimits.splice(i, 1);
+        }
+    }
+    return applied;
+}
+/** Creates test variants iterator with limiting capabilities */
+function testVariantsIterator(options) {
+    const { argsTemplates, getSeed, repeatsPerVariant: _repeatsPerVariant, equals, limitArgOnError } = options;
+    const repeatsPerVariant = _repeatsPerVariant !== null && _repeatsPerVariant !== void 0 ? _repeatsPerVariant : 1;
+    const keys = Object.keys(argsTemplates);
+    const templates = Object.values(argsTemplates);
+    const keysCount = keys.length;
+    const keysSet = new Set(keys);
+    // Initialize state
+    const indexes = [];
+    const variants = [];
+    const argLimits = [];
+    for (let i = 0; i < keysCount; i++) {
+        indexes[i] = -1;
+        variants[i] = [];
+        argLimits[i] = null;
+    }
+    const state = {
+        args: {},
+        indexes,
+        variants,
+        argLimits,
+        index: -1,
+        cycleIndex: -1,
+        repeatIndex: 0,
+        count: null,
+        limit: null,
+        started: false,
+        currentArgs: null,
+        pendingLimits: [],
+    };
+    const iterator = {
+        get index() {
+            return state.index;
+        },
+        get cycleIndex() {
+            return state.cycleIndex;
+        },
+        get count() {
+            return state.count;
+        },
+        get limit() {
+            return state.limit;
+        },
+        addLimit(_options) {
+            const hasArgs = typeof (_options === null || _options === void 0 ? void 0 : _options.args) !== 'undefined' && _options.args !== null;
+            const hasIndex = (_options === null || _options === void 0 ? void 0 : _options.index) != null;
+            // addLimit() or addLimit({error}) - uses current args and index
+            if (!hasArgs && !hasIndex) {
+                if (state.index < 0) {
+                    throw new Error('[testVariantsIterator] addLimit() requires at least one next() call');
+                }
+                if (state.count == null || state.index < state.count) {
+                    state.count = state.index;
+                    state.limit = typeof (_options === null || _options === void 0 ? void 0 : _options.error) !== 'undefined'
+                        ? { args: state.currentArgs, error: _options.error }
+                        : { args: state.currentArgs };
+                    updateArgLimits(state, state.args, templates, keys, keysCount, equals, limitArgOnError);
+                }
+                return;
+            }
+            // addLimit({index}) - only index limiting, no args
+            if (hasIndex && !hasArgs) {
+                if (state.count == null || _options.index < state.count) {
+                    state.count = _options.index;
+                }
+                return;
+            }
+            // addLimit({args}) or addLimit({args, error}) - pending limit
+            if (hasArgs && !hasIndex) {
+                // Validate args keys match iterator's arg names
+                if (!validateArgsKeys(_options.args, keysSet, keysCount)) {
+                    return; // Discard - unreproducible (templates changed)
+                }
+                // For static templates, verify arg value exists
+                if (!validateStaticArgsValues(_options.args, templates, keys, keysCount, equals)) {
+                    return; // Discard - unreproducible (value not in template)
+                }
+                // Store as pending limit
+                const pending = typeof _options.error !== 'undefined'
+                    ? { args: _options.args, error: _options.error }
+                    : { args: _options.args };
+                state.pendingLimits.push(pending);
+                return;
+            }
+            // addLimit({args, index}) or addLimit({args, index, error}) - immediate index + pending args
+            if (hasArgs && hasIndex) {
+                // Check if this is earliest (before potentially updating count)
+                const isEarliest = state.count == null || _options.index < state.count;
+                // Always apply index limit
+                if (isEarliest) {
+                    state.count = _options.index;
+                }
+                // Validate args for limit property update
+                if (!validateArgsKeys(_options.args, keysSet, keysCount)) {
+                    return; // Skip per-arg limits and limit property update
+                }
+                if (!validateStaticArgsValues(_options.args, templates, keys, keysCount, equals)) {
+                    return; // Skip per-arg limits and limit property update
+                }
+                // Update limit if this is earliest
+                if (isEarliest) {
+                    state.limit = typeof _options.error !== 'undefined'
+                        ? { args: _options.args, error: _options.error }
+                        : { args: _options.args };
+                    updateArgLimits(state, _options.args, templates, keys, keysCount, equals, limitArgOnError);
+                }
+            }
+        },
+        start() {
+            state.cycleIndex++;
+            resetIteratorState(state, templates, keysCount);
+            state.started = true;
+        },
+        next() {
+            if (!state.started) {
+                throw new Error('[testVariantsIterator] start() must be called before next()');
+            }
+            // Try next repeat for current variant
+            if (state.index >= 0 && state.repeatIndex + 1 < repeatsPerVariant) {
+                // Check if current variant is still within limit
+                if (state.count == null || state.index < state.count) {
+                    state.repeatIndex++;
+                    if (getSeed) {
+                        const seed = getSeed({
+                            variantIndex: state.index,
+                            cycleIndex: state.cycleIndex,
+                            repeatIndex: state.repeatIndex,
+                        });
+                        state.currentArgs = Object.assign(Object.assign({}, state.args), { seed });
+                    }
+                    else {
+                        state.currentArgs = Object.assign({}, state.args);
+                    }
+                    return state.currentArgs;
+                }
+            }
+            // Move to next variant
+            state.repeatIndex = 0;
+            if (!advanceVariant(state, templates, keys, keysCount)) {
+                // First complete cycle sets count to total variant count
+                if (state.count == null) {
+                    state.count = state.index + 1;
+                }
+                return null;
+            }
+            state.index++;
+            // Process pending limits at new position
+            if (state.pendingLimits.length > 0) {
+                processPendingLimits(state, templates, keys, keysCount, equals, limitArgOnError);
+            }
+            // Check count limit (may have been updated by pending limit)
+            if (state.count != null && state.index >= state.count) {
+                return null;
+            }
+            if (getSeed) {
+                const seed = getSeed({
+                    variantIndex: state.index,
+                    cycleIndex: state.cycleIndex,
+                    repeatIndex: state.repeatIndex,
+                });
+                state.currentArgs = Object.assign(Object.assign({}, state.args), { seed });
+            }
+            else {
+                state.currentArgs = Object.assign({}, state.args);
+            }
+            return state.currentArgs;
+        },
+    };
+    return iterator;
+}
+
+exports.testVariantsIterator = testVariantsIterator;

package/dist/lib/test-variants/testVariantsIterator.d.ts

@@ -0,0 +1,67 @@
+import type { Obj } from "./types";
+import type { TestVariantsTemplate, TestVariantsTemplates } from "./testVariantsIterable";
+/** Parameters passed to getSeed function for generating test seeds */
+export declare type GetSeedParams = {
+    /** Index of current variant/parameter-combination being tested */
+    variantIndex: number;
+    /** Index of current cycle - full pass through all variants (0..cycles-1) */
+    cycleIndex: number;
+    /** Index of repeat for current variant within this cycle (0..repeatsPerVariant-1) */
+    repeatIndex: number;
+};
+/** Options for limiting per-arg indexes on error */
+export declare type LimitArgOnErrorOptions = {
+    /** Arg name */
+    name: string;
+    /** Arg value's index in template values array */
+    valueIndex: number;
+    /** Current template values array for this arg */
+    values: any[];
+    /** Current max value index limit for this arg; null if no limit */
+    maxValueIndex: number | null;
+};
+/** Callback to decide whether to apply limit for specific arg */
+export declare type LimitArgOnError = (options: LimitArgOnErrorOptions) => boolean;
+/** Options for creating test variants iterator */
+export declare type TestVariantsIteratorOptions<Args extends Obj> = {
+    argsTemplates: TestVariantsTemplates<Args>;
+    /** Custom equality for comparing arg values when finding indexes */
+    equals?: null | ((a: any, b: any) => boolean);
+    /** Limit per-arg indexes on error; boolean enables/disables, function for custom per-arg logic */
+    limitArgOnError?: null | boolean | LimitArgOnError;
+    /** Seed generator for findBestError; if provided, seed is added to args returned by next() */
+    getSeed?: null | ((params: GetSeedParams) => any);
+    /** Number of repeat tests per variant within each cycle */
+    repeatsPerVariant?: null | number;
+};
+/** Limit information with args and optional error */
+export declare type TestVariantsIteratorLimit<Args> = {
+    args: Args;
+    error?: unknown;
+};
+/** Options for addLimit method */
+export declare type AddLimitOptions<Args> = {
+    args?: null | Args;
+    index?: null | number;
+    error?: unknown;
+};
+/** Test variants iterator with limiting capabilities */
+export declare type TestVariantsIterator<Args extends Obj> = {
+    /** Current variant index; -1 before first next() */
+    readonly index: number;
+    /** Current cycle index; -1 before first start(), 0 after first start(), incremented by each start() call */
+    readonly cycleIndex: number;
+    /** Limit or max count; variants with index >= count not yielded; null initially, set when first next() returns null or via addLimit({index}) */
+    readonly count: number | null;
+    /** Last applied limit's args and error; null if no limit applied yet or limit was index-only */
+    readonly limit: TestVariantsIteratorLimit<Args> | null;
+    /** Add or tighten limit based on args and/or index */
+    addLimit(options?: null | AddLimitOptions<Args>): void;
+    /** Reset to beginning of iteration; increments cycleIndex */
+    start(): void;
+    /** Get next variant or null when done */
+    next(): Args | null;
+};
+export { type TestVariantsTemplate, type TestVariantsTemplates, };
+/** Creates test variants iterator with limiting capabilities */
+export declare function testVariantsIterator<Args extends Obj>(options: TestVariantsIteratorOptions<Args>): TestVariantsIterator<Args>;