@autofleet/sadot 1.6.18-beta.4 → 1.6.18-beta.5

package/dist/_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.cjs

@@ -0,0 +1,11 @@
+
+//#region \0@oxc-project+runtime@0.103.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+exports.__decorate = __decorate;

package/dist/_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.cjs

@@ -0,0 +1,8 @@
+
+//#region \0@oxc-project+runtime@0.103.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+//#endregion
+exports.__decorateMetadata = __decorateMetadata;

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,45 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__commonJSMin = __commonJSMin;
+exports.__export = __export;
+exports.__toESM = __toESM;

package/dist/api/v1/validator/validations.d.cts

@@ -0,0 +1,22 @@
+import Joi from "joi";
+
+//#region src/api/v1/validator/validations.d.ts
+interface SchemaObject {
+  type: "object";
+  properties?: {
+    before?: object;
+    after?: object;
+  };
+  required?: string[];
+  allOf?: object[];
+  anyOf?: object[];
+  oneOf?: object[];
+  additionalProperties?: boolean | object;
+  $id?: string;
+  $schema?: string;
+  if?: object;
+  then?: object;
+  else?: object;
+}
+//#endregion
+export { SchemaObject };

package/dist/index.cjs

@@ -0,0 +1,87 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_index = require('./packages/sadot/src/utils/logger/index.cjs');
+const require_index$1 = require('./packages/sadot/src/utils/constants/index.cjs');
+const require_CustomFieldValue = require('./packages/sadot/src/models/CustomFieldValue.cjs');
+const require_CustomFieldDefinition = require('./packages/sadot/src/models/CustomFieldDefinition.cjs');
+const require_CustomFieldEntries = require('./packages/sadot/src/models/CustomFieldEntries.cjs');
+const require_CustomValidator = require('./packages/sadot/src/models/CustomValidator.cjs');
+const require_index$2 = require('./packages/sadot/src/migrations/index.cjs');
+const require_index$3 = require('./packages/sadot/src/models/index.cjs');
+const require_mat_path_state = require('./packages/sadot/src/mat-path-state.cjs');
+const require_FieldPolicy = require('./packages/sadot/src/models/FieldPolicy.cjs');
+const require_field_policy = require('./packages/sadot/src/repository/field-policy.cjs');
+const require_index$4 = require('./packages/sadot/src/api/v1/templates/index.cjs');
+const require_index$5 = require('./packages/sadot/src/api/index.cjs');
+const require_index$6 = require('./packages/sadot/src/utils/db/index.cjs');
+const require_index$7 = require('./packages/sadot/src/utils/helpers/index.cjs');
+const require_filter = require('./packages/sadot/src/scopes/filter.cjs');
+const require_init = require('./packages/sadot/src/utils/init.cjs');
+const require_init_state = require('./packages/sadot/src/init-state.cjs');
+const require_custom_fields = require('./packages/sadot/src/utils/validations/schema/custom-fields.cjs');
+
+//#region src/index.ts
+const sadotInitState = new require_init_state.SadotInitializationState();
+/**
+* Internal implementation of custom fields initialization
+* Contains all the business logic without state tracking
+*/
+const internalUseCustomFields = async (app, getModel, options) => {
+	require_index.tryAddingTraceIdMiddleware();
+	const { models, useCustomFieldsEntries, useModelTypeMapping, isMatPathEnabled, runLegacyMigrations } = options;
+	require_mat_path_state.matPathState.isMatPathEnabled = isMatPathEnabled;
+	if (app) {
+		app.use("/api", require_index$5.default);
+		app.use("/api/v1/templates", require_index$4.default);
+	}
+	const sequelize = options.sequelize ?? require_index$6.default(options.databaseConfig);
+	if (process.env.NODE_ENV === "test") await require_index$3.initTestModels(sequelize);
+	sequelize.addModels([require_FieldPolicy.default]);
+	require_init.addHooks(models, getModel, { useCustomFieldsEntries });
+	await require_index$3.initTables(sequelize, options.getUser, {
+		useCustomFieldsEntries,
+		useModelTypeMapping,
+		isMatPathEnabled,
+		runLegacyMigrations
+	});
+	await require_index$2.runSadotMigrations(sequelize);
+	require_init.addScopes(models, getModel, { useCustomFieldsEntries });
+	require_init.applyCustomAssociation(models);
+	require_index.default.debug("sadot - custom fields finished initializing with models", models);
+	return sequelize;
+};
+/**
+* Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
+* @see {@link 'custom-fields/config'} for configurations
+*/
+const useCustomFields = async (app, getModel, options) => {
+	const initPromise = internalUseCustomFields(app, getModel, options);
+	sadotInitState.setInitPromise(initPromise, !options.sequelize);
+	return await initPromise;
+};
+var src_default = useCustomFields;
+const disableCustomFields = (models, getModel) => {
+	require_init.removeHooks(models, getModel);
+};
+
+//#endregion
+exports.CUSTOM_FIELDS_FILTER_SCOPE = require_index$1.CUSTOM_FIELDS_FILTER_SCOPE;
+exports.CustomFieldDefinition = require_CustomFieldDefinition.default;
+exports.CustomFieldDefinitionType = require_index$1.CustomFieldDefinitionType;
+exports.CustomFieldEntries = require_CustomFieldEntries.default;
+exports.CustomFieldValue = require_CustomFieldValue.default;
+exports.CustomFieldsSchema = require_custom_fields.CustomFieldsSchema;
+exports.CustomValidator = require_CustomValidator.default;
+exports.FieldPolicy = require_FieldPolicy.default;
+Object.defineProperty(exports, 'FieldPolicyRepo', {
+  enumerable: true,
+  get: function () {
+    return require_field_policy.field_policy_exports;
+  }
+});
+exports.customFieldsSortScope = require_filter.customFieldsSortScope;
+exports.default = src_default;
+exports.disableCustomFields = disableCustomFields;
+exports.generateCustomFieldSearchQueryPayload = require_index$7.generateCustomFieldSearchQueryPayload;
+exports.generateRandomString = require_index$7.generateRandomString;
+exports.sadotInitState = sadotInitState;
+exports.supportedEntities = require_index$1.supportedEntities;

