@vpmedia/simplify 1.74.0 → 1.75.0

package/src/util/validate.test.ts

@@ -0,0 +1,309 @@
+import {
+  isArray,
+  isArrayOf,
+  isBoolean,
+  isEnum,
+  isFunction,
+  isInstance,
+  isInteger,
+  isNonNegativeInteger,
+  isNonNegativeNumber,
+  isNull,
+  isNumber,
+  isPlainObject,
+  isPlainObjectOf,
+  isAnyOf,
+  isPositiveInteger,
+  isPositiveNumber,
+  isString,
+  isUndefined,
+  refineValidator,
+  isNumberLess,
+  isNumberGreater,
+  isNumberLessOrEqual,
+  isNumberGreaterOrEqual,
+  isIntegerLess,
+  isIntegerGreater,
+  isIntegerLessOrEqual,
+  isIntegerGreaterOrEqual,
+  isNumberInRange,
+  isIntegerInRange,
+  isArrayLengthEqual,
+  isArrayLengthInRange,
+  isStringLengthEqual,
+  isStringLengthInRange,
+  isNullOrUndefined,
+} from './validate.js';
+
+describe('validate', () => {
+  test('isArray', () => {
+    expect(isArray('string')).toBe(false);
+    expect(isArray([])).toBe(true);
+    expect(isArray([1, 2, 3])).toBe(true);
+    expect(isArray({ string: '1' })).toBe(false);
+    expect(isArray(0.1)).toBe(false);
+    expect(isArray(1)).toBe(false);
+    expect(isArray(false)).toBe(false);
+    expect(isArray(null)).toBe(false);
+    expect(isArray(true)).toBe(false);
+    expect(isArray(undefined)).toBe(false);
+    expect(isArray(() => true)).toBe(false);
+  });
+
+  test('isBoolean', () => {
+    expect(isBoolean('string')).toBe(false);
+    expect(isBoolean([])).toBe(false);
+    expect(isBoolean([1, 2, 3])).toBe(false);
+    expect(isBoolean({ string: '1' })).toBe(false);
+    expect(isBoolean(0.1)).toBe(false);
+    expect(isBoolean(1)).toBe(false);
+    expect(isBoolean(false)).toBe(true);
+    expect(isBoolean(null)).toBe(false);
+    expect(isBoolean(true)).toBe(true);
+    expect(isBoolean(undefined)).toBe(false);
+    expect(isBoolean(() => true)).toBe(false);
+  });
+
+  test('isNumber', () => {
+    expect(isNumber('string')).toBe(false);
+    expect(isNumber([])).toBe(false);
+    expect(isNumber([1, 2, 3])).toBe(false);
+    expect(isNumber({ string: '1' })).toBe(false);
+    expect(isNumber(0.1)).toBe(true);
+    expect(isNumber(1)).toBe(true);
+    expect(isNumber(false)).toBe(false);
+    expect(isNumber(null)).toBe(false);
+    expect(isNumber(Number.NaN)).toBe(false);
+    expect(isNumber(Number.POSITIVE_INFINITY)).toBe(false);
+    expect(isNumber(true)).toBe(false);
+    expect(isNumber(undefined)).toBe(false);
+    expect(isNumber(() => true)).toBe(false);
+  });
+
+  test('isPositiveNumber', () => {
+    expect(isPositiveNumber(0)).toBe(false);
+    expect(isPositiveNumber(1)).toBe(true);
+    expect(isPositiveNumber(1.1)).toBe(true);
+    expect(isPositiveNumber(-1)).toBe(false);
+    expect(isPositiveNumber(-1.1)).toBe(false);
+  });
+
+  test('isNonNegativeNumber', () => {
+    expect(isNonNegativeNumber(0)).toBe(true);
+    expect(isNonNegativeNumber(1)).toBe(true);
+    expect(isNonNegativeNumber(1.1)).toBe(true);
+    expect(isNonNegativeNumber(-1)).toBe(false);
+    expect(isNonNegativeNumber(-1.1)).toBe(false);
+  });
+
+  test('isInteger', () => {
+    expect(isInteger('string')).toBe(false);
+    expect(isInteger(() => true)).toBe(false);
+    expect(isInteger([])).toBe(false);
+    expect(isInteger([1, 2, 3])).toBe(false);
+    expect(isInteger({ string: '1' })).toBe(false);
+    expect(isInteger(0.1)).toBe(false);
+    expect(isInteger(1)).toBe(true);
+    expect(isInteger(false)).toBe(false);
+    expect(isInteger(null)).toBe(false);
+    expect(isInteger(Number.NaN)).toBe(false);
+    expect(isInteger(Number.POSITIVE_INFINITY)).toBe(false);
+    expect(isInteger(true)).toBe(false);
+    expect(isInteger(undefined)).toBe(false);
+  });
+
+  test('isPositiveInteger', () => {
+    expect(isPositiveInteger(0)).toBe(false);
+    expect(isPositiveInteger(1)).toBe(true);
+    expect(isPositiveInteger(1.1)).toBe(false);
+    expect(isPositiveInteger(-1)).toBe(false);
+    expect(isPositiveInteger(-1.1)).toBe(false);
+  });
+
+  test('isNonNegativeInteger', () => {
+    expect(isNonNegativeInteger(0)).toBe(true);
+    expect(isNonNegativeInteger(1)).toBe(true);
+    expect(isNonNegativeInteger(1.1)).toBe(false);
+    expect(isNonNegativeInteger(-1)).toBe(false);
+    expect(isNonNegativeInteger(-1.1)).toBe(false);
+  });
+
+  test('isString', () => {
+    expect(isString('string')).toBe(true);
+    expect(isString([])).toBe(false);
+    expect(isString([1, 2, 3])).toBe(false);
+    expect(isString({ string: '1' })).toBe(false);
+    expect(isString(0.1)).toBe(false);
+    expect(isString(1)).toBe(false);
+    expect(isString(false)).toBe(false);
+    expect(isString(null)).toBe(false);
+    expect(isString(true)).toBe(false);
+    expect(isString(undefined)).toBe(false);
+    expect(isString(() => true)).toBe(false);
+  });
+
+  test('isFunction', () => {
+    expect(isFunction('string')).toBe(false);
+    expect(isFunction([])).toBe(false);
+    expect(isFunction([1, 2, 3])).toBe(false);
+    expect(isFunction({ string: '1' })).toBe(false);
+    expect(isFunction(0.1)).toBe(false);
+    expect(isFunction(1)).toBe(false);
+    expect(isFunction(false)).toBe(false);
+    expect(isFunction(null)).toBe(false);
+    expect(isFunction(true)).toBe(false);
+    expect(isFunction(undefined)).toBe(false);
+    expect(isFunction(() => true)).toBe(true);
+  });
+
+  test('isNull', () => {
+    expect(isNull('string')).toBe(false);
+    expect(isNull([])).toBe(false);
+    expect(isNull([1, 2, 3])).toBe(false);
+    expect(isNull({ string: '1' })).toBe(false);
+    expect(isNull(0.1)).toBe(false);
+    expect(isNull(1)).toBe(false);
+    expect(isNull(false)).toBe(false);
+    expect(isNull(null)).toBe(true);
+    expect(isNull(true)).toBe(false);
+    expect(isNull(undefined)).toBe(false);
+    expect(isNull(() => true)).toBe(false);
+  });
+
+  test('isUndefined', () => {
+    expect(isUndefined('string')).toBe(false);
+    expect(isUndefined([])).toBe(false);
+    expect(isUndefined([1, 2, 3])).toBe(false);
+    expect(isUndefined({ string: '1' })).toBe(false);
+    expect(isUndefined(0.1)).toBe(false);
+    expect(isUndefined(1)).toBe(false);
+    expect(isUndefined(false)).toBe(false);
+    expect(isUndefined(null)).toBe(false);
+    expect(isUndefined(true)).toBe(false);
+    expect(isUndefined(undefined)).toBe(true);
+    expect(isUndefined(() => true)).toBe(false);
+  });
+
+  test('isNullOrUndefined', () => {
+    expect(isNullOrUndefined('string')).toBe(false);
+    expect(isNullOrUndefined([])).toBe(false);
+    expect(isNullOrUndefined([1, 2, 3])).toBe(false);
+    expect(isNullOrUndefined({ string: '1' })).toBe(false);
+    expect(isNullOrUndefined(0.1)).toBe(false);
+    expect(isNullOrUndefined(1)).toBe(false);
+    expect(isNullOrUndefined(false)).toBe(false);
+    expect(isNullOrUndefined(null)).toBe(true);
+    expect(isNullOrUndefined(true)).toBe(false);
+    expect(isNullOrUndefined(undefined)).toBe(true);
+    expect(isNullOrUndefined(() => true)).toBe(false);
+  });
+
+  test('isPlainObject', () => {
+    expect(isPlainObject('string')).toBe(false);
+    expect(isPlainObject(() => true)).toBe(false);
+    expect(isPlainObject([])).toBe(false);
+    expect(isPlainObject([1, 2, 3])).toBe(false);
+    expect(isPlainObject({ string: '1' })).toBe(true);
+    expect(isPlainObject(0.1)).toBe(false);
+    expect(isPlainObject(1)).toBe(false);
+    expect(isPlainObject(false)).toBe(false);
+    expect(isPlainObject(new Date())).toBe(false);
+    expect(isPlainObject(null)).toBe(false);
+    expect(isPlainObject(true)).toBe(false);
+    expect(isPlainObject(undefined)).toBe(false);
+  });
+
+  test('isInstance', () => {
+    class CustomError extends Error {
+      override name = 'CustomError';
+    }
+    // @ts-expect-error
+    expect(isInstance({}, {})).toBe(false);
+    expect(isInstance({}, Number)).toBe(false);
+    // @ts-expect-error
+    expect(isInstance(new CustomError(), {})).toBe(false);
+    expect(isInstance(new CustomError(), Error)).toBe(true);
+    expect(isInstance(new CustomError(), Number)).toBe(false);
+    expect(isInstance(new Date(), Date)).toBe(true);
+  });
+
+  test('isEnum', () => {
+    expect(isEnum(0, [1, 2])).toBe(false);
+    expect(isEnum(1, [1, 2])).toBe(true);
+    expect(isEnum('AB', ['AB', 'CD'])).toBe(true);
+    expect(isEnum('EF', ['AB', 'CD'])).toBe(false);
+    expect(isEnum('AB', { AB: 'AB', CD: 'CD' })).toBe(true);
+    expect(isEnum('EF', { AB: 'AB', CD: 'CD' })).toBe(false);
+    expect(isEnum('AB', new Set(['AB', 'CD']))).toBe(true);
+    expect(isEnum('EF', new Set(['AB', 'CD']))).toBe(false);
+    expect(isEnum('EF', null)).toBe(false);
+    expect(isEnum('EF', undefined)).toBe(false);
+    // @ts-expect-error
+    expect(isEnum('EF', 1)).toBe(false);
+    // @ts-expect-error
+    expect(isEnum('EF', 'string')).toBe(false);
+    // @ts-expect-error
+    expect(isEnum(false, 'string')).toBe(false);
+  });
+
+  test('isArrayOf', () => {
+    expect(isArrayOf(0.1, isNumber)).toBe(false);
+    expect(isArrayOf([0.1, 'string'], isNumber)).toBe(false);
+    expect(isArrayOf([0.1, 0.2], isNumber)).toBe(true);
+    expect(isArrayOf([0.1, 1, 2], isInteger)).toBe(false);
+    expect(isArrayOf([1, 2], isInteger)).toBe(true);
+    expect(isArrayOf([1, 'string', undefined], isAnyOf(isInteger, isNullOrUndefined))).toBe(false);
+    expect(isArrayOf([1, null, undefined], isAnyOf(isInteger, isNullOrUndefined))).toBe(true);
+  });
+
+  test('isPlainObjectOf', () => {
+    expect(isPlainObjectOf(0.1, isNumber)).toBe(false);
+    expect(isPlainObjectOf({ a: 0.1, b: 'string' }, isNumber)).toBe(false);
+    expect(isPlainObjectOf({ a: 0.1, b: 0.2 }, isNumber)).toBe(true);
+    expect(isPlainObjectOf({ a: 0.1, b: 1, c: 2 }, isInteger)).toBe(false);
+    expect(isPlainObjectOf({ a: 1, b: 2 }, isInteger)).toBe(true);
+  });
+
+  test('isAnyOf', () => {
+    expect(isAnyOf(isNumber, isNull)(1)).toBe(true);
+    expect(isAnyOf(isNumber, isNull)(null)).toBe(true);
+    expect(isAnyOf(isNumber, isNull)('string')).toBe(false);
+  });
+
+  test('refineValidator', () => {
+    expect(refineValidator(isNumber, (v) => v > 0)(-1)).toBe(false);
+    expect(refineValidator(isNumber, (v) => v > 0)(1)).toBe(true);
+    expect(refineValidator(isNumber, (v) => v > 0).name).toBe('isNumberRefined');
+  });
+
+  test('isRefinedExtensions', () => {
+    expect(isNumberLess(0)(-1.1)).toBe(true);
+    expect(isNumberLess(0)(0)).toBe(false);
+    expect(isNumberLessOrEqual(0)(0)).toBe(true);
+    expect(isNumberGreater(0)(0)).toBe(false);
+    expect(isNumberGreater(0)(1.1)).toBe(true);
+    expect(isNumberGreaterOrEqual(0)(0)).toBe(true);
+    expect(isNumberInRange(0, 1.1)(0)).toBe(true);
+    expect(isNumberInRange.name).toBe('isNumberInRange');
+
+    expect(isIntegerLess(0)(-1)).toBe(true);
+    expect(isIntegerLess(0)(0)).toBe(false);
+    expect(isIntegerLessOrEqual(0)(0)).toBe(true);
+    expect(isIntegerGreater(0)(0)).toBe(false);
+    expect(isIntegerGreater(0)(1)).toBe(true);
+    expect(isIntegerGreater(0)(1.1)).toBe(false);
+    expect(isIntegerGreaterOrEqual(0)(0)).toBe(true);
+    expect(isIntegerInRange(0, 1)(0)).toBe(true);
+    expect(isIntegerInRange(0, 1)(2)).toBe(false);
+
+    expect(isStringLengthEqual(1)('a')).toBe(true);
+    expect(isStringLengthEqual(1)('ab')).toBe(false);
+    expect(isStringLengthInRange(1, 2)('ab')).toBe(true);
+    expect(isStringLengthInRange(1, 2)('abc')).toBe(false);
+
+    expect(isArrayLengthEqual(1)([1])).toBe(true);
+    expect(isArrayLengthEqual(1)([1, 2])).toBe(false);
+    expect(isArrayLengthInRange(1, 2)([1, 2])).toBe(true);
+    expect(isArrayLengthInRange(1, 2)([1, 2, 3])).toBe(false);
+  });
+});

