{"version":3,"file":"typescript-package-descriptor.mjs","sources":["../../../package/descriptor/src/lib/common-descriptor.abstract.ts","../../../package/descriptor/src/lib/accessor-descriptor.class.ts","../../../package/descriptor/src/lib/data-descriptor.class.ts","../../../package/descriptor/src/lib/descriptor.class.ts","../../../package/descriptor/src/lib/index.ts","../../../package/descriptor/src/public-api.ts","../../../package/descriptor/src/typescript-package-descriptor.ts"],"sourcesContent":["// Interface.\nimport { CommonPropertyDescriptor } from \"@typedly/descriptor\";\n /**\n * @description The common properties for descriptors.\n * @export\n * @abstract\n * @class CommonDescriptor\n * @template {boolean} [C=boolean] The type of configurable property.\n * @template {boolean} [E=boolean] The type of enumerable property.\n * @implements {Pick<PropertyDescriptor, 'configurable' | 'enumerable'>}\n */\nexport abstract class CommonDescriptor<\n  // Configurable.\n  C extends boolean = boolean,\n  // Enumerable.\n  E extends boolean = boolean\n> implements Pick<PropertyDescriptor, 'configurable' | 'enumerable'> {\n  /**\n   * @description The default value for configurable.\n   * @public\n   * @static\n   * @type {?boolean}\n   */\n  public static configurable?: boolean;\n\n  // \n  /**\n   * @description The default value for enumerable.\n   * @public\n   * @static\n   * @type {?boolean}\n   */\n  public static enumerable?: boolean;\n\n  //#region Property descriptor\n  /**\n   * @description The configurable property.\n   * @public\n   * @type {?C}\n   */\n  public configurable?: C;\n\n  /**\n   * @description The enumerable property.\n   * @public\n   * @type {?E}\n   */\n  public enumerable?: E;\n  //#endregion\n\n  /**\n   * Creates an instance of `CommonDescriptor` child class.\n   * @constructor\n   * @param {CommonPropertyDescriptor<C, E>} [param0={}] Object containing configurable and enumerable properties.\n   * @param {CommonPropertyDescriptor<C, E>} param0.configurable The configurable property. Defaults to static configurable value.\n   * @param {CommonPropertyDescriptor<C, E>} param0.enumerable The enumerable property. Defaults to static enumerable value.\n   */\n  constructor(\n    { configurable, enumerable }: CommonPropertyDescriptor<C, E>  = {},\n  ) {\n    delete this.configurable, delete this.enumerable;\n\n    typeof configurable === 'boolean'\n    ? (this.configurable = configurable)\n    : typeof CommonDescriptor.configurable === 'boolean' && (this.configurable = CommonDescriptor.configurable as C);\n\n    typeof enumerable === 'boolean'\n    ? (this.enumerable = enumerable)\n    : typeof CommonDescriptor.enumerable === 'boolean' && (this.enumerable = CommonDescriptor.enumerable as E);\n  }\n}\n","// Abstract,\nimport { CommonDescriptor } from './common-descriptor.abstract';\n// Interface.\nimport { ThisAccessorPropertyDescriptor } from '@typedly/descriptor';\n// Type.\nimport { ValidationCallback } from '@typedly/callback';\n/**\n * @description The `AccessorDescriptor` class is a concrete implementation of the `CommonDescriptor` class that represents an accessor property descriptor.\n * @export\n * @class AccessorDescriptor\n * @template [O=any] The type of the object.\n * @template {PropertyKey | keyof O} [K=keyof O] The type of property key.\n * @template {K extends keyof O ? O[K] : any} [V=K extends keyof O ? O[K] : any] The type of value captured from the object.\n * @template {boolean} [C=boolean] The type of the configurable property.\n * @template {boolean} [E=boolean] The type of the enumerable property.\n * @extends {CommonDescriptor<C, E>} Common descriptor properties.\n */\nexport class AccessorDescriptor<\n  // Object. `any` for proper type capturing by `V`.\n  O = any,\n  // Key.\n  K extends PropertyKey | keyof O = keyof O,\n  // Value.\n  V extends K extends keyof O ? O[K] : any = K extends keyof O ? O[K] : any,\n  // Configurable.\n  C extends boolean = boolean,\n  // Enumerable.\n  E extends boolean = boolean\n> extends CommonDescriptor<C, E> implements ThisAccessorPropertyDescriptor<V, O, C, E> {\n  /**\n   * @description Creates an instance of `AccessorDescriptor`.\n   * @public\n   * @static\n   * @template [O=any] The type of the object.\n   * @template {PropertyKey | keyof O} [K=keyof O] The type of property key.\n   * @template {K extends keyof O ? O[K] : any} [V=K extends keyof O ? O[K] : any] The type of value captured from the object.\n   * @template {boolean} [C=boolean] The type of the configurable property.\n   * @template {boolean} [E=boolean] The type of the enumerable property.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0 Accessor descriptor properties.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.configurable The type of configurable of `C`.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.enumerable The type of enumerable of `E`.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.get The type of the getter function.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.set The type of the setter function.\n   * @param {?O} [object] The object (non-stored) to define the descriptor on and capture the `this` context.\n   * @param {?K} [key] The (non-stored) key to define the descriptor on.\n   * @param {?ValidationCallback<ThisAccessorPropertyDescriptor<V, O, C, E>>} [onValidate] \n   * @returns {AccessorDescriptor<O, K, V, C, E>} \n   */\n  public static create<\n    O = any,\n    K extends PropertyKey | keyof O = keyof O,\n    V extends K extends keyof O ? O[K] : any = K extends keyof O ? O[K] : any,\n    C extends boolean = boolean,\n    E extends boolean = boolean\n  >(\n    { configurable, enumerable, get, set }: ThisAccessorPropertyDescriptor<V, O, C, E>,\n    object?: O,\n    key?: K,\n    onValidate?: ValidationCallback<ThisAccessorPropertyDescriptor<V, O, C, E>>\n  ): AccessorDescriptor<O, K, V, C, E> {\n    return new AccessorDescriptor(\n      { configurable, enumerable, get, set },\n      object,\n      key,\n      onValidate\n    );\n  }\n\n  /**\n   * @description Returns strictly defined accessor descriptor of a `ThisAccessorPropertyDescriptor<V, O, C, E>` type on `get` or `set` property detected.\n   * @public\n   * @static\n   * @template [O=any] The type of the object.\n   * @template {PropertyKey | keyof O} [K=keyof O] The type of the object key.\n   * @template {K extends keyof O ? O[K] : any} [V=K extends keyof O ? O[K] : any] The type of the object value.\n   * @template {boolean} [C=boolean] The type of the configurable property.\n   * @template {boolean} [E=boolean] The type of the enumerable property.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0 The accessor descriptor attributes.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.configurable The configurable of `C` type.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.enumerable The configurable of `E` type.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.get The getter.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.set The setter.\n   * @param {?O} [object] The object (non-stored) to define the descriptor on and capture the `this` context.\n   * @param {?K} [key] The (non-stored) key to define the descriptor on and capture the type of value.\n   * @param {?ValidationCallback<ThisAccessorPropertyDescriptor<V, O, C, E>>} [onValidate] A `ValidationCallback` function to handle the result of the check whether the `descriptor` is an `object` with `get` or `set` property.\n   * @returns {(ThisAccessorPropertyDescriptor<V, O, C, E> | undefined)} The returned value is an `object` of a `ThisAccessorPropertyDescriptor<V, O, C, E>` type.\n   */\n  public static define<\n    O = any,\n    K extends PropertyKey | keyof O = keyof O,\n    V extends K extends keyof O ? O[K] : any = K extends keyof O ? O[K] : any,\n    C extends boolean = boolean,\n    E extends boolean = boolean\n  >(\n    { configurable, enumerable, get, set }: ThisAccessorPropertyDescriptor<V, O, C, E>,\n    object?: O,\n    key?: K,\n    onValidate?: ValidationCallback<ThisAccessorPropertyDescriptor<V, O, C, E>>\n  ): ThisAccessorPropertyDescriptor<V, O, C, E> | undefined {\n    return this.guard({ configurable, enumerable, get, set }, onValidate)\n      ? {\n        ...(configurable || AccessorDescriptor.configurable as C) &&  { configurable: configurable || AccessorDescriptor.configurable as C },\n        ...(enumerable || AccessorDescriptor.enumerable as E) && { enumerable: enumerable || AccessorDescriptor.enumerable as E },\n        ...set && { set },\n        ...get && { get },\n      }\n      : undefined;\n  }\n\n  /**\n   * @description Guards the `descriptor` to be an `object` of a `ThisAccessorPropertyDescriptor<V, O, C, E>` type.\n   * @public\n   * @static\n   * @template V The type of the value.\n   * @template O The type of the object.\n   * @template {boolean} [C=boolean] The type of the configurable.\n   * @template {boolean} [E=boolean] The type of the enumerable.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} descriptor The object of a `ThisAccessorPropertyDescriptor<V, O, C, E>` type to guard.\n   * @param {?ValidationCallback<ThisAccessorPropertyDescriptor<V, O, C, E>>} [callbackFn] A `ValidationCallback` function to handle the result of the check whether or not the descriptor is an `object` containing the `get` or `set` property.\n   * @returns {descriptor is ThisAccessorPropertyDescriptor<V, O, C, E>} The return value is a boolean indicating whether the `descriptor` is an `object` with the `get` or `set` property.\n   */\n  public static guard<\n    V,\n    O,\n    C extends boolean = boolean,\n    E extends boolean = boolean\n  >(\n    descriptor: ThisAccessorPropertyDescriptor<V, O, C, E>,\n    callbackFn?: ValidationCallback<ThisAccessorPropertyDescriptor<V, O, C, E>>\n  ): descriptor is ThisAccessorPropertyDescriptor<V, O, C, E> {\n    const result = typeof descriptor === 'object'\n      && (\n        ('get' in descriptor && typeof descriptor.get === 'function')\n        ||\n        ('set' in descriptor && typeof descriptor.set === 'function')\n      )\n      && !('value' in descriptor || 'writable' in descriptor);\n    return callbackFn?.(result, descriptor) || result;\n  }\n\n  //#region Accessor descriptor.\n  /**\n   * @description The getter function.\n   * @public\n   * @type {?() => V}\n   */\n  public get?: () => V;\n\n  /**\n   * @description The setter function.\n   * @public\n   * @type {?(value: V) => void}\n   */\n  public set?: (value: V) => void;\n  //#endregion\n\n  /**\n   * Creates an instance of `AccessorDescriptor`.\n   * @constructor\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0 The properties of the accessor descriptor.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.configurable The configurable of generic type variable `C`.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.enumerable The enumerable of generic type variable `E`.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.get The getter function.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.set The setter function.\n   * @param {?O} [object] The object (non-stored) to define the descriptor on.\n   * @param {?K} [key] The (non-stored) key to define the descriptor on.\n   * @param {?ValidationCallback<ThisAccessorPropertyDescriptor<V, O, C, E>>} [onValidate] \n   */\n  constructor(\n    { configurable, enumerable, get, set }: ThisAccessorPropertyDescriptor<V, O, C, E>,\n    object?: O,\n    key?: K,\n    onValidate?: ValidationCallback<ThisAccessorPropertyDescriptor<V, O, C, E>>\n  ) {\n    onValidate && AccessorDescriptor.guard({ configurable, enumerable, get, set }, onValidate);\n    super({ configurable, enumerable });\n    delete this.get, delete this.set;\n    'get' in arguments[0] && (this.get = get);\n    'set' in arguments[0] && (this.set = set);\n  }\n}\n","// Abstract.\nimport { CommonDescriptor } from './common-descriptor.abstract';\n// Interface.\nimport { DataPropertyDescriptor } from '@typedly/descriptor';\n// Type.\nimport { ValidationCallback } from '@typedly/callback';\n/**\n * @description The `DataDescriptor` class is a concrete implementation of the `CommonDescriptor` class that represents a data property descriptor.\n * @export\n * @class DataDescriptor\n * @template [O=any] The type of the object.\n * @template {PropertyKey | keyof O} [K=keyof O] The type of property key.\n * @template [V=K extends keyof O ? O[K] : any] The type of value captured from the object.\n * @template {boolean} [C=boolean] The type of the configurable property.\n * @template {boolean} [E=boolean] The type of the enumerable property.\n * @template {boolean} [W=boolean] The type of the writable property.\n * @extends {CommonDescriptor<C, E>}\n */\nexport class DataDescriptor<\n  // Object.\n  O = any,\n  // Key.\n  K extends PropertyKey | keyof O = keyof O,\n  // Value.\n  V = K extends keyof O ? O[K] : any,\n  // Configurable.\n  C extends boolean = boolean,\n  // Enumerable.\n  E extends boolean = boolean,\n  // Writable.\n  W extends boolean = boolean\n> extends CommonDescriptor<C, E>\n  implements DataPropertyDescriptor<V, C, E, W> {\n  /**\n   * @description Creates an instance of `DataDescriptor`.\n   * @public\n   * @static\n   * @template [O=any] The type of the object.\n   * @template {PropertyKey | keyof O} [K=keyof O] The type of the property key. \n   * @template [V=K extends keyof O ? O[K] : any] The type of the value captured from the object.\n   * @template {boolean} [C=boolean] The type of configurable.\n   * @template {boolean} [E=boolean] The type of enumerable.\n   * @template {boolean} [W=boolean] The type of writable.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0 Data descriptor properties.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.configurable The configurable property.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.enumerable The enumerable property.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.value The value for data descriptor.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.writable The writable property.\n   * @param {?O} [object] The object (non-stored) to define the descriptor on. The object is optional, if not provided the descriptor will be created without an object.\n   * @param {?K} [key] The property key to define the descriptor on. The key is optional, if not provided the descriptor will be created without a key.\n   * @param {?ValidationCallback<DataPropertyDescriptor<V, C, E, W>>} [onValidate] An optional validation callback to validate the descriptor.\n   * @returns {(DataDescriptor<O, K, V, C, E, W> | undefined)} The returned \n   */\n  public static create<\n    O = any,\n    K extends PropertyKey | keyof O = keyof O,\n    V = K extends keyof O ? O[K] : any,\n    C extends boolean = boolean,\n    E extends boolean = boolean,\n    W extends boolean = boolean\n  >(\n    { configurable, enumerable, value, writable }: DataPropertyDescriptor<V, C, E, W>,\n    object?: O,\n    key?: K,\n    onValidate?: ValidationCallback<DataPropertyDescriptor<V, C, E, W>>\n  ): DataDescriptor<O, K, V, C, E, W> | undefined {\n    return new DataDescriptor(\n      { configurable, enumerable, value, writable },\n      object,\n      key,\n      onValidate\n    );\n  }\n\n  /**\n   * @description Returns strictly defined data descriptor of a `DataPropertyDescriptor<V, C, E, W>` interface on `writable` or `value` property detected.\n   * @public\n   * @static\n   * @template [O=any] The type of the object.\n   * @template {PropertyKey | keyof O} [K=keyof O] The type of the object key.\n   * @template [V=K extends keyof O ? O[K] : any] The type of value.\n   * @template {boolean} [C=boolean] The type of configurable.\n   * @template {boolean} [E=boolean] The type of enumerable.\n   * @template {boolean} [W=boolean] The type of writable.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0 An `object` of a `DataPropertyDescriptor<V, C, E, W>` interface, to set with the default values of the `CommonDescriptor`.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.configurable The descriptor configurable.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.enumerable The descriptor enumerable.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.value The descriptor value.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.writable The descriptor writable.\n   * @param {?O} [object] The object (non-stored) to define the descriptor on. The object is optional, if not provided the descriptor will be created without an object.\n   * @param {?K} [key] The (non-stored) key to define the descriptor on.\n   * @param {?ValidationCallback<DataPropertyDescriptor<V, C, E, W>>} [onValidate] An optional `ResultCallback` function to handle the result of the check whether or not the `descriptor` is an `object` with the `writable` or `value` property, by default it uses `dataCallback()` function from the static `guard()` method.\n   * @returns {(DataPropertyDescriptor<V, C, E, W> | undefined)} The return value is an `object` of a `DataPropertyDescriptor<V, C, E, W>` interface.\n   */\n  public static define<\n    O = any,\n    K extends PropertyKey | keyof O = keyof O,\n    V = K extends keyof O ? O[K] : any,\n    C extends boolean = boolean,\n    E extends boolean = boolean,\n    W extends boolean = boolean\n  >(\n    { configurable, enumerable, value, writable }: DataPropertyDescriptor<V, C, E, W>,\n    object?: O,\n    key?: K,\n    onValidate?: ValidationCallback<DataPropertyDescriptor<V, C, E, W>>\n  ): DataPropertyDescriptor<V, C, E, W> | undefined {\n    return this.guard({ configurable, enumerable, value, writable }, onValidate)\n      ? {\n        ...{\n          configurable: CommonDescriptor.configurable,\n          enumerable: DataDescriptor.enumerable,\n          writable: DataDescriptor.writable,  \n        },\n        ...{ configurable, enumerable, value, writable }\n      }\n      : undefined;\n  }\n\n  /**\n   * @description Guards the `descriptor` to be an `object` of a `DataPropertyDescriptor<Value>` interface.\n   * @public\n   * @static\n   * @template V The type of the value.\n   * @template {boolean} [C=boolean] The type of configurable.\n   * @template {boolean} [E=boolean] The type of enumerable.\n   * @template {boolean} [W=boolean] The type of writable.\n   * @param {DataPropertyDescriptor<V, C, E, W>} descriptor Object of a `DataPropertyDescriptor<Value>` interface to guard.\n   * @param {?ValidationCallback<DataPropertyDescriptor<V, C, E, W>>} [callbackFn] A `ResultCallback` function to handle the result of the check whether or not the `descriptor` is an `object` with the `writable` or `value` property, by default it uses `dataCallback()` function.\n   * @returns {descriptor is DataPropertyDescriptor<V, C, E, W>} The return value is a `boolean` indicating whether the `descriptor` is an `object` with the `writable` or `value` property.\n   */\n  public static guard<\n    V,\n    C extends boolean = boolean,\n    E extends boolean = boolean,\n    W extends boolean = boolean\n  >(\n    descriptor: DataPropertyDescriptor<V, C, E, W>,\n    callbackFn?: ValidationCallback<DataPropertyDescriptor<V, C, E, W>>\n  ): descriptor is DataPropertyDescriptor<V, C, E, W> {\n    return typeof callbackFn === 'function'\n      ? callbackFn(\n        typeof descriptor === 'object'\n        && 'value' in descriptor\n        && !('get' in descriptor || 'set' in descriptor), descriptor)\n      : false;\n  }\n\n  /**\n   * @description Defaults to writable.\n   * @public\n   * @static\n   * @type {?boolean}\n   */\n  public static writable?: boolean;\n\n  /**\n   * @description The value of the descriptor.\n   * @public\n   * @type {?V}\n   */\n  public value?: V;\n\n  /**\n   * @description The writable of the descriptor.\n   * @public\n   * @type {?W}\n   */\n  public writable?: W;\n\n  /**\n   * Creates an instance of `DataDescriptor`.\n   * @constructor\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0 Data descriptor properties.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.configurable The configurable of the descriptor.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.enumerable Enumerable of the descriptor.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.value The value for data descriptor.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.writable The writable for data descriptor.\n   * @param {?O} [object] The object (non-stored) to define the descriptor on. The object is optional, if not provided the descriptor will be created without an object.\n   * @param {?K} [key] The (non-stored) key to define the descriptor on.\n   * @param {?ValidationCallback<DataPropertyDescriptor<V, C, E, W>>} [onValidate] Optional callback function to determine the validity of the descriptor.\n   */\n  constructor(\n    { configurable, enumerable, value, writable }: DataPropertyDescriptor<V, C, E, W>,\n    object?: O,\n    key?: K,\n    onValidate?: ValidationCallback<DataPropertyDescriptor<V, C, E, W>>\n  ) {\n    onValidate && DataDescriptor.guard({ configurable, enumerable, value, writable }, onValidate);\n    super({ configurable, enumerable });\n    delete this.writable;\n    'writable' in arguments[0] && (this.writable = writable);\n    this.value = value;\n  }\n}\n","// Abstract.\nimport { CommonDescriptor } from './common-descriptor.abstract';\n// Class.\nimport { AccessorDescriptor } from './accessor-descriptor.class';\nimport { DataDescriptor } from './data-descriptor.class';\n// Interface.\nimport { DataPropertyDescriptor } from '@typedly/descriptor';\n// Type.\nimport { ObjectPropertyDescriptors, StrictPropertyDescriptor } from '@typedly/descriptor';\nimport { ThisAccessorPropertyDescriptor } from '@typedly/descriptor';\nimport { ValidationCallback } from '@typedly/callback';\n/**\n * @description The `Descriptor` class is a concrete implementation of the `CommonDescriptor` class that represents a property descriptor.\n * @export\n * @class Descriptor\n * @template [O=any] The type of the object.\n * @template {PropertyKey | keyof O} [K=keyof O] The type of the key.\n * @template {K extends keyof O ? O[K] : any} [V=K extends keyof O ? O[K] : any] The type of the value.\n * @template {boolean} [C=boolean] The type of the configurable flag.\n * @template {boolean} [E=boolean] The type of the enumerable flag.\n * @template {boolean} [W=boolean] The type of the writable flag.\n * @extends {CommonDescriptor<C, E>}\n */\nexport class Descriptor<\n  // Object. `any` for proper type capturing by `V`.\n  O = any,\n  // Key.\n  K extends PropertyKey | keyof O = keyof O,\n  // Value.\n  V extends K extends keyof O ? O[K] : any = K extends keyof O ? O[K] : any,\n  // Configurable.\n  C extends boolean = boolean,\n  // Enumerable.\n  E extends boolean = boolean,\n  // Writable.\n  W extends boolean = boolean\n> extends CommonDescriptor<C, E> {\n  /**\n   * @description Creates an instance of `Descriptor`.\n   * @public\n   * @static\n   * @template [O=any] The type of the object.\n   * @template {PropertyKey | keyof O} [K=keyof O] The type of the key.\n   * @template {K extends keyof O ? O[K] : any} [V=K extends keyof O ? O[K] : any] The type of the value.\n   * @template {boolean} [C=boolean] The type of the configurable flag.\n   * @template {boolean} [E=boolean] The type of the enumerable flag.\n   * @template {boolean} [W=boolean] The type of the writable flag.\n   * @param {StrictPropertyDescriptor<V, O, C, E>} [attributes={}] The type of the descriptor.\n   * @param {?O} [object] The object (non-stored) to define the descriptor on. The object is optional, if not provided the descriptor will be created without an object.\n   * @param {?K} [key] The key (non-stored) to define the descriptor on. The key is optional, if not provided the descriptor will be created without a key.\n   * @returns {Descriptor<O, K, V, C, E, W>} \n   */\n  public static create<\n    O = any,\n    K extends PropertyKey | keyof O = keyof O,\n    V extends K extends keyof O ? O[K] : any = K extends keyof O ? O[K] : any,\n    C extends boolean = boolean,\n    E extends boolean = boolean,\n    W extends boolean = boolean\n  >(\n    attributes: StrictPropertyDescriptor<V, O, C, E, W> = {},\n    object?: O,\n    key?: K,\n  ): Descriptor<O, K, V, C, E, W> {\n    return new Descriptor<O, K, V, C, E, W>(\n      attributes,\n      object,\n      key\n    );    \n  }\n  \n  /**\n   * @description Creates an instance of `Descriptor`.\n   * @public\n   * @static\n   * @template [O=any] The type of the object.\n   * @template {PropertyKey | keyof O} [K=keyof O] The type of the key.\n   * @template {K extends keyof O ? O[K] : any} [V=K extends keyof O ? O[K] : any] The type of the value.\n   * @template {boolean} [C=boolean] The type of the configurable.\n   * @template {boolean} [E=boolean] The type of the enumerable.\n   * @template {boolean} [W=boolean] The type of the writable.\n   * @param {StrictPropertyDescriptor<V, O, C, E, W>} [attributes={}] Data descriptor properties.\n   * @param {StrictPropertyDescriptor<V, O, C, E, W>} attributes.configurable The configurable property.\n   * @param {StrictPropertyDescriptor<V, O, C, E, W>} attributes.enumerable The enumerable property.\n   * @param {StrictPropertyDescriptor<V, O, C, E, W>} attributes.value The value for data descriptor.\n   * @param {StrictPropertyDescriptor<V, O, C, E, W>} attributes.writable The writable property.\n   * @param {?O} [object] The object (non-stored) to define the descriptor on.\n   * @param {?K} [key] The key (non-stored) to define the descriptor on.\n   * @returns {StrictPropertyDescriptor<V, O, C, E, W>} \n   */\n  public static define<\n    O = any,\n    K extends PropertyKey | keyof O = keyof O,\n    V extends K extends keyof O ? O[K] : any = K extends keyof O ? O[K] : any,\n    C extends boolean = boolean,\n    E extends boolean = boolean,\n    W extends boolean = boolean\n  >(\n    attributes: StrictPropertyDescriptor<V, O, C, E, W> = {},\n    object?: O,\n    key?: K,\n  ): StrictPropertyDescriptor<V, O, C, E, W> {\n    return {\n      ...this.create<O, K, V, C, E, W>(\n        attributes,\n        object,\n        key,\n      )\n    } as StrictPropertyDescriptor<V, O, C, E, W>;\n  }\n\n  /**\n   * @description Returns accessor descriptor of a `ThisAccessorPropertyDescriptor<V, O, C, E>` type, on `get` or `set` property detected.\n   * @public\n   * @static\n   * @template [O=any] The type of the object.\n   * @template {PropertyKey | keyof O} [K=keyof O] The type of the object key.\n   * @template {K extends keyof O ? O[K] : any} [V=K extends keyof O ? O[K] : any] The type of the value.\n   * @template {boolean} [C=boolean] The type of configurable.\n   * @template {boolean} [E=boolean] The type of enumerable.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0 The accessor descriptor attributes.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.configurable The configurable property.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.enumerable The enumerable property.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.get The getter function.\n   * @param {ThisAccessorPropertyDescriptor<V, O, C, E>} param0.set The setter function.\n   * @param {?O} [object] The object (non-stored) to define the descriptor on.\n   * @param {?K} [key] The key (non-stored) to define the descriptor on.\n   * @param {?ValidationCallback<ThisAccessorPropertyDescriptor<V, O, C, E>>} [onValidate] \n   * @returns {(ThisAccessorPropertyDescriptor<V, O, C, E> | undefined)} \n   */\n  public static defineAccessor<\n    O = any,\n    K extends PropertyKey | keyof O = keyof O,\n    V extends K extends keyof O ? O[K] : any = K extends keyof O ? O[K] : any, \n    C extends boolean = boolean,\n    E extends boolean = boolean\n  >(\n    {configurable, enumerable, get, set}: ThisAccessorPropertyDescriptor<V, O, C, E>,\n    object?: O,\n    key?: K,\n    onValidate?: ValidationCallback<ThisAccessorPropertyDescriptor<V, O, C, E>>\n  ): ThisAccessorPropertyDescriptor<V, O, C, E> | undefined {\n    return AccessorDescriptor.define<O, K, V, C, E>({ configurable, enumerable, get, set }, object, key, onValidate);\n  }\n\n  /**\n   * @description Returns data descriptor of a `DataPropertyDescriptor<Value>` interface, on `writable` or `value` property detected.\n   * @public\n   * @static\n   * @template [O=any] The type of the object.\n   * @template {PropertyKey | keyof O} [K=keyof O] The type of the object key.\n   * @template [V=K extends keyof O ? O[K] : any] The type of the value.\n   * @template {boolean} [C=boolean] The type of configurable.\n   * @template {boolean} [E=boolean] The type of enumerable.\n   * @template {boolean} [W=boolean] The type of writable.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0 An `object` of a `DataPropertyDescriptor<Value>` interface, to set with the default values of the `CommonDescriptor`.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.configurable The configurable property.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.enumerable The enumerable property.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.value The value property.\n   * @param {DataPropertyDescriptor<V, C, E, W>} param0.writable The writable property.\n   * @param {?O} [object] The object (non-stored) to define the descriptor on.\n   * @param {?K} [key] The key (non-stored) to define the descriptor on.\n   * @param {?ValidationCallback<DataPropertyDescriptor<V, C, E, W>>} [onValidate] An optional `ValidationCallback` function to handle the result of the check whether or not the `descriptor` is an `object` with the `writable` or `value` property.\n   * @returns {(DataPropertyDescriptor<V, C, E, W> | undefined)} \n   */\n  public static defineData<\n    O = any,\n    K extends PropertyKey | keyof O = keyof O,\n    V = K extends keyof O ? O[K] : any,\n    C extends boolean = boolean,\n    E extends boolean = boolean,\n    W extends boolean = boolean\n  >(\n    {configurable, enumerable, value, writable}: DataPropertyDescriptor<V, C, E, W>,\n    object?: O,\n    key?: K,\n    onValidate?: ValidationCallback<DataPropertyDescriptor<V, C, E, W>>\n  ): DataPropertyDescriptor<V, C, E, W> | undefined {\n    return DataDescriptor.define<O, K, V, C, E, W>({configurable, enumerable, writable, value}, object, key, onValidate);\n  }\n\n  /**\n   * @description Returns property descriptors from the specified object and its prototype.\n   * @public\n   * @static\n   * @template O The type of the object.\n   * @param {O} object An `object` of a generic `Obj` type to get property descriptors.\n   * @returns {(ObjectPropertyDescriptors<O> | undefined)} The return value is an `object` of a `ObjectPropertyDescriptors<O> | undefined` type.\n   */\n  public static fromObject<O>(\n    object: O\n  ): ObjectPropertyDescriptors<O> | undefined {\n    return {\n      ...Object.getOwnPropertyDescriptors(Object.getPrototypeOf(object)) || {}, // ['__proto__'] equivalent to getPrototypeOf()\n      ...Object.getOwnPropertyDescriptors(object) || {},\n    } as any;\n  }\n\n  /**\n   * @description Returns property descriptor from the `object` or `class` prototype.\n   * Wrapper function for the `getOwnPropertyDescriptor`, which \"Gets the own property descriptor of the specified object.\"\n   * @param object An `object` of a generic `Obj` type or a class to get own property descriptor with the specified `key`.\n   * If `class` is provided then it uses its prototype to get the property descriptor.\n   * @param key A `keyof Obj` value to get property descriptor from the `object`.\n   * @returns The return value is an `object` of a `PropertyDescriptor` interface or an `undefined`.\n   * @example\n   * // Useful here.\n   * class A {\n   *  get foo() { return \"foo\"; }\n   * }\n   * const a = new A();\n   * Descriptor.fromProperty(a, 'foo'); // {set: undefined, enumerable: false, configurable: true, get: ƒ}\n   */\n  public static fromProperty<O, K extends keyof O>(\n    object: O,\n    key: K,\n  ): PropertyDescriptor | undefined {\n    return (\n      Object.getOwnPropertyDescriptor(object, key) ||\n      Object.getOwnPropertyDescriptor(Object.getPrototypeOf(object), key)\n    );\n  }\n\n  /**\n   * @alias fromProperty()\n   */\n  public static get<O, K extends keyof O>(object: O, key: K): PropertyDescriptor | undefined {\n    return this.fromProperty(object, key);\n  }\n\n  /**\n   * @alias fromObject()\n   */\n  public static getAll<O>(object: O): ObjectPropertyDescriptors<O> | undefined {\n    return this.fromObject(object);\n  }\n\n  /**\n   * @description Picks the descriptors of the specified keys from the `object`.\n   * @public\n   * @static\n   * @template O The type of object.\n   * @template {keyof O} K The type of object key.\n   * @param {O} object The object to pick the descriptors from.\n   * @param {...K[]} keys The keys of the descriptors to pick.\n   * @returns {Pick<ObjectPropertyDescriptors<O>, K>} The picked descriptors.\n   */\n  public static pick<O, K extends keyof O>(\n    object: O,\n    ...keys: K[]\n  ): Pick<ObjectPropertyDescriptors<O>, K> {\n    // Prepare constant to assign descriptors of picked keys.\n    const result: Pick<ObjectPropertyDescriptors<O>, K> = {} as any;\n\n    // Get all descriptors.\n    const descriptors = this.getAll(object);\n\n    // If descriptors exists then set picked descriptor into the map storage.\n    typeof descriptors === 'object' &&\n      Object.keys(descriptors)\n        .filter(key => keys.includes(key as any))\n        .forEach(key =>\n          Object.assign(result, {\n            [key]: descriptors[key],\n          })\n        );\n    return result;\n  }\n\n  /**\n   * The static getter accessor to get descriptors from property or object.\n   * @returns The returned value is an `object` with `object` and `property` properties.\n   */\n  public static get from(): {\n    object: <O>(\n      object: O\n    ) => ObjectPropertyDescriptors<O> | undefined,\n    property: <O, K extends keyof O>(\n      object: O,\n      key: K\n    ) => PropertyDescriptor | undefined,\n  } {\n    return {\n      object: this.fromObject,\n      property: this.fromProperty,\n    }\n  }\n\n  //#region Property descriptor\n  /**\n   * @description The configurable property.\n   * @public\n   * @type {?() => V}\n   */\n  public get?: () => V;\n\n  /**\n   * @description\n   * @public\n   * @type {?(value: V) => void}\n   */\n  public set?: (value: V) => void;\n\n  /**\n   * @description The value property.\n   * @public\n   * @type {?V}\n   */\n  public value?: V;\n\n  /**\n   * @description The writable property.\n   * @public\n   * @type {?W}\n   */\n  public writable?: W;\n  //#endregion\n\n  /**\n   * Creates an instance of `Descriptor`.\n   * @constructor\n   * @param {StrictPropertyDescriptor<V, O, C, E, W>} [param0={}] The attributes of the descriptor.\n   * @param {StrictPropertyDescriptor<V, O, C, E, W>} param0.configurable The configurable property.\n   * @param {StrictPropertyDescriptor<V, O, C, E, W>} param0.enumerable The enumerable property.\n   * @param {StrictPropertyDescriptor<V, O, C, E, W>} param0.get The getter function.\n   * @param {StrictPropertyDescriptor<V, O, C, E, W>} param0.set The setter function.\n   * @param {StrictPropertyDescriptor<V, O, C, E, W>} param0.writable The writable property.\n   * @param {StrictPropertyDescriptor<V, O, C, E, W>} param0.value The value property.\n   * @param {?O} [object] The object (non-stored) to define the descriptor on. The object is optional, if not provided the descriptor will be created without an object.\n   * @param {?K} [key] The key (non-stored) of the property to define the descriptor on.\n   */\n  constructor(\n    {configurable, enumerable, get, set, value, writable}: StrictPropertyDescriptor<V, O, C, E, W> = {},\n    object?: O,\n    key?: K\n  ) {\n    super({configurable, enumerable});\n\n    // Deletes the PropertyDescriptor properties.\n    delete this.get, delete this.set, delete this.value, delete this.writable;\n\n    'get' in arguments[0] && (this.get = get);\n    'set' in arguments[0] && (this.set = set);\n\n    'value' in arguments[0] && (this.value = value);\n    'writable' in arguments[0] && (this.writable = writable);\n  }\n}\n","// Abstract.\nexport { CommonDescriptor } from './common-descriptor.abstract';\n// Class.\nexport { AccessorDescriptor } from './accessor-descriptor.class';\nexport { DataDescriptor } from './data-descriptor.class';\nexport { Descriptor } from './descriptor.class';\n","/*\n * Public API Surface of descriptor\n */\n\nexport {\n  // Abstract.\n  CommonDescriptor,\n  // Class.\n  AccessorDescriptor,\n  DataDescriptor,\n  Descriptor\n} from './lib';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"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"}