struct-fakerator 2.6.9 → 2.8.9

package/dist/config_scheme.mjs

@@ -1,17 +1,46 @@
-import {
-  arrayConfigScheme,
-  boundedSeriesScheme,
-  objConfigScheme,
-  selectionConfigScheme,
-  tupleConfigScheme,
-  valueConfigScheme
-} from "./chunk-USLYTOPD.mjs";
-import "./chunk-XGB3TDIC.mjs";
-export {
-  arrayConfigScheme,
-  boundedSeriesScheme,
-  objConfigScheme,
-  selectionConfigScheme,
-  tupleConfigScheme,
-  valueConfigScheme
-};
+import { z } from "zod";
+const valueConfigScheme = z.object({
+    type: z.string().regex(/^value$/, {
+        message: "invalid type string"
+    }),
+    generateFn: z.any()
+});
+const selectionConfigScheme = z.object({
+    type: z.string().regex(/^select$/, {
+        message: "invalid type string"
+    }),
+    items: z.any().array().nonempty({
+        message: "items can not be empty"
+    })
+});
+const arrayConfigScheme = z.object({
+    type: z.string().regex(/^arr$/, {
+        message: "invalid type string"
+    }),
+    item: z.object({}),
+    len: z.number().nonnegative()
+});
+const tupleConfigScheme = z.object({
+    type: z.string().regex(/^tuple$/, {
+        message: "invalid type string"
+    }),
+    configItems: z.any().array()
+});
+const objConfigScheme = z.object({
+    type: z.string().regex(/^obj$/, {
+        message: "invalid type string"
+    }),
+    content: z.object({})
+});
+const boundedSeriesScheme = z.object({
+    type: z.string().regex(/^bounded_series$/, {
+        message: "invalid type string"
+    }),
+    upperLimit: z.number().nonnegative(),
+    lowerLimit: z.number().nonnegative(),
+    createInitValue: z.any(),
+    count: z.number().nonnegative()
+}).refine(({ upperLimit, lowerLimit })=>upperLimit >= lowerLimit, {
+    message: "lowerLimit can not greater then upperLimit"
+});
+export { arrayConfigScheme, boundedSeriesScheme, objConfigScheme, selectionConfigScheme, tupleConfigScheme, valueConfigScheme };

package/dist/create_config.d.ts

@@ -1,25 +1,24 @@
-import { ValueConfig, Result, ArrayConfig, ObjectConfig, ObjectConfigWithFn, TupleConfig, SelectionConfig, BoundedSeriesConfig } from './type.js';
-
+import type { ArrayConfig, BoundedSeriesConfig, ObjectConfig, ObjectConfigWithFn, Result, SelectionConfig, TupleConfig, ValueConfig } from "./type";
 /**
  * value
  * @param {function} generateFn - The function used to generate the value.
  * @return {ValueConfig} The configuration object with the type "value" and the provided generate function.
  */
-declare const createValueConfig: <T>(generateFn: () => T) => ValueConfig<T>;
+export declare const createValueConfig: <T>(generateFn: () => T) => ValueConfig<T>;
 /**
  * selection
  * @param {Array} items - The array of items to choose from.
  * @return {SelectionConfig} The configuration object with the type "select" and the provided items.
  */
-declare const createSelectionConfig: <T>(items: T[]) => SelectionConfig<T>;
+export declare const createSelectionConfig: <T>(items: T[]) => SelectionConfig<T>;
 /**
  * object
  * @param {object} content
  * @param {function} transformer
  * @return {ObjectConfig}
  */