package/src/util/validate.ts

@@ -0,0 +1,230 @@
+import { isEqual, isGreater, isGreaterOrEqual, isInRange, isLess, isLessOrEqual } from './number.js';
+
+export type Validator<T> = (value: unknown) => value is T;
+
+/**
+ * Validates `value` as `boolean`.
+ */
+export const isBoolean = (value: unknown): value is boolean => typeof value === 'boolean';
+
+/**
+ * Validates `value` as `number`.
+ */
+export const isNumber = (value: unknown): value is number => typeof value === 'number' && Number.isFinite(value);
+
+/**
+ * Validates `value` as positive `number`.
+ */
+export const isPositiveNumber = (value: unknown): value is number => isNumber(value) && value > 0;
+
+/**
+ * Validates `value` as non-negative `number`.
+ */
+export const isNonNegativeNumber = (value: unknown): value is number => isNumber(value) && value >= 0;
+
+/**
+ * Validates `value` as `integer`.
+ */
+export const isInteger = (value: unknown): value is number => isNumber(value) && Number.isInteger(value);
+
+/**
+ * Validates `value` as positive `integer`.
+ */
+export const isPositiveInteger = (value: unknown): value is number => isInteger(value) && value > 0;
+
+/**
+ * Validates `value` as non-negative `integer`.
+ */
+export const isNonNegativeInteger = (value: unknown): value is number => isInteger(value) && value >= 0;
+
+/**
+ * Validates `value` as `string`.
+ */
+export const isString = (value: unknown): value is string => typeof value === 'string';
+
+/**
+ * Validates `value` as `array`.
+ */
+export const isArray = <T = unknown>(value: unknown): value is T[] => Array.isArray(value);
+
+/**
+ * Validates `value` as `null`.
+ */
+export const isNull = (value: unknown): value is null => value === null;
+
+/**
+ * Validates `value` as `undefined`.
+ */
+export const isUndefined = (value: unknown): value is undefined => value === undefined;
+
+/**
+ * Validates `value` as `null` or `undefined`.
+ */
+export const isNullOrUndefined = (value: unknown): value is null | undefined => isNull(value) || isUndefined(value);
+
+/**
+ * Validates `value` as plain `object`.
+ */
+export const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+  Object.prototype.toString.call(value) === '[object Object]';
+
+/**
+ * Validates `value` as `function`.
+ */
+export const isFunction = (value: unknown): value is (...args: any[]) => any => typeof value === 'function';
+
+/**
+ * Validates `value` as `type`.
+ */
+export const isInstance = <T>(value: unknown, type: new (...args: any[]) => T): value is T =>
+  isFunction(type) && value instanceof type;
+
+/**
+ * Validates `value` as `enum`.
+ */
+export const isEnum = (
+  value: unknown,
+  choices:
+    | ReadonlyArray<string | number>
+    | ReadonlySet<string | number>
+    | Readonly<Record<string | number, string | number>>
+    | null
+    | undefined
+): boolean => {
+  if (!isString(value) && !isNumber(value)) {
+    return false;
+  }
+  return (
+    (isArray<string | number>(choices) && choices.includes(value)) ||
+    (isPlainObject(choices) && Object.values(choices).includes(value)) ||
+    (isInstance(choices, Set) && (choices as Set<string | number>).has(value))
+  );
+};
+
+/**
+ * Type check an array of values using a validator.
+ */
+export const isArrayOf = <T>(values: unknown, validator: Validator<T>): values is T[] => {
+  if (!isArray(values)) {
+    return false;
+  }
+  for (const value of values) {
+    if (!validator(value)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * Type check a plain object of values using a validator.
+ */
+export const isPlainObjectOf = <T>(
+  record: unknown,
+  validator: Validator<T>
+): record is Record<string | number, T> => {
+  if (!isPlainObject(record)) {
+    return false;
+  }
+  for (const value of Object.values(record)) {
+    if (!validator(value)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * Refine a base validator with an extra condition.
+ */
+export const refineValidator = <T>(
+  base: Validator<T>,
+  predicate: (value: T) => boolean,
+  name: string | null = null
+): Validator<T> => {
+  const refinedValidator = (value: unknown): value is T => base(value) && predicate(value as T);
+  Object.defineProperty(refinedValidator, 'name', {
+    value: isString(name) ? name : `${base.name}Refined`,
+  });
+  return refinedValidator;
+};
+
+/**
+ * Logical OR of two validators.
+ */
+export const isAnyOf =
+  <A, B>(a: Validator<A>, b: Validator<B>): Validator<A | B> =>
+  (value: unknown): value is A | B =>
+    a(value) || b(value);
+
+export const isNumberGreater = (min: number): Validator<number> =>
+  refineValidator(isNumber, (value) => isGreater(value, min));
+
+export const isNumberGreaterOrEqual = (min: number): Validator<number> =>
+  refineValidator(isNumber, (value) => isGreaterOrEqual(value, min));
+
+export const isNumberLess = (min: number): Validator<number> =>
+  refineValidator(isNumber, (value) => isLess(value, min));
+
+export const isNumberLessOrEqual = (min: number): Validator<number> =>
+  refineValidator(isNumber, (value) => isLessOrEqual(value, min));
+
+export const isNumberInRange = (min: number, max: number): Validator<number> =>
+  refineValidator(isNumber, (value) => isInRange(value, min, max));
+
+export const isNumberEqual = (expected: number): Validator<number> =>
+  refineValidator(isNumber, (value) => isEqual(value, expected));
+
+export const isIntegerGreater = (min: number): Validator<number> =>
+  refineValidator(isInteger, (value) => isGreater(value, min));
+
+export const isIntegerGreaterOrEqual = (min: number): Validator<number> =>
+  refineValidator(isInteger, (value) => isGreaterOrEqual(value, min));
+
+export const isIntegerLess = (min: number): Validator<number> =>
+  refineValidator(isInteger, (value) => isLess(value, min));
+
+export const isIntegerLessOrEqual = (min: number): Validator<number> =>
+  refineValidator(isInteger, (value) => isLessOrEqual(value, min));
+
+export const isIntegerInRange = (min: number, max: number): Validator<number> =>
+  refineValidator(isInteger, (value) => isInRange(value, min, max));
+
+export const isIntegerEqual = (expected: number): Validator<number> =>
+  refineValidator(isInteger, (value) => isEqual(value, expected));
+
+export const isStringLengthGreater = (min: number): Validator<string> =>
+  refineValidator(isString, (value) => isGreater(value.length, min));
+
+export const isStringLengthGreaterOrEqual = (min: number): Validator<string> =>
+  refineValidator(isString, (value) => isGreaterOrEqual(value.length, min));
+
+export const isStringLengthLess = (min: number): Validator<string> =>
+  refineValidator(isString, (value) => isLess(value.length, min));
+
+export const isStringLengthLessOrEqual = (min: number): Validator<string> =>
+  refineValidator(isString, (value) => isLessOrEqual(value.length, min));
+
+export const isStringLengthInRange = (min: number, max: number): Validator<string> =>
+  refineValidator(isString, (value) => isInRange(value.length, min, max));
+
+export const isStringLengthEqual = (expected: number): Validator<string> =>
+  refineValidator(isString, (value) => isEqual(value.length, expected));
+
+export const isArrayLengthGreater = (min: number): Validator<unknown[]> =>
+  refineValidator(isArray, (value) => isGreater(value.length, min));
+
+export const isArrayLengthGreaterOrEqual = (min: number): Validator<unknown[]> =>
+  refineValidator(isArray, (value) => isGreaterOrEqual(value.length, min));
+
+export const isArrayLengthLess = (min: number): Validator<unknown[]> =>
+  refineValidator(isArray, (value) => isLess(value.length, min));
+
+export const isArrayLengthLessOrEqual = (min: number): Validator<unknown[]> =>
+  refineValidator(isArray, (value) => isLessOrEqual(value.length, min));
+
+export const isArrayLengthInRange = (min: number, max: number): Validator<unknown[]> =>
+  refineValidator(isArray, (value) => isInRange(value.length, min, max));
+
+export const isArrayLengthEqual = (expected: number): Validator<unknown[]> =>
+  refineValidator(isArray, (value) => isEqual(value.length, expected));

package/.vscode/extensions.json

@@ -1,6 +0,0 @@
-{
-	"recommendations": [
-		"oxc.oxc-vscode",
-		"vitest.explorer"
-	]
-}

package/.vscode/settings.json

@@ -1,27 +0,0 @@
-{
-  "files.watcherExclude": {
-    "**/.git/objects/**": true,
-    "**/.git/subtree-cache/**": true,
-    "**/build/**": true,
-    "**/node_modules/**": true
-  },
-  "editor.codeActionsOnSave": {
-    "source.removeUnusedImports": "explicit",
-    "source.organizeImports": "explicit"
-  },
-  "oxc.enable": true,
-  "[javascript]": {
-    "editor.defaultFormatter": "oxc.oxc-vscode"
-  },
-  "[javascriptreact]": {
-    "editor.defaultFormatter": "oxc.oxc-vscode"
-  },
-  "javascript.updateImportsOnFileMove.enabled": "always",
-  "[typescript]": {
-    "editor.defaultFormatter": "oxc.oxc-vscode",
-  },
-  "[typescriptreact]": {
-    "editor.defaultFormatter": "oxc.oxc-vscode"
-  },
-  "typescript.updateImportsOnFileMove.enabled": "always",
-}

package/src/logging/AbstractLogHandler.js

@@ -1,23 +0,0 @@
-export class AbstractLogHandler {
-  /**
-   * Abstract log handler.
-   * @param {number} level - Log handler level.
-   */
-  constructor(level) {
-    this.level = level;
-  }
-
-  /**
-   * Emit log record.
-   * @param {import('./Logger.js').Logger} logger - Logger instance.
-   * @param {number} timestamp - Log timestamp.
-   * @param {number} level - Log level.
-   * @param {string} message - Log message.
-   * @param {object | null | undefined} extra - Log extra data.
-   * @param {Error | null | undefined} error - Log error.
-   * @throws {Error}
-   */
-  emit(logger, timestamp, level, message, extra, error) {
-    throw new Error('Not implemented.');
-  }
-}