package/dist/index.d.cts

@@ -0,0 +1,25 @@
+import { CUSTOM_FIELDS_FILTER_SCOPE, CustomFieldDefinitionType, supportedEntities } from "./utils/constants/index.cjs";
+import { CustomFieldValue } from "./models/CustomFieldValue.cjs";
+import { CustomFieldDefinition } from "./models/CustomFieldDefinition.cjs";
+import { CustomValidator } from "./models/CustomValidator.cjs";
+import { CustomFieldOptions, ModelFetcher, Models } from "./types/index.cjs";
+import { SadotInitializationState } from "./init-state.cjs";
+import { CustomFieldsSchema } from "./utils/validations/schema/custom-fields.cjs";
+import { generateCustomFieldSearchQueryPayload, generateRandomString } from "./utils/helpers/index.cjs";
+import { customFieldsSortScope } from "./scopes/filter.cjs";
+import { CustomFieldEntries } from "./models/CustomFieldEntries.cjs";
+import { FieldPolicy, ModelInclusion, ModelMode } from "./models/FieldPolicy.cjs";
+import { field_policy_d_exports } from "./repository/field-policy.cjs";
+import { Application } from "express";
+import { Sequelize } from "sequelize-typescript";
+
+//#region src/index.d.ts
+declare const sadotInitState: SadotInitializationState;
+/**
+* Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
+* @see {@link 'custom-fields/config'} for configurations
+*/
+declare const useCustomFields: (app: Pick<Application, "use"> | null, getModel: ModelFetcher, options: CustomFieldOptions) => Promise<Sequelize>;
+declare const disableCustomFields: (models: Models[], getModel: ModelFetcher) => void;
+//#endregion
+export { CUSTOM_FIELDS_FILTER_SCOPE, CustomFieldDefinition, CustomFieldDefinitionType, CustomFieldEntries, CustomFieldValue, CustomFieldsSchema, CustomValidator, FieldPolicy, field_policy_d_exports as FieldPolicyRepo, type ModelInclusion, type ModelMode, customFieldsSortScope, useCustomFields as default, disableCustomFields, generateCustomFieldSearchQueryPayload, generateRandomString, sadotInitState, supportedEntities };

package/dist/init-state.d.cts