-declare function createObjectConfig<T extends object>(content: T): ObjectConfig<T>;
-declare function createObjectConfig<T extends object, R>(content: T, transformer: (v: {
+export declare function createObjectConfig<T extends object>(content: T): ObjectConfig<T>;
+export declare function createObjectConfig<T extends object, R>(content: T, transformer: (v: {
     [K in keyof T]: Result<T[K]>;
 }) => R): ObjectConfigWithFn<T, R>;
 /**
@@ -29,7 +28,7 @@ declare function createObjectConfig<T extends object, R>(content: T, transformer
  * @param {function} next
  * @return {ArrayConfig}
  */
-declare const createArrayConfig: <T>(item: T, len: number, next?: (v: Result<T>) => Result<T>) => ArrayConfig<T>;
+export declare const createArrayConfig: <T>(item: T, len: number, next?: (prev: Result<T>, current: Result<T>) => Result<T>) => ArrayConfig<T>;
 /**
  * tuple
  * @param {Array} configItems
@@ -47,12 +46,11 @@ interface CreateTupleConfig {
     <A, B>(configItems: [A, B]): TupleConfig<A, B>;
     <A>(configItems: [A]): TupleConfig<A>;
 }
-declare const createTupleConfig: CreateTupleConfig;
+export declare const createTupleConfig: CreateTupleConfig;
 /**
  * bounded series
  * @param {{ upperLimit: number, lowerLimit: number, createInitValue: () => number, count: number }} config
  * @return {BoundedSeriesConfig}
  */
-declare const createBoundedSeriesConfig: (config: Omit<BoundedSeriesConfig, "type">) => BoundedSeriesConfig;
-
-export { createArrayConfig, createBoundedSeriesConfig, createObjectConfig, createSelectionConfig, createTupleConfig, createValueConfig };
+export declare const createBoundedSeriesConfig: (config: Omit<BoundedSeriesConfig, "type">) => BoundedSeriesConfig;
+export {};

package/dist/create_config.js

@@ -1,18 +1,110 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-
-
-var _chunkC3RGM3CBjs = require('./chunk-C3RGM3CB.js');
-require('./chunk-ZWLHVT5O.js');
-require('./chunk-4VNS5WPM.js');
-
-
-
-
-
-
-
-exports.createArrayConfig = _chunkC3RGM3CBjs.createArrayConfig; exports.createBoundedSeriesConfig = _chunkC3RGM3CBjs.createBoundedSeriesConfig; exports.createObjectConfig = _chunkC3RGM3CBjs.createObjectConfig; exports.createSelectionConfig = _chunkC3RGM3CBjs.createSelectionConfig; exports.createTupleConfig = _chunkC3RGM3CBjs.createTupleConfig; exports.createValueConfig = _chunkC3RGM3CBjs.createValueConfig;
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createSelectionConfig: ()=>createSelectionConfig,
+    createValueConfig: ()=>createValueConfig,
+    createObjectConfig: ()=>createObjectConfig,
+    createArrayConfig: ()=>createArrayConfig,
+    createBoundedSeriesConfig: ()=>createBoundedSeriesConfig,
+    createTupleConfig: ()=>createTupleConfig
+});
+const external_config_scheme_js_namespaceObject = require("./config_scheme.js");
+const createValueConfig = (generateFn)=>{
+    const config = {
+        type: "value",
+        generateFn
+    };
+    external_config_scheme_js_namespaceObject.valueConfigScheme.parse(config);
+    return config;
+};
+const createSelectionConfig = (items)=>{
+    const config = {
+        type: "select",
+        items
+    };
+    external_config_scheme_js_namespaceObject.selectionConfigScheme.parse(config);
+    return config;
+};
+function createObjectConfig(content, transformer) {
+    if (transformer) {
+        const config = {
+            type: "obj",
+            content,
+            transformer
+        };
+        external_config_scheme_js_namespaceObject.objConfigScheme.parse(config);
+        return config;
+    }
+    const config = {
+        type: "obj",
+        content
+    };
+    external_config_scheme_js_namespaceObject.objConfigScheme.parse(config);
+    return config;
+}
+const createArrayConfig = (item, len, next)=>{
+    const config = {
+        type: "arr",
+        item,
+        len,
+        next
+    };
+    external_config_scheme_js_namespaceObject.arrayConfigScheme.parse(config);
+    return config;
+};
+const createTupleConfig = (configItems)=>{
+    const config = {
+        type: "tuple",
+        configItems
+    };
+    external_config_scheme_js_namespaceObject.tupleConfigScheme.parse(config);
+    return config;
+};
+const createBoundedSeriesConfig = (config)=>{
+    const newConfig = {
+        type: "bounded_series",
+        ...config
+    };
+    external_config_scheme_js_namespaceObject.boundedSeriesScheme.parse(newConfig);
+    return newConfig;
+};
+exports.createArrayConfig = __webpack_exports__.createArrayConfig;
+exports.createBoundedSeriesConfig = __webpack_exports__.createBoundedSeriesConfig;
+exports.createObjectConfig = __webpack_exports__.createObjectConfig;
+exports.createSelectionConfig = __webpack_exports__.createSelectionConfig;
+exports.createTupleConfig = __webpack_exports__.createTupleConfig;
+exports.createValueConfig = __webpack_exports__.createValueConfig;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createArrayConfig",
+    "createBoundedSeriesConfig",
+    "createObjectConfig",
+    "createSelectionConfig",
+    "createTupleConfig",
+    "createValueConfig"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/create_config.mjs

@@ -1,18 +1,61 @@
-import {
-  createArrayConfig,
-  createBoundedSeriesConfig,
-  createObjectConfig,
-  createSelectionConfig,
-  createTupleConfig,
-  createValueConfig
-} from "./chunk-ZQA42PYM.mjs";
-import "./chunk-USLYTOPD.mjs";
-import "./chunk-XGB3TDIC.mjs";
-export {
-  createArrayConfig,
-  createBoundedSeriesConfig,
-  createObjectConfig,
-  createSelectionConfig,
-  createTupleConfig,
-  createValueConfig
+import { arrayConfigScheme, boundedSeriesScheme, objConfigScheme, selectionConfigScheme, tupleConfigScheme, valueConfigScheme } from "./config_scheme.mjs";
+const createValueConfig = (generateFn)=>{
+    const config = {
+        type: "value",
+        generateFn
+    };
+    valueConfigScheme.parse(config);
+    return config;
 };
+const createSelectionConfig = (items)=>{
+    const config = {
+        type: "select",
+        items
+    };
+    selectionConfigScheme.parse(config);
+    return config;
+};
+function createObjectConfig(content, transformer) {
+    if (transformer) {
+        const config = {
+            type: "obj",
+            content,
+            transformer
+        };
+        objConfigScheme.parse(config);
+        return config;
+    }
+    const config = {
+        type: "obj",
+        content
+    };
+    objConfigScheme.parse(config);
+    return config;
+}
+const createArrayConfig = (item, len, next)=>{
+    const config = {
+        type: "arr",
+        item,
+        len,
+        next
+    };
+    arrayConfigScheme.parse(config);
+    return config;
+};
+const createTupleConfig = (configItems)=>{
+    const config = {
+        type: "tuple",
+        configItems
+    };
+    tupleConfigScheme.parse(config);
+    return config;
+};
+const createBoundedSeriesConfig = (config)=>{
+    const newConfig = {
+        type: "bounded_series",
+        ...config
+    };
+    boundedSeriesScheme.parse(newConfig);
+    return newConfig;
+};
+export { createArrayConfig, createBoundedSeriesConfig, createObjectConfig, createSelectionConfig, createTupleConfig, createValueConfig };

package/dist/create_config.test.d.ts

@@ -1,2 +1 @@
-
-export {  }
+export {};

package/dist/create_generator_fn.d.ts

@@ -1,12 +1,10 @@
-import { ValueConfig, SelectionConfig, Result, ObjectConfig, ArrayConfig, TupleConfig, BoundedSeriesConfig, ObjectConfigWithFn } from './type.js';
-
+import type { ArrayConfig, BoundedSeriesConfig, ObjectConfig, ObjectConfigWithFn, Result, SelectionConfig, TupleConfig, ValueConfig } from "./type";
 type AllConfig<T> = ValueConfig<T> | SelectionConfig<T> | ArrayConfig<T> | ObjectConfig<T> | ObjectConfigWithFn<T, unknown> | TupleConfig<T> | TupleConfig<T, T> | TupleConfig<T, T, T> | TupleConfig<T, T, T, T> | TupleConfig<T, T, T, T, T> | TupleConfig<T, T, T, T, T, T> | TupleConfig<T, T, T, T, T, T, T> | TupleConfig<T, T, T, T, T, T, T, T> | TupleConfig<T, T, T, T, T, T, T, T, T> | TupleConfig<T, T, T, T, T, T, T, T, T, T> | BoundedSeriesConfig;
-declare const createValueGenerator: <R = unknown>(config: ValueConfig<unknown>) => (() => R);
-declare const createSelectionGenerator: <T extends SelectionConfig<unknown>>(config: T) => (() => Result<T>);
-declare const createObjectGenerator: <T extends ObjectConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>) => (() => Result<T>);
-declare const createArrayGenerator: <T extends ArrayConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>) => (() => Result<T>);
-declare const createTupleGenerator: <T extends TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown> | TupleConfig<unknown, unknown> | TupleConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path: string) => ValueConfig<unknown>) => (() => Result<T>);
-declare const createBoundedSeriesGenerator: <T extends BoundedSeriesConfig>(config: T) => (() => Result<T>);
-declare const createGeneratorByType: <T extends AllConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path: string) => ValueConfig<unknown>) => (() => Result<T>);
-
-export { createArrayGenerator, createBoundedSeriesGenerator, createGeneratorByType, createObjectGenerator, createSelectionGenerator, createTupleGenerator, createValueGenerator };
+export declare const createValueGenerator: <R = unknown>(config: ValueConfig<unknown>) => (() => R);
+export declare const createSelectionGenerator: <T extends SelectionConfig<unknown>>(config: T) => (() => Result<T>);
+export declare const createObjectGenerator: <T extends ObjectConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>) => (() => Result<T>);
+export declare const createArrayGenerator: <T extends ArrayConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path?: string) => ValueConfig<unknown>) => (() => Result<T>);
+export declare const createTupleGenerator: <T extends TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown, unknown> | TupleConfig<unknown, unknown, unknown> | TupleConfig<unknown, unknown> | TupleConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path: string) => ValueConfig<unknown>) => (() => Result<T>);
+export declare const createBoundedSeriesGenerator: <T extends BoundedSeriesConfig>(config: T) => (() => Result<T>);
+export declare const createGeneratorByType: <T extends AllConfig<unknown>>(config: T, customTypeMatch?: (config: unknown, path: string) => ValueConfig<unknown>) => (() => Result<T>);
+export {};