@@ -0,0 +1,35 @@
+import { Sequelize } from "sequelize-typescript";
+
+//#region src/init-state.d.ts
+
+/**
+* Tracks the initialization state of sadot's useCustomFields function
+* Allows HealthManager to wait for initialization before passing readiness checks
+*/
+declare class SadotInitializationState {
+  private initPromise;
+  private initError;
+  private isInitialized;
+  private sequelizeInstance;
+  private ownsSequelizeInstance;
+  /** Set the initialization promise */
+  setInitPromise(promise: Promise<Sequelize>, ownsSequelize: boolean): void;
+  /**
+  * Get the Sequelize instance
+  * Returns null if initialization hasn't completed yet, or in cases where it failed.
+  */
+  get sequelize(): Sequelize | null;
+  /**
+  * Wait for initialization to complete and return the Sequelize instance
+  * Returns the Sequelize instance only if Sadot created it (owns it)
+  * Returns undefined if the Sequelize instance was provided externally
+  * Rejects when initialization fails
+  */
+  waitForInitialization(): Promise<Sequelize | undefined>;
+  /** Check if initialization is complete and successful */
+  get isReady(): boolean;
+  /** Get the initialization error if one occurred */
+  get error(): Error | null;
+}
+//#endregion
+export { SadotInitializationState };

package/dist/models/CustomFieldDefinition.d.cts

@@ -0,0 +1,40 @@
+import { CustomFieldDefinitionType } from "../utils/constants/index.cjs";
+import { CustomFieldValue } from "./CustomFieldValue.cjs";
+import { CustomFieldModelTypeMap } from "./CustomFieldModelTypeMap.cjs";
+import { Model } from "sequelize-typescript";
+import { CreateOptions } from "sequelize";
+
+//#region src/models/CustomFieldDefinition.d.ts
+declare class CustomFieldDefinition extends Model {
+  id: string;
+  name: string;
+  displayName?: string;
+  fieldType: CustomFieldDefinitionType;
+  validation?: any;
+  entityId: string;
+  entityType: string;
+  modelType: string;
+  description?: string;
+  required?: boolean;
+  disabled?: boolean;
+  defaultValue?: any;
+  createdAt?: Date;
+  updatedAt?: Date;
+  deletedAt?: Date;
+  blockEditingFromUI: boolean;
+  values: CustomFieldValue[];
+  modelTypeMappings?: CustomFieldModelTypeMap[];
+  private _modelTypeIds?;
+  get modelTypeIds(): string[] | undefined;
+  set modelTypeIds(value: string[] | undefined);
+  static displayNameDefaultValue(instance: CustomFieldDefinition): void;
+  static afterSaveHandler(instance: CustomFieldDefinition, options: CreateOptions): void;
+  /**
+  * Override toJSON to exclude internal associations from API responses
+  * The modelTypeMappings association is used internally to optimize queries
+  * but should not be exposed in the API response (use modelTypeIds instead)
+  */
+  toJSON(): object;
+}
+//#endregion
+export { CustomFieldDefinition };

package/dist/models/CustomFieldEntries.d.cts

@@ -0,0 +1,15 @@
+import { Model } from "sequelize-typescript";
+import { CreateOptions } from "sequelize";
+
+//#region src/models/CustomFieldEntries.d.ts
+declare class CustomFieldEntries extends Model {
+  modelId: string;
+  entityId: string;
+  customFields: Record<string, any>;
+  modelType: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+  static afterSaveHandler(instance: CustomFieldEntries[], options: CreateOptions): void;
+}
+//#endregion
+export { CustomFieldEntries };

package/dist/models/CustomFieldModelTypeMap.d.cts

@@ -0,0 +1,14 @@
+import { CustomFieldDefinition } from "./CustomFieldDefinition.cjs";
+import { Model } from "sequelize-typescript";
+
+//#region src/models/CustomFieldModelTypeMap.d.ts
+declare class CustomFieldModelTypeMap extends Model {
+  id: string;
+  modelTypeId: string;
+  customFieldDefinitionId: string;
+  customFieldDefinition: CustomFieldDefinition;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+//#endregion
+export { CustomFieldModelTypeMap };

package/dist/models/CustomFieldValue.d.cts

@@ -0,0 +1,20 @@
+import { CustomFieldDefinition } from "./CustomFieldDefinition.cjs";
+import { Model } from "sequelize-typescript";
+import { CreateOptions } from "sequelize";
+
+//#region src/models/CustomFieldValue.d.ts
+declare class CustomFieldValue extends Model {
+  modelId: string;
+  customFieldDefinitionId: string;
+  value: any;
+  createdAt?: Date;
+  updatedAt?: Date;
+  deletedAt?: Date;
+  customFieldDefinition: CustomFieldDefinition;
+  private static validateValueAgainstDefinition;
+  static validateCustomFieldValues(instances: CustomFieldValue[]): Promise<void>;
+  static validateCustomFieldValue(instance: CustomFieldValue): Promise<void>;
+  static afterSaveHandler(instance: CustomFieldValue[], options: CreateOptions): void;
+}
+//#endregion
+export { CustomFieldValue };

package/dist/models/CustomValidator.d.cts

@@ -0,0 +1,18 @@
+import { SchemaObject } from "../api/v1/validator/validations.cjs";
+import { Model } from "sequelize-typescript";
+import { CreateOptions } from "sequelize";
+
+//#region src/models/CustomValidator.d.ts
+declare class CustomValidator extends Model {
+  id: string;
+  entityId: string;
+  entityType: string;
+  modelType: string;
+  schema: SchemaObject;
+  disabled: boolean;
+  createdAt?: Date;
+  updatedAt?: Date;
+  static afterSaveHandler(instance: CustomValidator, options: CreateOptions): void;
+}
+//#endregion
+export { CustomValidator };

package/dist/models/FieldPolicy.d.cts

@@ -0,0 +1,23 @@
+import { Model } from "sequelize-typescript";
+
+//#region src/models/FieldPolicy.d.ts
+type ModelMode = "full" | "partial";
+type ModelInclusion = {
+  name: string;
+  mode: "full";
+} | {
+  name: string;
+  mode: "partial";
+  fields: string[];
+};
+declare class FieldPolicy extends Model {
+  id: string;
+  contextId: string;
+  name: string;
+  /** Base-level field names to include */
+  fields: string[];
+  /** Model inclusions; full = all fields, partial = only listed fields */
+  models: ModelInclusion[];
+}
+//#endregion
+export { FieldPolicy, ModelInclusion, ModelMode };

package/dist/node_modules/accepts/index.cjs

@@ -0,0 +1,180 @@
+'use strict';
+
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../mime-types/index.cjs');
+const require_index$1 = require('../negotiator/index.cjs');
+
+//#region ../../node_modules/accepts/index.js
+/*!
+* accepts
+* Copyright(c) 2014 Jonathan Ong
+* Copyright(c) 2015 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_accepts = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var Negotiator = require_index$1.default;
+	var mime = require_index.default;
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = Accepts;
+	/**
+	* Create a new Accepts object for the given req.
+	*
+	* @param {object} req
+	* @public
+	*/
+	function Accepts(req) {
+		if (!(this instanceof Accepts)) return new Accepts(req);
+		this.headers = req.headers;
+		this.negotiator = new Negotiator(req);
+	}
+	/**
+	* Check if the given `type(s)` is acceptable, returning
+	* the best match when true, otherwise `undefined`, in which
+	* case you should respond with 406 "Not Acceptable".
+	*
+	* The `type` value may be a single mime type string
+	* such as "application/json", the extension name
+	* such as "json" or an array `["json", "html", "text/plain"]`. When a list
+	* or array is given the _best_ match, if any is returned.
+	*
+	* Examples:
+	*
+	*     // Accept: text/html
+	*     this.types('html');
+	*     // => "html"
+	*
+	*     // Accept: text/*, application/json
+	*     this.types('html');
+	*     // => "html"
+	*     this.types('text/html');
+	*     // => "text/html"
+	*     this.types('json', 'text');
+	*     // => "json"
+	*     this.types('application/json');
+	*     // => "application/json"
+	*
+	*     // Accept: text/*, application/json
+	*     this.types('image/png');
+	*     this.types('png');
+	*     // => undefined
+	*
+	*     // Accept: text/*;q=.5, application/json
+	*     this.types(['html', 'json']);
+	*     this.types('html', 'json');
+	*     // => "json"
+	*
+	* @param {String|Array} types...
+	* @return {String|Array|Boolean}
+	* @public
+	*/
+	Accepts.prototype.type = Accepts.prototype.types = function(types_) {
+		var types = types_;
+		if (types && !Array.isArray(types)) {
+			types = new Array(arguments.length);
+			for (var i = 0; i < types.length; i++) types[i] = arguments[i];
+		}
+		if (!types || types.length === 0) return this.negotiator.mediaTypes();
+		if (!this.headers.accept) return types[0];
+		var mimes = types.map(extToMime);
+		var first = this.negotiator.mediaTypes(mimes.filter(validMime))[0];
+		return first ? types[mimes.indexOf(first)] : false;
+	};
+	/**
+	* Return accepted encodings or best fit based on `encodings`.
+	*
+	* Given `Accept-Encoding: gzip, deflate`
+	* an array sorted by quality is returned:
+	*
+	*     ['gzip', 'deflate']
+	*
+	* @param {String|Array} encodings...
+	* @return {String|Array}
+	* @public
+	*/
+	Accepts.prototype.encoding = Accepts.prototype.encodings = function(encodings_) {
+		var encodings = encodings_;
+		if (encodings && !Array.isArray(encodings)) {
+			encodings = new Array(arguments.length);
+			for (var i = 0; i < encodings.length; i++) encodings[i] = arguments[i];
+		}
+		if (!encodings || encodings.length === 0) return this.negotiator.encodings();
+		return this.negotiator.encodings(encodings)[0] || false;
+	};
+	/**
+	* Return accepted charsets or best fit based on `charsets`.
+	*
+	* Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
+	* an array sorted by quality is returned:
+	*
+	*     ['utf-8', 'utf-7', 'iso-8859-1']
+	*
+	* @param {String|Array} charsets...
+	* @return {String|Array}
+	* @public
+	*/
+	Accepts.prototype.charset = Accepts.prototype.charsets = function(charsets_) {
+		var charsets = charsets_;
+		if (charsets && !Array.isArray(charsets)) {
+			charsets = new Array(arguments.length);
+			for (var i = 0; i < charsets.length; i++) charsets[i] = arguments[i];
+		}
+		if (!charsets || charsets.length === 0) return this.negotiator.charsets();
+		return this.negotiator.charsets(charsets)[0] || false;
+	};
+	/**
+	* Return accepted languages or best fit based on `langs`.
+	*
+	* Given `Accept-Language: en;q=0.8, es, pt`
+	* an array sorted by quality is returned:
+	*
+	*     ['es', 'pt', 'en']
+	*
+	* @param {String|Array} langs...
+	* @return {Array|String}
+	* @public
+	*/
+	Accepts.prototype.lang = Accepts.prototype.langs = Accepts.prototype.language = Accepts.prototype.languages = function(languages_) {
+		var languages = languages_;
+		if (languages && !Array.isArray(languages)) {
+			languages = new Array(arguments.length);
+			for (var i = 0; i < languages.length; i++) languages[i] = arguments[i];
+		}
+		if (!languages || languages.length === 0) return this.negotiator.languages();
+		return this.negotiator.languages(languages)[0] || false;
+	};
+	/**
+	* Convert extnames to mime.
+	*
+	* @param {String} type
+	* @return {String}
+	* @private
+	*/
+	function extToMime(type) {
+		return type.indexOf("/") === -1 ? mime.lookup(type) : type;
+	}
+	/**
+	* Check if mime is valid.
+	*
+	* @param {String} type
+	* @return {String}
+	* @private
+	*/
+	function validMime(type) {
+		return typeof type === "string";
+	}
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_accepts();
+  }
+});