package/dist/create_generator_fn.js

@@ -1,21 +1,168 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-
-
-
-var _chunkU7MLTDS4js = require('./chunk-U7MLTDS4.js');
-require('./chunk-TZ2RKEBF.js');
-require('./chunk-ZWLHVT5O.js');
-require('./chunk-4VNS5WPM.js');
-
-
-
-
-
-
-
-
-exports.createArrayGenerator = _chunkU7MLTDS4js.createArrayGenerator; exports.createBoundedSeriesGenerator = _chunkU7MLTDS4js.createBoundedSeriesGenerator; exports.createGeneratorByType = _chunkU7MLTDS4js.createGeneratorByType; exports.createObjectGenerator = _chunkU7MLTDS4js.createObjectGenerator; exports.createSelectionGenerator = _chunkU7MLTDS4js.createSelectionGenerator; exports.createTupleGenerator = _chunkU7MLTDS4js.createTupleGenerator; exports.createValueGenerator = _chunkU7MLTDS4js.createValueGenerator;
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createTupleGenerator: ()=>createTupleGenerator,
+    createValueGenerator: ()=>createValueGenerator,
+    createArrayGenerator: ()=>createArrayGenerator,
+    createBoundedSeriesGenerator: ()=>createBoundedSeriesGenerator,
+    createObjectGenerator: ()=>createObjectGenerator,
+    createSelectionGenerator: ()=>createSelectionGenerator,
+    createGeneratorByType: ()=>createGeneratorByType
+});
+const faker_namespaceObject = require("@faker-js/faker");
+const external_config_scheme_js_namespaceObject = require("./config_scheme.js");
+const _createValueGenerator = (config, path)=>{
+    try {
+        external_config_scheme_js_namespaceObject.valueConfigScheme.parse(config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.value\n${err}`);
+    }
+    return config.generateFn;
+};
+const createValueGenerator = (config)=>_createValueGenerator(config, "*");
+const _createSelectionGenerator = (config, path)=>{
+    try {
+        external_config_scheme_js_namespaceObject.selectionConfigScheme.parse(config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.select\n${err}`);
+    }
+    const { items } = config;
+    return ()=>items[faker_namespaceObject.faker.number.int(items.length - 1)];
+};
+const createSelectionGenerator = (config)=>_createSelectionGenerator(config, "*");
+const _createObjectGenerator = (config, path, customTypeMatch)=>{
+    try {
+        external_config_scheme_js_namespaceObject.objConfigScheme.parse(config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.obj\n ${err}`);
+    }
+    const keyWithFns = Object.entries(config.content).map(([key, subConfig])=>[
+            key,
+            _createGeneratorByType(subConfig, `${path}.obj[${key}]`, customTypeMatch)
+        ]);
+    return ()=>{
+        const result = {};
+        for (const [key, generateFn] of keyWithFns)result[key] = generateFn();
+        if ("transformer" in config && "function" == typeof config.transformer) return config.transformer(result);
+        return result;
+    };
+};
+const createObjectGenerator = (config, customTypeMatch)=>_createObjectGenerator(config, "*", customTypeMatch);
+const _createArrayGenerator = (config, path, customTypeMatch)=>{
+    try {
+        external_config_scheme_js_namespaceObject.arrayConfigScheme.parse(config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.arr\n ${err}`);
+    }
+    const itemGeneratorFn = _createGeneratorByType(config.item, `${path}.arr`, customTypeMatch);
+    if (config.next) {
+        const next = config.next;
+        return ()=>{
+            let prev = itemGeneratorFn();
+            const result = [];
+            for(let i = 0; i < config.len; i++){
+                const nextValue = next(prev, itemGeneratorFn());
+                result.push(nextValue);
+                prev = nextValue;
+            }
+            return result;
+        };
+    }
+    return ()=>Array.from({
+            length: config.len ?? 0
+        }, itemGeneratorFn);
+};
+const createArrayGenerator = (config, customTypeMatch)=>_createArrayGenerator(config, "*", customTypeMatch);
+const _createTupleGenerator = (config, path, customTypeMatch)=>{
+    try {
+        external_config_scheme_js_namespaceObject.tupleConfigScheme.parse(config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.tuple\n ${err}`);
+    }
+    const itemsFns = config.configItems.map((configItem, index)=>_createGeneratorByType(configItem, `${path}.tuple[${index}]`, customTypeMatch));
+    return ()=>itemsFns.map((generateFn)=>generateFn());
+};
+const createTupleGenerator = (config, customTypeMatch)=>_createTupleGenerator(config, "*", customTypeMatch);
+const _createBoundedSeriesGenerator = (config, path)=>{
+    try {
+        external_config_scheme_js_namespaceObject.boundedSeriesScheme.parse(config);
+    } catch (err) {
+        throw new Error(`config path: ${path}.boundedSeries\n ${err}`);
+    }
+    const { upperLimit, lowerLimit, createInitValue, count } = config;
+    return ()=>{
+        let value = createInitValue();
+        const boundedSeries = [];
+        for(let i = 0; i < count; i++){
+            value = faker_namespaceObject.faker.number.float({
+                max: upperLimit,
+                min: lowerLimit
+            }) * value;
+            boundedSeries.push(value);
+        }
+        return boundedSeries;
+    };
+};
+const createBoundedSeriesGenerator = (config)=>_createBoundedSeriesGenerator(config, "*");
+const _createGeneratorByType = (config, path, customTypeMatch)=>{
+    switch(config.type){
+        case "obj":
+            return _createObjectGenerator(config, path, customTypeMatch);
+        case "arr":
+            return _createArrayGenerator(config, path, customTypeMatch);
+        case "tuple":
+            return _createTupleGenerator(config, path, customTypeMatch);
+        case "select":
+            return _createSelectionGenerator(config, path);
+        case "value":
+            return _createValueGenerator(config, path);
+        case "bounded_series":
+            return _createBoundedSeriesGenerator(config, path);
+        default:
+            if (customTypeMatch) return createValueGenerator(customTypeMatch(config, path));
+            throw new Error(`path: ${path}\nconfig type is not supported`);
+    }
+};
+const createGeneratorByType = (config, customTypeMatch)=>_createGeneratorByType(config, "*", customTypeMatch);
+exports.createArrayGenerator = __webpack_exports__.createArrayGenerator;
+exports.createBoundedSeriesGenerator = __webpack_exports__.createBoundedSeriesGenerator;
+exports.createGeneratorByType = __webpack_exports__.createGeneratorByType;
+exports.createObjectGenerator = __webpack_exports__.createObjectGenerator;
+exports.createSelectionGenerator = __webpack_exports__.createSelectionGenerator;
+exports.createTupleGenerator = __webpack_exports__.createTupleGenerator;
+exports.createValueGenerator = __webpack_exports__.createValueGenerator;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createArrayGenerator",
+    "createBoundedSeriesGenerator",
+    "createGeneratorByType",
+    "createObjectGenerator",
+    "createSelectionGenerator",
+    "createTupleGenerator",
+    "createValueGenerator"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});