package/dist/node_modules/array-flatten/array-flatten.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+
+//#region ../../node_modules/array-flatten/array-flatten.js
+var require_array_flatten = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/**
+	* Expose `arrayFlatten`.
+	*/
+	module.exports = arrayFlatten;
+	/**
+	* Recursive flatten function with depth.
+	*
+	* @param  {Array}  array
+	* @param  {Array}  result
+	* @param  {Number} depth
+	* @return {Array}
+	*/
+	function flattenWithDepth(array, result, depth) {
+		for (var i = 0; i < array.length; i++) {
+			var value = array[i];
+			if (depth > 0 && Array.isArray(value)) flattenWithDepth(value, result, depth - 1);
+			else result.push(value);
+		}
+		return result;
+	}
+	/**
+	* Recursive flatten function. Omitting depth is slightly faster.
+	*
+	* @param  {Array} array
+	* @param  {Array} result
+	* @return {Array}
+	*/
+	function flattenForever(array, result) {
+		for (var i = 0; i < array.length; i++) {
+			var value = array[i];
+			if (Array.isArray(value)) flattenForever(value, result);
+			else result.push(value);
+		}
+		return result;
+	}
+	/**
+	* Flatten an array, with the ability to define a depth.
+	*
+	* @param  {Array}  array
+	* @param  {Number} depth
+	* @return {Array}
+	*/
+	function arrayFlatten(array, depth) {
+		if (depth == null) return flattenForever(array, []);
+		return flattenWithDepth(array, [], depth);
+	}
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_array_flatten();
+  }
+});