@questwork/q-utilities 0.1.30 → 0.1.32

package/dist/index.min.cjs

@@ -1,4744 +0,0 @@
-(function webpackUniversalModuleDefinition(root, factory) {
-	if(typeof exports === 'object' && typeof module === 'object')
-		module.exports = factory();
-	else if(typeof define === 'function' && define.amd)
-		define([], factory);
-	else {
-		var a = factory();
-		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
-	}
-})(this, () => {
-return /******/ (() => { // webpackBootstrap
-/******/ 	"use strict";
-/******/ 	// The require scope
-/******/ 	var __webpack_require__ = {};
-/******/ 	
-/************************************************************************/
-/******/ 	/* webpack/runtime/define property getters */
-/******/ 	(() => {
-/******/ 		// define getter functions for harmony exports
-/******/ 		__webpack_require__.d = (exports, definition) => {
-/******/ 			for(var key in definition) {
-/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
-/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
-/******/ 				}
-/******/ 			}
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
-/******/ 	(() => {
-/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/make namespace object */
-/******/ 	(() => {
-/******/ 		// define __esModule on exports
-/******/ 		__webpack_require__.r = (exports) => {
-/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 			}
-/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/************************************************************************/
-var __webpack_exports__ = {};
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  ActionRecord: () => (/* reexport */ ActionRecord),
-  ApiResponse: () => (/* reexport */ ApiResponse),
-  AwsStsS3Client: () => (/* reexport */ AwsStsS3Client),
-  KeyValueObject: () => (/* reexport */ keyValueObject_KeyValueObject),
-  Metadata: () => (/* reexport */ Metadata),
-  PushEnvelope: () => (/* reexport */ PushEnvelope),
-  QMeta: () => (/* reexport */ QMeta),
-  Repo: () => (/* reexport */ Repo),
-  Service: () => (/* reexport */ Service),
-  Status: () => (/* reexport */ Status),
-  StatusDocument: () => (/* reexport */ StatusDocument),
-  TemplateCompiler: () => (/* reexport */ TemplateCompiler),
-  TenantAwareEntity: () => (/* reexport */ TenantAwareEntity),
-  TrackedEntity: () => (/* reexport */ TrackedEntity),
-  UniqueKeyGenerator: () => (/* reexport */ UniqueKeyGenerator),
-  authorize: () => (/* reexport */ authorize),
-  bwipJsHelper: () => (/* reexport */ bwipJsHelper),
-  calculateAge: () => (/* reexport */ calculateAge),
-  changeCreatorOwner: () => (/* reexport */ changeCreatorOwner),
-  concatStringByArray: () => (/* reexport */ concatStringByArray),
-  convertString: () => (/* reexport */ convertString),
-  detectControlCharacters: () => (/* reexport */ detectControlCharacters),
-  downloadFileByUrl: () => (/* reexport */ downloadFileByUrl),
-  escapeRegex: () => (/* reexport */ escapeRegex),
-  expressHelper: () => (/* reexport */ expressHelper),
-  extractEmails: () => (/* reexport */ extractEmails),
-  formatDate: () => (/* reexport */ formatDate),
-  generalPost: () => (/* reexport */ generalPost),
-  getObjectByArr: () => (/* reexport */ getObjectByArr),
-  getValidation: () => (/* reexport */ getValidation),
-  getValueByKeys: () => (/* reexport */ getValueByKeys_getValueByKeys),
-  groupArrayByKey: () => (/* reexport */ groupArrayByKey),
-  init: () => (/* reexport */ init),
-  initFromArray: () => (/* reexport */ initFromArray),
-  initOnlyValidFromArray: () => (/* reexport */ initOnlyValidFromArray),
-  isConvertibleToNumber: () => (/* reexport */ isConvertibleToNumber),
-  makeApiResponse: () => (/* reexport */ makeApiResponse),
-  makeService: () => (/* reexport */ makeService),
-  mergeArraysByKey: () => (/* reexport */ mergeArraysByKey),
-  objectHelper: () => (/* reexport */ objectHelper),
-  pMap: () => (/* reexport */ pMap),
-  pMapIterable: () => (/* reexport */ pMapIterable),
-  pMapSkip: () => (/* reexport */ pMapSkip),
-  pReduce: () => (/* reexport */ pReduce),
-  padZeros: () => (/* reexport */ padZeros),
-  printControlCharReport: () => (/* reexport */ printControlCharReport),
-  replacePlaceholders: () => (/* reexport */ replacePlaceholders),
-  sanitizeText: () => (/* reexport */ sanitizeText),
-  shuffleArray: () => (/* reexport */ shuffleArray),
-  stringFormatter: () => (/* reexport */ stringFormatter),
-  stringHelper: () => (/* reexport */ stringHelper),
-  tenantPlugin: () => (/* reexport */ tenantPlugin),
-  trackingPlugin: () => (/* reexport */ trackingPlugin)
-});
-
-;// ./lib/helpers/authorize/authorize.js
-function authorize({ allowCoordinator, allowOwner, query = {}, required, user }) {
-  if (!user) {
-    throw new Error('Require login.')
-  }
-  if (!user.permission) {
-    // throw new Error('You do not have any permission.')
-  }
-  const scopes = user.permission.getScopes(required || {}) || []
-  if (!scopes || scopes.length === 0) {
-    // throw new Error('You are not allowed in this scope.')
-  }
-  if (!scopes.includes('*')) {
-    query.tenantCode = user.tenantCode
-  }
-  if (!scopes.includes('TENANT')) {
-    query.eventShortCode = user.eventShortCode
-  }
-  // if (!scopes.includes('EVENT')) {
-  //   query.eventRegistrationCode = user.eventRegistrationCode
-  // }
-  if (allowCoordinator) {
-    if (query.registrationGroupCode && user.myManagedRegistrationGroupCodes.includes(query.registrationGroupCode)) {
-      query.__ALLOW_COORDINATOR = true
-    } else {
-      if (!scopes.includes('EVENT')) {
-        query.eventRegistrationCode = user.eventRegistrationCode
-      }
-    }
-  } else {
-    if (!scopes.includes('EVENT')) {
-      query.eventRegistrationCode = user.eventRegistrationCode
-    }
-  }
-  if (allowOwner) {
-    query.__ALLOW_OWNER = true
-  }
-  // not good, just use it as example
-  if (user.hasExcludedFields) {
-    query.__EXCLUDED_FIELDS = user.getExcludedFields(required)
-  }
-  query.__LOGIN_SUBJECT_CODE = user.loginSubjectCode
-  return query
-}
-
-;// ./lib/helpers/authorize/index.js
-
-
-;// external "bwip-js"
-const external_bwip_js_namespaceObject = require("bwip-js");
-;// ./lib/helpers/bwipJsHelper/toDataUrlInBrowser.js
-
-
-function toDataUrlInBrowser({ config = {}, type = 'image/png' }) {
-  const canvas = document.createElement('canvas')
-  external_bwip_js_namespaceObject.toCanvas(canvas, {
-    bcid: 'qrcode',
-    text: '',
-    ...config
-  })
-  return canvas.toDataURL(type)
-}
-
-/* harmony default export */ const bwipJsHelper_toDataUrlInBrowser = ({
-  toDataUrlInBrowser
-});
-
-
-;// ./lib/helpers/bwipJsHelper/index.js
-
-
-const bwipJsHelper = {
-  toDataUrlInBrowser: toDataUrlInBrowser
-}
-
-;// ./lib/helpers/calculateAge/calculateAge.js
-function calculateAge(timestamp, reference) {
-  const birthDate = new Date(timestamp)
-  const refDate = reference ? new Date(reference) : new Date()
-  // Validate inputs
-  if (isNaN(birthDate.getTime())) {
-    return null
-  }
-  if (isNaN(refDate.getTime())) {
-    return null
-  }
-  if (birthDate > refDate) {
-    return null
-  }
-
-  // Calculate raw difference
-  let age = refDate.getFullYear() - birthDate.getFullYear()
-  const monthDiff = refDate.getMonth() - birthDate.getMonth()
-
-  // Adjust if birthday hasn't occurred yet this year
-  if (monthDiff < 0 || (monthDiff === 0 && refDate.getDate() < birthDate.getDate())) {
-    age--
-  }
-
-  return age
-}
-
-;// ./lib/helpers/calculateAge/index.js
-
-
-;// ./lib/helpers/changeCreatorOwner/changeCreatorOwner.js
-function changeCreatorOwner(that, { source, target }) {
-  if (that.meta) {
-    if (!that.meta.creator || that.meta.creator === source.getId()) {
-      that.meta.creator = target.getId()
-    }
-    if (!that.meta.owner || that.meta.owner === source.getId()) {
-      that.meta.owner = target.getId()
-    }
-  } else {
-    if (!that.creator || that.creator === source.getId()) {
-      that.creator = target.getId()
-    }
-    if (!that.owner || that.owner === source.getId()) {
-      that.owner = target.getId()
-    }
-  }
-  return that
-}
-
-;// ./lib/helpers/changeCreatorOwner/index.js
-
-
-;// ./lib/helpers/isConvertibleToNumber/isConvertibleToNumber.js
-function isConvertibleToNumber(value) {
-  return value !== null
-    && value !== undefined
-    && typeof value !== 'boolean'
-    && String(value).trim() !== ''
-    && !isNaN(Number(value))
-}
-
-;// ./lib/helpers/getValueByKeys/getValueByKeys.js
-// keys can be array or object or string
-function getValueByKeys_getValueByKeys(keys, data) {
-  let _keys = keys
-  let _data = data
-  if (typeof keys === 'string') {
-    _keys = _keys.split('.')
-  }
-  if (!Array.isArray(keys) && typeof keys === 'object') {
-    const { keys: keyArr, obj } = keys
-    _keys = keyArr
-    _data = obj
-  }
-  if (_keys.length === 0) {
-    return _data
-  }
-  const firstKey = _keys.shift()
-  if (_data && Object.prototype.hasOwnProperty.call(_data, firstKey)) {
-    return getValueByKeys_getValueByKeys(_keys, _data[firstKey])
-  }
-  if (_data && firstKey) {
-    if (_keys.length > 0) {
-      return getValueByKeys_getValueByKeys(_keys, _data[firstKey])
-    }
-    return _data[firstKey]
-  }
-  return _data
-}
-/* harmony default export */ const getValueByKeys = ({
-  getValueByKeys: getValueByKeys_getValueByKeys
-});
-
-
-;// ./lib/helpers/getValueByKeys/index.js
-
-
-;// ./lib/models/apiResponse/apiResponse.js
-class ApiResponse {
-  constructor(options = {}) {
-    options = options || {}
-    this._data = options.data || options._data || []
-    this.err = options.err
-    this.isNew = options.isNew || false
-    this.message = options.message
-    this.total = options.total || 0
-    this._instanceBuilder = options._instanceBuilder
-  }
-
-  static init(options = {}) {
-    if (options instanceof this) {
-      return options
-    }
-    const instance = new this(options)
-    return instance
-  }
-  static get _classname() {
-    return 'ApiResponse'
-  }
-  static get _superclass() {
-    return 'ApiResponse'
-  }
-
-  // getters
-  get data() {
-    if (this._instanceBuilder && (typeof this._instanceBuilder === 'function')) {
-      return this._data.map(this._instanceBuilder)
-    }
-    return this._data
-  }
-}
-
-
-
-;// ./lib/models/apiResponse/makeApiResponse.js
-
-
-function makeApiResponse({ repo, result }) {
-  return ApiResponse.init({
-    ...result,
-    _instanceBuilder: (i) => {
-      return repo.init(i)
-    }
-  })
-}
-
-
-
-;// ./lib/models/apiResponse/index.js
-
-
-
-
-
-;// ./lib/models/awsStsS3Client/awsStsS3Client.js
-class AwsStsS3Client {
-  constructor(options) {
-    options = options || {}
-
-    this.expiration = options.expiration || null
-    this.s3Client = options.s3Client || null
-    this.getIdToken = options.getIdToken
-    this.region = options.region || 'ap-east-1'
-    this.roleArn = options.roleArn
-    this.roleSessionName = options.roleSessionName || 'web-identity-session'
-    this.durationSession = options.durationSession || 3600
-    this.awsClientSts = options.awsClientSts
-    this.awsClientS3 = options.awsClientS3
-  }
-
-  static dummyData() {
-    return {
-      getIdToken: () => 'mock-web-identity-token',
-      roleArn: 'arn:aws:iam::846252828949:role/oidcS3Jccpa',
-      awsClientSts: {
-        STSClient: class {},
-        AssumeRoleWithWebIdentityCommand: class {}
-      },
-      awsClientS3: {
-        S3Client: class {},
-        PutObjectCommand: class {},
-        GetObjectCommand: class {},
-        DeleteObjectCommand: class {}
-      }
-    }
-  }
-
-  static init(options = {}) {
-    if (options instanceof this) {
-      return options
-    }
-    try {
-      const instance = new this(options)
-      if (!instance.isValid) {
-        return null
-      }
-      return instance
-    } catch (error) {
-      return null
-    }
-  }
-
-  get isExpired() {
-    if (!this.expiration)
-      return true
-    const now = new Date()
-    const bufferMs = 1 * 60 * 1000 // 一分钟缓冲
-    return now >= new Date(this.expiration.getTime() - bufferMs)
-  }
-
-  get isValid() {
-    if (!this.getIdToken) {
-      throw new Error('Missing required configuration: getIdToken function')
-    }
-    if (!this.roleArn) {
-      throw new Error('Missing required configuration: roleArn')
-    }
-    if (!this.awsClientSts) {
-      throw new Error('Missing required AWS awsClientSts client configuration')
-    }
-    if (!this.awsClientSts.STSClient) {
-      throw new Error('Missing STSClient in AWS awsClientSts client configuration')
-    }
-    if (!this.awsClientSts.AssumeRoleWithWebIdentityCommand) {
-      throw new Error('Missing AssumeRoleWithWebIdentityCommand in AWS awsClientSts client configuration')
-    }
-    if (!this.awsClientS3) {
-      throw new Error('Missing required AWS awsClientS3 client configuration')
-    }
-
-    const requiredS3Components = [
-      'S3Client',
-      'PutObjectCommand',
-      'GetObjectCommand',
-      'DeleteObjectCommand'
-    ]
-
-    for (const component of requiredS3Components) {
-      if (!this.awsClientS3[component]) {
-        throw new Error(`Missing ${component} in AWS awsClientS3 client configuration`)
-      }
-    }
-
-    return true
-  }
-
-  async refreshCredentials() {
-    try {
-      const webIdentityToken = await this.getIdToken()
-      if (!webIdentityToken) {
-        throw new Error('getIdToken function returned empty or invalid token')
-      }
-
-      const stsClient = new this.awsClientSts.STSClient({ region: this.region })
-
-      const stsResponse = await stsClient.send(
-        new this.awsClientSts.AssumeRoleWithWebIdentityCommand({
-          RoleArn: this.roleArn,
-          RoleSessionName: this.roleSessionName,
-          WebIdentityToken: await this.getIdToken(),
-          DurationSeconds: this.durationSession,
-        })
-      )
-
-      const credentials = stsResponse.Credentials
-      if (!credentials) {
-        throw new Error('No credentials returned from awsClientSts')
-      }
-
-      this.expiration = credentials.Expiration
-
-      this.s3Client = new this.awsClientS3.S3Client({
-        region: this.region,
-        credentials: {
-          accessKeyId: credentials.AccessKeyId,
-          secretAccessKey: credentials.SecretAccessKey,
-          sessionToken: credentials.SessionToken,
-        }
-      })
-
-      return this
-    } catch (error) {
-      throw new Error(`Failed to refresh credentials: ${error.message}`)
-    }
-  }
-
-  async getS3Client() {
-    if (this.isExpired || !this.s3Client) {
-      await this.refreshCredentials()
-    }
-    return this.s3Client
-  }
-
-  async putObject(params) {
-    try {
-      const client = await this.getS3Client()
-      const command = new this.awsClientS3.PutObjectCommand(params)
-      await client.send(command)
-      const fileArr = params.Key.split('/')
-      return {
-        url: `https://s3.${this.region}.amazonaws.com/${params.Bucket}/${params.Key}`,
-        filename: fileArr.pop(),
-        folder: params.Bucket,
-        subFolders: fileArr
-      }
-    } catch (error) {
-      throw new Error(`Failed to put object: ${error.message}`)
-    }
-  }
-
-  async getObject(params) {
-    try {
-      const client = await this.getS3Client()
-      const command = new this.awsClientS3.GetObjectCommand(params)
-      const response = await client.send(command)
-      return {
-        body: response.Body,
-        contentType: response.ContentType,
-        lastModified: response.LastModified,
-        contentLength: response.ContentLength,
-      }
-    } catch (error) {
-      throw new Error(`Failed to get object: ${error.message}`)
-    }
-  }
-
-  async deleteObject(params) {
-    try {
-      const client = await this.getS3Client()
-      const command = new this.awsClientS3.DeleteObjectCommand(params)
-      await client.send(command)
-      return true
-    } catch (error) {
-      throw new Error(`Failed to delete object: ${error.message}`)
-    }
-  }
-}
-
-
-
-;// ./lib/models/awsStsS3Client/index.js
-
-
-
-
-;// ./lib/helpers/objectHelper/objectHelper.js
-const objectHelper = {
-  get(obj, path) {
-    const parts = path.split('.')
-    return parts.reduce((acc, part) => {
-      if (part.endsWith('[]')) {
-        // 处理数组遍历
-        const key = part.slice(0, -2) // 去掉 '[]' 得到属性名
-        if (Array.isArray(acc[key])) {
-          return acc[key] // 返回整个数组
-        }
-        return [] // 如果不是数组，返回空数组
-      }
-      if (part.includes('[') && part.includes(']')) {
-        // 处理数组索引
-        const arrayMatch = part.match(/(\w+)\[(\d+)\]/)
-        if (arrayMatch) {
-          const key = arrayMatch[1]
-          const index = arrayMatch[2]
-          return acc && acc[key] && acc[key][index]
-        }
-      } else if (acc && Array.isArray(acc)) {
-        // 如果当前值是数组，提取每个对象的指定属性
-        return acc.map((item) => item[part])
-      } else {
-        // 处理普通属性
-        return acc && acc[part]
-      }
-    }, obj)
-  },
-  isPlainObject,
-  merge,
-  set(obj, path, value) {
-    const parts = path.split('.')
-    let current = obj
-
-    // 处理所有中间部分
-    for (let i = 0; i < parts.length - 1; i++) {
-      const part = parts[i]
-      let key, index
-
-      // 检查是否是数组索引格式，如key[0]
-      const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/)
-      if (arrayMatch) {
-        key = arrayMatch[1]
-        index = Number.parseInt(arrayMatch[2], 10)
-        // 确保当前层级的数组存在
-        if (!current[key] || !Array.isArray(current[key])) {
-          current[key] = []
-        }
-        // 扩展数组到足够大
-        while (current[key].length <= index) {
-          current[key].push(undefined)
-        }
-        // 如果当前位置未定义或为null，初始化为对象
-        if (current[key][index] == null) {
-          current[key][index] = {}
-        }
-        current = current[key][index]
-      } else {
-        // 处理普通属性
-        if (!current[part]) {
-          current[part] = {}
-        }
-        current = current[part]
-      }
-    }
-
-    // 处理最后一部分
-    const lastPart = parts[parts.length - 1]
-    const arrayMatch = lastPart.match(/^(\w+)\[(\d+)\]$/)
-    if (arrayMatch) {
-      const key = arrayMatch[1]
-      const index = Number.parseInt(arrayMatch[2], 10)
-      // 确保数组存在
-      if (!current[key] || !Array.isArray(current[key])) {
-        current[key] = []
-      }
-      // 扩展数组到所需索引
-      while (current[key].length <= index) {
-        current[key].push(undefined)
-      }
-      current[key][index] = value
-    } else {
-      current[lastPart] = value
-    }
-  }
-}
-
-function isPlainObject(value) {
-  return (
-    value !== null
-    && typeof value === 'object'
-    && !Array.isArray(value) &&
-    !(value instanceof Date) &&
-    !(value instanceof RegExp) &&
-    // Optional: exclude other built-in objects
-    Object.prototype.toString.call(value) === '[object Object]'
-  )
-}
-
-function merge(target, ...sources) {
-  if (!sources.length)
-    return target
-
-  const source = sources.shift() // 取出第一个源对象
-
-  if (_isObject(target) && _isObject(source)) {
-    for (const key in source) {
-      if (_isObject(source[key])) {
-        if (!target[key]) {
-          // 如果目标对象没有该属性，创建一个空对象
-          target[key] = {}
-        }
-        // 递归合并
-        merge(target[key], source[key])
-      } else {
-        // 直接覆盖
-        target[key] = source[key]
-      }
-    }
-  }
-
-  // 继续合并剩余的源对象
-  return merge(target, ...sources)
-}
-
-function _isObject(obj) {
-  return obj && typeof obj === 'object' && !Array.isArray(obj)
-}
-
-
-
-;// ./lib/helpers/objectHelper/index.js
-
-
-
-
-;// ./lib/models/keyValueObject/keyValueObject.js
-
-
-class keyValueObject_KeyValueObject {
-  constructor(options = {}) {
-    options = options || {}
-    this.key = options.key || null
-    this.value = (typeof options.value !== 'undefined') ? options.value : ''
-  }
-
-  // Class methods
-  static init(options = {}) {
-    if (options instanceof this) {
-      return options
-    }
-    const instance = new this(options)
-    return instance.isValid ? instance : null
-  }
-  static initFromArray(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.map((a) => this.init(a))
-    }
-    return []
-  }
-  static initOnlyValidFromArray(arr = []) {
-    return this.initFromArray(arr).filter((i) => i)
-  }
-  static get _classname() {
-    return 'KeyValueObject'
-  }
-  static get _superclass() {
-    return 'KeyValueObject'
-  }
-
-  static addItem(arr, key, value) {
-    arr.push(this.init({ key, value }))
-  }
-  static addRecord(arr = [], key, value) {
-    if (!this.hasKeyValue(arr, key, value)) {
-      arr.push(this.init({ key, value }))
-    }
-    return arr
-  }
-  static appendRecord(arr = [], key, value) {
-    return arr.map((item) => {
-      if (this.sameKey(item, key)) {
-        item.value = [...item.value, ...value]
-      }
-      return item
-    })
-  }
-  static appendValueArray(arr = [], key, value) {
-    return arr.map((item) => {
-      if (this.sameKey(item, key)) {
-        item.value = [...item.value, ...value]
-      }
-      return item
-    })
-  }
-  static foundByKey(arr = [], key) {
-    const found = arr.find((m) => {
-      return this.sameKey(m, key)
-    })
-    return found || null
-  }
-  static foundValueByKey(arr = [], key) {
-    const found = this.foundByKey(arr, key)
-    return found ? found.value : null
-  }
-  static fromObject(options = {}) {
-    return Object.keys(options).reduce((acc, key) => {
-      acc.push(this.init({ key, value: options[key] }))
-      return acc
-    }, [])
-  }
-  static getValueByKey(arr = [], key) {
-    return this.foundValueByKey(arr, key)
-  }
-  static getMetadataValueByKeyAsArray(arr = [], key) {
-    const _value = this.getValueByKey(arr, key)
-    if (!_value) {
-      return []
-    }
-    if (objectHelper.isPlainObject(_value)) {
-      return Object.keys(_value).reduce((acc, key) => {
-        acc.push({ key, value: _value[key] })
-        return acc
-      }, [])
-    }
-    return _value
-  }
-  static getValueByKeyFromArray(arr = [], key) {
-    if (arr.length === 0) {
-      return null
-    }
-    const firstArr = arr.shift()
-    const found = firstArr.find((i) => {
-      return this.sameKey(i, key)
-    })
-    if (found && found.value) {
-      return found.value
-    }
-    return this.getValueByKeyFromArray(arr, key)
-  }
-  static getValuesByKey(arr = [], key) {
-    return arr.reduce((acc, item) => {
-      if (this.sameKey(item, key)) {
-        acc.push(item.value)
-      }
-      return acc
-    }, [])
-  }
-  static hasKeyValue(arr = [], key, value) {
-    if (typeof value === 'undefined') {
-      return arr.filter((item) => this.sameKey(item, key)).length > 0
-    }
-    return arr.filter((item) => (this.sameKey(item, key) && _isSame(item.value, value))).length > 0
-  }
-  static insertOrUpdateRecord(arr = [], key, value) {
-    let copy = [...arr]
-    if (!this.hasKeyValue(arr, key)) {
-      copy.push(this.init({ key, value }))
-    } else {
-      copy = this.updateRecord(arr, key, value)
-    }
-    return copy
-  }
-  static keys(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.reduce((acc, item) => {
-        acc.push(item.key)
-        return acc
-      }, [])
-    }
-    return []
-  }
-  static merge(toArr, fromArr) {
-    (fromArr || []).map((from) => {
-      const found = toArr.find((to) => {
-        return to.key === from.key
-      })
-      if (found) {
-        found.value = _mergeValues(from.value, found.value)
-      } else {
-        toArr.push(from)
-      }
-    })
-    return toArr
-  }
-  static removeByKey(arr, key) {
-    return arr.reduce((acc, item) => {
-      if (!this.sameKey(item, key)) {
-        acc.push(item)
-      }
-      return acc
-    }, [])
-  }
-  static sameKey(item, key) {
-    if (item) {
-      return _isSame(item.key, key)
-    }
-    return false
-  }
-  static toObject(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.reduce((acc, item) => {
-        acc[item.key] = item.value
-        return acc
-      }, {})
-    }
-    return {}
-  }
-  static toString(arr = [], delimiter = '; ') {
-    if (Array.isArray(arr)) {
-      return arr.reduce((acc, item) => {
-        acc.push(`${item.key}: ${item.value}`)
-        return acc
-      }, []).join(delimiter)
-    }
-    return ''
-  }
-  static updateRecord(arr = [], key, value) {
-    return arr.map((item) => {
-      if (this.sameKey(item, key)) {
-        return {
-          ...item,
-          value
-        }
-      }
-      return item
-    })
-  }
-  static updateOrInsertRecord(arr = [], key, value) {
-    return this.insertOrUpdateRecord(arr, key, value)
-  }
-  static updateRecordsFromArray(arr = [], updateArr = []) {
-    if (Array.isArray(arr) && Array.isArray(updateArr)) {
-      const obj1 = this.toObject(arr)
-      const obj2 = this.toObject(updateArr)
-      return this.fromObject({
-        ...obj1,
-        ...obj2
-      })
-    }
-    return []
-  }
-  static values(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.reduce((acc, item) => {
-        acc.push(item.value)
-        return acc
-      }, [])
-    }
-    return []
-  }
-
-  // getters
-  get isValid() {
-    return !!this.key
-  }
-
-  get toObject() {
-    const obj = {}
-    if (this.isValid) {
-      obj[this.key] = this.value
-    }
-    return obj
-  }
-}
-
-function _mergeValues(existingValue, newValue) {
-  if (existingValue === undefined)
-    return newValue
-
-  // Handle arrays by concatenating
-  if (Array.isArray(existingValue) && Array.isArray(newValue)) {
-    return [...new Set([...existingValue, ...newValue])]
-  }
-
-  // Handle objects by merging
-  if (typeof existingValue === 'object' && typeof newValue === 'object'
-    && !Array.isArray(existingValue) && !Array.isArray(newValue)) {
-    return { ...existingValue, ...newValue }
-  }
-
-  // // Handle numbers by adding
-  // if (typeof existingValue === 'number' && typeof newValue === 'number') {
-  //   return existingValue
-  // }
-
-  // // Handle strings by concatenating
-  // if (typeof existingValue === 'string' && typeof newValue === 'string') {
-  //   return existingValue
-  // }
-
-  // Default: use the new value
-  return newValue
-}
-
-function _isSame(key1, key2) {
-  return key1 === key2
-}
-
-
-
-;// ./lib/models/keyValueObject/index.js
-
-
-
-
-;// ./lib/helpers/stringFormatter/stringFormatter.js
-function stringFormatter(str, delimiter = '_') {
-  if (str === null || typeof str === 'undefined' || typeof str.toString === 'undefined') {
-    return null
-  }
-  return str.toString()
-    .trim()
-    .toUpperCase()
-    .replace('-', delimiter)
-    .replace(' ', delimiter)
-}
-
-
-
-;// ./lib/models/metadata/metadata.js
-
-
-
-const DELIMITER = '_'
-
-class Metadata extends keyValueObject_KeyValueObject {
-  static init(options = {}) {
-    if (options instanceof this) {
-      return options
-    }
-    const instance = new this({
-      ...options,
-      key: stringFormatter(options.key, DELIMITER),
-    })
-    return instance.isValid ? instance : null
-  }
-  static get _classname() {
-    return 'Metadata'
-  }
-
-  static merge(toArr, fromArr) {
-    (fromArr || []).map((from) => {
-      const found = toArr.find((to) => {
-        return metadata_isSame(to.key, from.key)
-      })
-      if (found) {
-        found.value = metadata_mergeValues(from.value, found.value)
-      } else {
-        toArr.push(from)
-      }
-    })
-    return toArr
-  }
-  static sameKey(item, key) {
-    return metadata_isSame(item.key, key)
-  }
-}
-
-function metadata_isSame(key1, key2) {
-  return stringFormatter(key1, DELIMITER) === stringFormatter(key2, DELIMITER)
-}
-
-function metadata_mergeValues(existingValue, newValue) {
-  if (existingValue === undefined)
-    return newValue
-
-  // Handle arrays by concatenating
-  if (Array.isArray(existingValue) && Array.isArray(newValue)) {
-    return [...new Set([...existingValue, ...newValue])]
-  }
-
-  // Handle objects by merging
-  if (typeof existingValue === 'object' && typeof newValue === 'object'
-    && !Array.isArray(existingValue) && !Array.isArray(newValue)) {
-    return { ...existingValue, ...newValue }
-  }
-
-  // // Handle numbers by adding
-  // if (typeof existingValue === 'number' && typeof newValue === 'number') {
-  //   return existingValue
-  // }
-
-  // // Handle strings by concatenating
-  // if (typeof existingValue === 'string' && typeof newValue === 'string') {
-  //   return existingValue
-  // }
-
-  // Default: use the new value
-  return newValue
-}
-
-
-
-;// ./lib/models/metadata/index.js
-
-
-
-
-;// ./lib/models/trackedEntity/trackedEntity.js
-
-
-class TrackedEntity {
-  constructor(options = {}) {
-    options = options || {}
-    const timestamp = Date.now()
-    this.meta = {
-      active: options.meta?.active ?? options.active ?? true,
-      created: options.meta?.created ?? (options.created
-        ? new Date(options.created).getTime()
-        : timestamp),
-      creator: options.meta?.creator ?? options.creator ?? '',
-      deleted: options.meta?.deleted ?? options.deleted ?? false,
-      modified: options.meta?.modified ?? (options.modified
-        ? new Date(options.modified).getTime()
-        : timestamp),
-      owner: options.meta?.owner ?? options.owner ?? '',
-    }
-
-    // if (trackFlat) {
-    //   Object.assign(this, _tracking)
-    // } else {
-    //   this.meta = { ..._tracking, ...options.meta }
-    // }
-  }
-
-  // Class methods
-  static get _classname() {
-    return 'TrackedEntity'
-  }
-  static get _superclass() {
-    return 'TrackedEntity'
-  }
-
-  static init(options = {}) {
-    return init(this, options)
-  }
-  static initFromArray(arr = []) {
-    return initFromArray(this, arr)
-  }
-  static initOnlyValidFromArray(arr = []) {
-    return initOnlyValidFromArray(this, arr)
-  }
-  // static nest(entity) {
-  //   const { active, created, creator, deleted, modified, owner, ...rest } = entity
-  //   return { ...rest, meta: { active, created, creator, deleted, modified, owner } }
-  // }
-
-  // getters
-  get __valid() {
-    return {}
-  }
-  get isValid() {
-    return !!this
-  }
-  get active() {
-    return this.meta?.active ?? this.active
-  }
-  get created() {
-    return this.meta?.created ?? this.created
-  }
-  get creator() {
-    return this.meta?.creator ?? this.creator
-  }
-  get deleted() {
-    return this.meta?.deleted ?? this.deleted
-  }
-  get modified() {
-    return this.meta?.modified ?? this.modified
-  }
-  get owner() {
-    return this.meta?.owner ?? this.owner
-  }
-  changeCreatorOwner({ source, target }) {
-    return changeCreatorOwner(this, { source, target }).setModified()
-  }
-  delete() {
-    return this.setDeleted()
-  }
-  setActive() {
-    if (this.meta) {
-      this.meta.active = true
-    } else {
-      this.active = true
-    }
-    return this
-  }
-  setDeleted() {
-    if (this.meta) {
-      this.meta.deleted = true
-    } else {
-      this.deleted = true
-    }
-    return this
-  }
-  setModified() {
-    const timestamp = Date.now()
-    if (this.meta) {
-      this.meta.modified = timestamp
-    } else {
-      this.modified = timestamp
-    }
-    return this
-  }
-  setOwner(owner) {
-    if (!owner) {
-      return this
-    }
-    if (this.meta) {
-      this.meta.owner = owner
-    } else {
-      this.owner = owner
-    }
-    return this
-  }
-  unsetActive() {
-    if (this.meta) {
-      this.meta.active = false
-    } else {
-      this.active = false
-    }
-    return this
-  }
-  unsetDeleted() {
-    if (this.meta) {
-      this.meta.deleted = false
-    } else {
-      this.deleted = false
-    }
-    return this
-  }
-
-  update(update) {
-    if (update.meta) {
-      this.meta = { ...this.meta, ...update.meta }
-    }
-    return this.setModified()
-  }
-}
-
-;// ./lib/models/trackedEntity/index.js
-
- // Explicit named export (optional)
-
-;// ./lib/models/pushEnvelope/pushEnvelope.js
-
-
-
-
-
-class PushEnvelope extends TrackedEntity {
-  constructor(options) {
-    options = options || {}
-    super(options)
-
-    this.id = options.id
-    this.body = options.body
-    this.data = options.data
-    this.dirty = options.dirty
-    this.metadata = Metadata.initOnlyValidFromArray(options.metadata)
-    this.remarks = keyValueObject_KeyValueObject.initOnlyValidFromArray(options.remarks)
-    this.threadID = options.threadID
-    this.title = options.title
-  }
-  static get _classname() {
-    return 'PushEnvelope'
-  }
-  static get _superclass() {
-    return 'PushEnvelope'
-  }
-  static init(options = {}) {
-    return init(this, options)
-  }
-
-  get _classname() {
-    return 'PushEnvelope'
-  }
-
-  get _superclass() {
-    return 'PushEnvelope'
-  }
-
-  get isValid() {
-    return super.isValid && this.data
-  }
-}
-
-;// ./lib/models/pushEnvelope/index.js
-
-
-;// ./lib/models/qMeta/qMeta.js
-
-
-const updateAllowedProps = [
-  'attributes',
-  'ref'
-]
-
-class QMeta {
-  constructor(options = {}) {
-    options = options || {}
-    this.attributes = keyValueObject_KeyValueObject.initOnlyValidFromArray(options.attributes)
-    this.ref = options.ref || {}
-  }
-
-  static get _classname() {
-    return 'QMeta'
-  }
-  static get _superclass() {
-    return 'QMeta'
-  }
-
-  // Class methods
-  static init(options = {}) {
-    if (options instanceof QMeta) {
-      return options
-    }
-    return new QMeta(options)
-  }
-
-  // instance methods
-  addAttribute(obj) {
-    const kvObject = keyValueObject_KeyValueObject.init(obj)
-    if (!kvObject) {
-      throw new Error('invalid meta attribute')
-    }
-    this.attributes.push(kvObject)
-    return this
-  }
-
-  update(obj) {
-    Object.keys(obj).forEach((key) => {
-      if (updateAllowedProps.includes(key)) {
-        if (key === 'attributes') {
-          this[key] = keyValueObject_KeyValueObject.initOnlyValidFromArray(obj[key])
-        } else {
-          this[key] = obj[key]
-        }
-      }
-    })
-    return this
-  }
-}
-
-
-
-;// ./lib/models/qMeta/index.js
-
-
-
-
-;// ./lib/models/repo/repo.js
-
-
-class Repo {
-  constructor(options) {
-    options = options || {}
-    this.model = options.model
-    this._sharedOptions = options._sharedOptions // { session: this.dbTransaction }
-    this._queryOptions = options._queryOptions
-    this._saveOptions = options._saveOptions
-    this._Class = options._constructor && options._constructor._Class
-      ? options._constructor._Class
-      : null
-  }
-  static init(options = {}) {
-    return init(this, options)
-  }
-  static get _classname() {
-    return 'Repo'
-  }
-  static get _superclass() {
-    return 'Repo'
-  }
-
-  get _classname() {
-    return 'Repo'
-  }
-
-  get _superclass() {
-    return 'Repo'
-  }
-
-  get isValid() {
-    return this.model
-      && (typeof this.model.deleteOne === 'function')
-      && (typeof this.model.findAll === 'function')
-      && (typeof this.model.saveOne === 'function')
-  }
-
-  get queryOptions() {
-    return {
-      ...this._sharedOptions,
-      ...this._queryOptions,
-    }
-  }
-
-  get saveOptions() {
-    return {
-      ...this._sharedOptions,
-      ...this._saveOptions,
-    }
-  }
-
-  init(options) {
-    if (this._Class && typeof this._Class.init === 'function') {
-      return this._Class.init(options)
-    }
-    return options
-  }
-
-  async deleteOne({ id }) {
-    try {
-      const result = await this.model.deleteOne({ _id: id })
-      return {
-        ...result, // { message: 'ok', total }
-        isNew: false,
-        data: []
-      }
-    } catch (err) {
-      throw err
-    }
-  }
-
-  // systemLog is optional
-  findAll({ config = {}, query, systemLog }) {
-    const log = _makeLog({
-      systemLog,
-      label: 'REPO_READ',
-      message: `fn ${this._classname}.prototype.findAll`,
-      input: [{ query: { ...query }, systemLog: { ...systemLog } }]
-    })
-    const queryOptions = {
-      ...this.queryOptions,
-      ...config,
-    }
-    return new Promise((resolve, reject) => {
-      this.model.findAll(query, queryOptions, (err, data, total) => {
-        if (err) {
-          log({ level: 'warn', output: err.toString() })
-          reject(err)
-        } else {
-          const result = {
-            isNew: false,
-            data,
-            total: total || data.length
-          }
-          log({ level: 'info', output: { ...result } })
-          resolve(result)
-        }
-      })
-    })
-  }
-
-  findOne({ config = {}, query, systemLog }) {
-    const log = _makeLog({
-      systemLog,
-      label: 'REPO_READ',
-      message: `fn ${this._classname}.prototype.findOne`,
-      input: [{ query: { ...query }, systemLog: { ...systemLog } }]
-    })
-    const queryOptions = {
-      ...this.queryOptions,
-      ...config,
-    }
-    return new Promise((resolve, reject) => {
-      this.model.findAll(query, queryOptions, (err, data) => {
-        if (err) {
-          reject(err)
-        } else if (data.length === 1) {
-          const result = {
-            isNew: false,
-            data,
-            total: 1
-          }
-          log({ level: 'info', output: { ...result } })
-          resolve(result)
-        } else if (data.length === 0) {
-          reject(new Error('record not found'))
-        } else {
-          reject(new Error('more than one is found'))
-        }
-      })
-    })
-      .catch((err) => {
-        log({ level: 'warn', output: err.toString() })
-        throw err
-      })
-  }
-
-  saveAll({ config = {}, docs, systemLog }) {
-    let isNew
-    const log = _makeLog({
-      systemLog,
-      label: 'REPO_WRITE',
-      message: `fn ${this._classname}.prototype.saveAll`,
-      input: [{ config, docs: [...docs], systemLog: { ...systemLog } }]
-    })
-    const promise = typeof this.model.saveAll === 'function'
-      ? this.model.saveAll({ config, docs })
-      : _saveAll({ config, docs, service: this })
-    // : Promise.all(docs.map(async (doc) => {
-    //     if (doc) {
-    //       const result = await this.saveOne({ config, doc })
-    //       isNew = result.isNew
-    //       const _data = result._data || result.data
-    //       return _data[0]
-    //     }
-    //     return null
-    //   }))
-    return promise.then((savedData) => {
-      if (savedData.length !== 1)
-        isNew = null
-      const result = {
-        data: savedData,
-        isNew,
-        total: savedData.length
-      }
-      log({ level: 'info', output: { ...result } })
-      return result
-    }).catch((err) => {
-      log({ level: 'warn', output: err.toString() })
-      throw err
-    })
-  }
-
-  saveOne({ config = {}, doc, systemLog }) {
-    const log = _makeLog({
-      systemLog,
-      label: 'REPO_WRITE',
-      message: `fn ${this._classname}.prototype.saveOne`,
-      input: [{ config, doc: { ...doc }, systemLog: { ...systemLog } }]
-    })
-    const saveOptions = {
-      ...this.saveOptions,
-      ...config,
-    }
-    return new Promise((resolve, reject) => {
-      this.model.saveOne(doc, saveOptions, (err, result) => {
-        if (err) {
-          log({ level: 'warn', output: err.toString() })
-          reject(err)
-        } else {
-          log({ level: 'info', output: { ...result } })
-          resolve(result)
-        }
-      })
-    })
-  }
-}
-
-function _makeLog({ systemLog, label, message: message1, input } = {}) {
-  return ({ level, messgae: massage2, output } = {}) => {
-    if (systemLog && systemLog.systemLogHelper) {
-      systemLog.systemLogHelper.log({
-        batchId: systemLog.batchId,
-        label,
-        level,
-        message: massage2 || message1,
-        data: {
-          payload: {
-            input,
-            output
-          }
-        }
-      })
-    }
-  }
-}
-
-async function _saveAll({ config = {}, docs, service }) {
-  let _result = null
-  if (config.session || service.saveOptions.session) {
-    _result = await pMap(docs, async (doc) => {
-      if (doc) {
-        const result = await service.saveOne({ config, doc })
-        // isNew = result.isNew
-        const _data = result._data || result.data
-        return _data[0]
-      }
-      return null
-    }, { concurrency: 1 })
-  } else {
-    _result = await Promise.all(docs.map(async (doc) => {
-      if (doc) {
-        const result = await service.saveOne({ config, doc })
-        // isNew = result.isNew
-        const _data = result._data || result.data
-        return _data[0]
-      }
-      return null
-    }))
-  }
-  return _result
-}
-
-
-
-;// ./lib/models/repo/index.js
-
-
-
-
-;// ./lib/models/service/service.js
-
-
-
-class Service {
-  constructor({ repo }) {
-    this.repo = repo
-  }
-
-  static get _classname() {
-    return 'Service'
-  }
-  static get _superclass() {
-    return 'Service'
-  }
-
-  async deleteOne({ id }) {
-    const result = await this.repo.deleteOne({ id })
-    return makeApiResponse({
-      repo: this.repo,
-      result
-    })
-    // return this.repo.delete({ id })
-    //   .catch(() => {
-    //     throw new Error(`Not found for query: ${id}`)
-    //   })
-  }
-
-  async findAll({ config = {}, query = {}, systemLog } = {}) {
-    const result = await this.repo.findAll({ config, query, systemLog })
-    return makeApiResponse({
-      repo: this.repo,
-      result
-    })
-  }
-
-  async findOne({ config = {}, query = {}, systemLog } = {}) {
-    const result = await this.repo.findOne({ config, query, systemLog })
-    return makeApiResponse({
-      repo: this.repo,
-      result
-    })
-  }
-
-  init(options) {
-    return this.repo.init(options)
-  }
-  initFromArray(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.map((a) => this.init(a))
-    }
-    return []
-  }
-  initOnlyValidFromArray(arr = []) {
-    return this.initFromArray(arr).filter((i) => i)
-  }
-
-  async saveAll({ config = {}, docs = [], systemLog } = {}) {
-    const copies = docs.map((doc) => {
-      return config.skipInit ? doc : this.init(doc)
-    })
-    const result = await this.repo.saveAll({ config, docs: copies, systemLog })
-    return makeApiResponse({
-      repo: this.repo,
-      result
-    })
-  }
-
-  // set skipInit to true if we want to use POST for query
-  async saveOne({ config = {}, doc = {}, systemLog } = {}) {
-    const copy = config.skipInit ? doc : this.init(doc)
-    if (copy) {
-      const result = await this.repo.saveOne({ config, doc: copy, systemLog })
-      return makeApiResponse({
-        repo: this.repo,
-        result
-      })
-    }
-    return {
-      isNew: null,
-      data: [],
-      err: new Error('doc is not a valid instance')
-    }
-  }
-}
-
-function makeService({ repo }) {
-  if (repo === undefined) {
-    throw new Error('repo is required.')
-  }
-  if (repo._superclass !== Repo._superclass) {
-    throw new Error('repo is not an instance of Repo.')
-  }
-  return new Service({ repo })
-}
-
-
-
-;// ./lib/models/service/index.js
-
-
-
-
-;// ./lib/models/status/actionRecord.js
-
-
-class ActionRecord {
-  constructor(options) {
-    options = options || {}
-
-    const { _Actor } = options._constructor || {}
-    this._Actor = _Actor
-
-    this._actor = options._actor
-
-    this.actorCode = typeof options === 'number' ? null : (options.actorCode || null)
-    this.timestamp = typeof options === 'number' ? options : (options.timestamp || null)
-  }
-
-  static get _classname() {
-    return 'ActionRecord'
-  }
-  static get _superclass() {
-    return 'ActionRecord'
-  }
-  static dummyData() {
-    return {
-      timestamp: (new Date()).valueOf(),
-    }
-  }
-  static init(options = {}) {
-    return init(this, options)
-  }
-
-  get _classname() {
-    return 'ActionRecord'
-  }
-
-  get _superclass() {
-    return 'ActionRecord'
-  }
-
-  get actor() {
-    return this._Actor && typeof this._Actor.init === 'function' ? this._Actor.init(this._actor) : this._actor
-  }
-
-  get isValid() {
-    return !!this.timestamp
-  }
-
-  update(update) {
-    if (typeof update === 'number') {
-      this.timestamp = update
-      return this
-    }
-    Object.keys(update).forEach((key) => {
-      this[key] = update[key]
-    })
-    return this
-  }
-}
-
-;// ./lib/models/status/status.js
-
-
-
-const notUpdateAllowedProps = [
-  '_ActionRecord',
-  'created',
-  // 'statusType'
-]
-
-class Status {
-  constructor(options) {
-    options = options || {}
-
-    const { _ActionRecord } = options._constructor || {}
-    this._ActionRecord = _ActionRecord && (_ActionRecord._superclass === ActionRecord._superclass) ? _ActionRecord : ActionRecord
-
-    this.created = this._ActionRecord.init(options.created || { timestamp: (new Date()).valueOf() })
-    // this.statusType = options.statusType || 'Status'
-  }
-
-  static get _classname() {
-    return 'Status'
-  }
-  static get _superclass() {
-    return 'Status'
-  }
-  static dummyData() {
-    return {}
-  }
-  static init(options = {}) {
-    return init(this, options)
-  }
-  static initFromArray(arr = []) {
-    return initFromArray(this, arr)
-  }
-  static initOnlyValidFromArray(arr = []) {
-    return initOnlyValidFromArray(this, arr)
-  }
-
-  get _classname() {
-    return 'Status'
-  }
-  get _superclass() {
-    return 'Status'
-  }
-  get isCreated() {
-    return this.created?.timestamp !== null
-  }
-  get isValid() {
-    return !!this
-  }
-
-  setValue(t, actorCode, key) {
-    const timestamp = t || Date.now()
-    this[key] = this[key] instanceof this._ActionRecord ? this[key].update({ actorCode, timestamp }) : this._ActionRecord.init({ actorCode, timestamp })
-    return this
-  }
-
-  update(update) {
-    Object.keys(update).forEach((key) => {
-      if (!notUpdateAllowedProps.includes(key)) {
-        this[key] = this[key] instanceof this._ActionRecord ? this[key].update(update[key]) : this._ActionRecord.init(update[key])
-      }
-    })
-    return this
-  }
-}
-
-;// ./lib/models/status/statusDocument.js
-
-
-class StatusDocument extends Status {
-  constructor(options) {
-    options = options || {}
-    super(options)
-
-    this.archived = this._ActionRecord.init(options.archived)
-    this.completed = this._ActionRecord.init(options.completed)
-    this.discarded = this._ActionRecord.init(options.discarded)
-    this.drafted = this._ActionRecord.init(options.drafted)
-    // this.statusType = 'StatusDocument'
-  }
-
-  static get _classname() {
-    return 'StatusDocument'
-  }
-  get _classname() {
-    return 'StatusDocument'
-  }
-  get isArchived() {
-    return this.created?.timestamp !== null
-  }
-  get isCompleted() {
-    return this.completed?.timestamp !== null
-  }
-  get isDiscarded() {
-    return this.discarded?.timestamp !== null
-  }
-  get isDrafted() {
-    return this.drafted?.timestamp !== null
-  }
-  get isValid() {
-    return super.isValid
-  }
-  setArchived(value, actorCode) {
-    // const timestamp = value || Date.now()
-    // this.archived = this.archived instanceof this._ActionRecord ? this.archived.update({ actorCode, timestamp }) : this._ActionRecord.init({ actorCode, timestamp })
-    // return this
-    return this.setValue(value, actorCode, 'archived')
-  }
-  setCompleted(value, actorCode) {
-    return this.setValue(value, actorCode, 'completed')
-  }
-  setDiscarded(value, actorCode) {
-    return this.setValue(value, actorCode, 'discarded')
-  }
-  setDrafted(value, actorCode) {
-    return this.setValue(value, actorCode, 'drafted')
-  }
-}
-
-;// ./lib/models/status/index.js
-
-
-
-
-;// ./lib/models/templateCompiler/templateCompilerException.js
-const TEMPLATE_COMPILER_EXCEPTION_TYPE = {
-  argumentEmptyException: 'Argument is empty',
-  argumentFormatException: 'Incorrect number or format of argument',
-  invalidFuntionException: 'Function Name is invalid',
-  invalidRegExpException: 'Invalid regular expression',
-  isNotAFunctionException: 'Is not a function',
-  notExistException: 'Key does not exist',
-  resultEmptyException: 'Result is empty',
-  resultMoreThanOneException: 'More than one result'
-}
-
-class TemplateCompilerException extends Error {
-  constructor(message) {
-    super(message)
-    this.message = message
-  }
-}
-
-
-
-;// ./lib/models/templateCompiler/constants.js
-const _EMPTY = '_EMPTY'
-const _FN_NAMES = [
-  'concatIf',
-  'divide',
-  'eq',
-  'exec',
-  'filterAll',
-  'filterOne',
-  'formatDate',
-  'get',
-  'gt',
-  'gte',
-  'isEmpty',
-  'isNotEmpty',
-  'join',
-  'lt',
-  'lte',
-  'map',
-  'neq',
-  'removeHtml',
-  'sum',
-  'toLowerCase',
-  'toUpperCase',
-]
-const _HIDE = '_HIDE'
-const _NOT_EMPTY = '_NOT_EMPTY'
-const _SELF = '_SELF'
-const TAGS_EJS = ['<%=', '%>']
-const TAGS_HANDLEBAR = ['{{', '}}']
-
-
-
-;// ./lib/models/templateCompiler/helpers/_concatIf.js
-
-
-
-
-function _concatIf(data, args) {
-  if (typeof data !== 'string') {
-    throw new TemplateCompilerException(`_concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the data must be string :${data.join(', ')}`)
-  }
-  if (args.length !== 3) {
-    throw new TemplateCompilerException(`_concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
-  }
-  if (data === null || (typeof data === 'undefined')) {
-    return null
-  }
-  const [condition, success, failover] = args
-  const validConditions = [_EMPTY, _NOT_EMPTY]
-  if (validConditions.includes(condition) || success.length !== 2) {
-    throw new TemplateCompilerException(`concatIf: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException}: ${condition}, ${success}`)
-  }
-  if (data === '' && failover.includes(_HIDE)) {
-    return ''
-  }
-  if (data !== '' && (data !== null || data !== undefined) && failover.includes(_HIDE)) {
-    return `${success[0]}${data}${success[success.length - 1]}`
-  }
-  return failover
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_divide.js
-function _divide(value, divisor) {
-  try {
-    if (Number.isNaN(value)) {
-      return value
-    }
-    return (value / divisor)
-  } catch (e) {
-    throw e
-  }
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_eq.js
-
-
-
-
-function _eq(data, args) {
-  if (args.length !== 3) {
-    throw new TemplateCompilerException(`eq: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
-  }
-  if (data === null || (typeof data === 'undefined')) {
-    return null
-  }
-  if (args.includes(_SELF)) {
-    args = args.map((arg) => {
-      return (arg === _SELF) ? data : arg
-    })
-  }
-  const expected = args[0]
-  return data === expected ? args[1] : args[2]
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_exec.js
-function _exec(data, args) {
-  try {
-    const [methodName, ..._args] = args
-    return data[methodName](..._args)
-  } catch (e) {
-    throw e
-  }
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_filterAll.js
-
-
-
-// const DELIMITER = '~~~'
-
-function _filterAll(data, args) {
-  try {
-    if (!Array.isArray(args) || args.length === 0) {
-      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
-    }
-    if (!Array.isArray(data) || data.length === 0) {
-      return []
-    }
-    if (typeof data[0] === 'object') {
-      return _existObject(data, args)
-    }
-    if (typeof data[0] === 'string' || typeof data[0] === 'number') {
-      return _exist(data, args)
-    }
-    return []
-  } catch (e) {
-    throw e
-  }
-}
-
-function _exist(data, args) {
-  const _args = args.flat()
-  return data.filter((e) => _args.some((arg) => _performOperation(arg, e)))
-}
-
-function _existObject(data, args) {
-  if (args.length === 1) {
-    const arg = args[0]
-    return data.filter((e) => {
-      if (arg.includes('.')) {
-        return getValueByKeys_getValueByKeys(arg.split('.'), e)
-      }
-      return Object.prototype.hasOwnProperty.call(e, arg)
-    })
-  }
-
-  if (args.length > 2) {
-    let res = data
-    for (let i = 0; i < args.length; i += 2) {
-      const group = [args[i], args[i + 1]]
-      res = _existObject(res, group)
-    }
-    return res
-  }
-
-  const [key, ..._argsArr] = args
-  const _args = _argsArr.flat()
-  return data.filter((e) => {
-    const value = key.includes('.') ? getValueByKeys_getValueByKeys(key.split('.'), e) : e[key]
-    return _args.some((arg) => _performOperation(arg, value))
-  })
-}
-
-function _performOperation(arg, value) {
-  // the arg is undefined
-  if (arg === undefined && value === undefined)
-    return true
-
-  // the arg is null
-  if (arg === null && value === null)
-    return true
-
-  // the arg is boolean
-  if (typeof arg === 'boolean') {
-    return arg === value
-  }
-
-  // the arg is blank or *: Blank => Empty, * => Not Empty
-  if (arg === '' || arg === '*') {
-    // null and undefined are not included in either case
-    if (value === null || value === undefined) {
-      return false
-    }
-    if (typeof value === 'string') {
-      return arg === '' ? value === '' : value !== ''
-    }
-    if (Array.isArray(value)) {
-      return arg === '' ? value.length === 0 : value.length !== 0
-    }
-    return arg !== ''
-  }
-
-  // the arg is alphabetic or number
-  if (_isPureStringOrNumber(arg)) {
-    return arg === value
-  }
-
-  // the arg is array of [] or [*]: [] => Empty, [*] => Not Empty
-  if (arg.startsWith('[') && arg.endsWith(']')) {
-    if (arg === '[]') {
-      return Array.isArray(value) && value.length === 0
-    }
-    if (arg === '[*]') {
-      return Array.isArray(value) && value.length !== 0
-    }
-    return false
-  }
-
-  // the arg is 'operator + string | number'
-  const { operator, value: argValue } = _splitOperator(arg)
-  if (!operator || (argValue !== 0 && !argValue)) {
-    return false
-  }
-  switch (operator) {
-    case '>':
-      return value > argValue
-    case '<':
-      return value < argValue
-    case '!=':
-      return value !== argValue
-    case '>=':
-      return value >= argValue
-    case '<=':
-      return value <= argValue
-    default:
-      return false
-  }
-}
-
-function _isPureStringOrNumber(input) {
-  if (typeof input === 'string') {
-    if (input.startsWith('[') && input.endsWith(']')) {
-      return false
-    }
-    if (/!=|>=|<=|>|</.test(input)) {
-      return false
-    }
-    return true
-  }
-  return !Number.isNaN(input)
-}
-
-function _splitOperator(str) {
-  const operators = ['!=', '>=', '<=', '>', '<']
-
-  const matchedOp = operators.find((op) => str.startsWith(op))
-  if (!matchedOp)
-    return { operator: null, value: null }
-
-  const remaining = str.slice(matchedOp.length)
-
-  // '>Primary' or '<Primary' is invalid
-  if (/^[a-z]*$/i.test(remaining) && matchedOp !== '!=') {
-    return { operator: null, value: null }
-  }
-
-  // if it is a number it is converted to a number
-  const value = (!Number.isNaN(Number.parseFloat(remaining)) && !Number.isNaN(remaining)) ? Number(remaining) : remaining
-
-  return {
-    operator: matchedOp,
-    value
-  }
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_filterOne.js
-
-
-
-function _filterOne(data, args) {
-  try {
-    const list = _filterAll(data, args)
-    if (list.length === 1) {
-      return list[0]
-    }
-    if (list.length === 0) {
-      return null
-    }
-    throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.resultMoreThanOneException)
-  } catch (e) {
-    throw e
-  }
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_formatDate.js
-
-
-function _formatDate(timestamp, format) {
-  if (format.length === 0) {
-    throw new TemplateCompilerException(`_formateDate: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: format parts must be not empty array`)
-  }
-
-  if (timestamp === null || timestamp === undefined) {
-    return null
-  }
-
-  const date = new Date(timestamp)
-
-  const partsMap = {
-    yyyy: String(date.getFullYear()),
-    mm: String(date.getMonth() + 1).padStart(2, '0'),
-    dd: String(date.getDate()).padStart(2, '0')
-  }
-
-  // Check for invalid format tokens
-  const validTokens = ['yyyy', 'mm', 'dd']
-  const invalidTokens = format.filter((part) => part.length > 1 && !validTokens.includes(part))
-
-  if (invalidTokens.length > 0) {
-    throw new TemplateCompilerException(
-      `_formateDate: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the format type is not valid: ${format.join(', ')}`
-    )
-  }
-
-  // Build the formatted string using reduce
-  return format.reduce((result, part) => result + (partsMap[part] || part), '')
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_get.js
-
-
-function _get(data, key, failover = null) {
-  try {
-    if (key === null || (typeof key === 'undefined') || key === '') {
-      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
-    }
-    if (data === null) {
-      return null
-    }
-    if (key.includes('.')) {
-      const parts = key.split('.')
-      if (parts.length > 1) {
-        const first = parts.shift()
-        const remainingKey = parts.join('.')
-        if (typeof data[first] !== 'undefined') {
-          return _get(data[first], remainingKey, failover)
-        }
-        return _handleFailover(key, failover)
-      }
-    }
-    if (typeof data[key] !== 'undefined') {
-      return data[key]
-    }
-    return _handleFailover(key, failover)
-  } catch (e) {
-    throw e
-  }
-}
-
-function _handleFailover(key, failover) {
-  if (failover !== null) {
-    return failover
-  }
-  return null
-  // throw new TemplateCompilerException(`Key "${key}" does not exist and no failover`)
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_gt.js
-
-
-
-
-function _gt(data, args) {
-  if (args.length !== 3) {
-    throw new TemplateCompilerException(`_gt: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
-  }
-  if (data === null || (typeof data === 'undefined')) {
-    return null
-  }
-  if (args.includes(_SELF)) {
-    args = args.map((arg) => {
-      return (arg === _SELF) ? data : arg
-    })
-  }
-  const expected = args[0]
-  return data > expected ? args[1] : args[2]
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_gte.js
-
-
-
-
-function _gte(data, args) {
-  if (args.length !== 3) {
-    throw new TemplateCompilerException(`_gte: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
-  }
-  if (data === null || (typeof data === 'undefined')) {
-    return null
-  }
-  if (args.includes(_SELF)) {
-    args = args.map((arg) => {
-      return (arg === _SELF) ? data : arg
-    })
-  }
-  const expected = args[0]
-  return data >= expected ? args[1] : args[2]
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_isEmpty.js
-
-
-
-
-function _isEmpty(data, args) {
-  if (args.length !== 2) {
-    throw new TemplateCompilerException(`_isEmpty: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
-  }
-  // if (data === null || (typeof data === 'undefined')) {
-  //   return null
-  // }
-  if (args.includes(_SELF)) {
-    args = args.map((arg) => {
-      return (arg === _SELF) ? data : arg
-    })
-  }
-  if (data !== null && typeof data === 'object' && Object.keys(data).length === 0) {
-    return args[0]
-  }
-  return (data === '' || data === null || data === undefined || data.length === 0) ? args[0] : args[1]
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_isNotEmpty.js
-
-
-
-
-function _isNotEmpty(data, args) {
-  if (args.length !== 2) {
-    throw new TemplateCompilerException(`_isNotEmpty: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
-  }
-  // if (data === null || (typeof data === 'undefined')) {
-  //   return null
-  // }
-  if (args.includes(_SELF)) {
-    args = args.map((arg) => {
-      return (arg === _SELF) ? data : arg
-    })
-  }
-  if (data !== null && typeof data === 'object' && Object.keys(data).length === 0) {
-    return args[1]
-  }
-  if (Array.isArray(data) && data.length === 0) {
-    return args[1]
-  }
-  if (typeof data === 'string' && data === '') {
-    return args[1]
-  }
-  if (data === null || data === undefined) {
-    return args[1]
-  }
-  return args[0]
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_join.js
-function _join(data, delimiter) {
-  try {
-    if (data.length === 0)
-      return ''
-    if (data.length === 1)
-      return _stringifyObject(data[0])
-    return data.map((item) => _stringifyObject(item)).join(delimiter)
-  } catch (e) {
-    throw e
-  }
-}
-
-function _stringifyObject(obj) {
-  return JSON.stringify(obj).replace(/"([^"]+)":/g, '$1: ').replace(/"([^"]+)"/g, '$1').replace(/,/g, ', ')
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_lt.js
-
-
-
-
-function _lt(data, args) {
-  if (args.length !== 3) {
-    throw new TemplateCompilerException(`_lt: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
-  }
-  if (data === null || (typeof data === 'undefined')) {
-    return null
-  }
-  if (args.includes(_SELF)) {
-    args = args.map((arg) => {
-      return (arg === _SELF) ? data : arg
-    })
-  }
-  const expected = args[0]
-  return data < expected ? args[1] : args[2]
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_lte.js
-
-
-
-
-function _lte(data, args) {
-  if (args.length !== 3) {
-    throw new TemplateCompilerException(`_lte: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
-  }
-  if (data === null || (typeof data === 'undefined')) {
-    return null
-  }
-  if (args.includes(_SELF)) {
-    args = args.map((arg) => {
-      return (arg === _SELF) ? data : arg
-    })
-  }
-  const expected = args[0]
-  return data <= expected ? args[1] : args[2]
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_map.js
-
-
-
-function _map(data, args) {
-  try {
-    if (args.length === 0) {
-      throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentEmptyException)
-    }
-    if (data === null || (typeof data === 'undefined')) {
-      return null
-    }
-
-    const result = data.reduce((acc, item) => {
-      if (args.length === 1 && Array.isArray(args[0])) {
-        args = args[0]
-        acc.hasFormat = true
-      }
-      const list = args.map((key) => {
-        if (key.includes('.')) {
-          const parts = key.split('.')
-          const first = parts[0]
-          parts.shift()
-          const remainingKey = parts.join('.')
-          return _get(item[first], remainingKey)
-        }
-        if (typeof item[key] !== 'undefined') {
-          return item[key]
-        }
-        return null
-      })
-      if (acc.hasFormat) {
-        acc.content.push(list)
-      } else {
-        acc.content = acc.content.concat(list)
-      }
-      return acc
-    }, {
-      content: [],
-      hasFormat: false
-    })
-    return result.content
-  } catch (e) {
-    throw e
-  }
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_neq.js
-
-
-
-
-function _neq(data, args) {
-  if (args.length !== 3) {
-    throw new TemplateCompilerException(`_neq: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
-  }
-  if (data === null || (typeof data === 'undefined')) {
-    return null
-  }
-  if (args.includes(_SELF)) {
-    args = args.map((arg) => {
-      return (arg === _SELF) ? data : arg
-    })
-  }
-  const expected = args[0]
-  return data !== expected ? args[1] : args[2]
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_removeHtml.js
-
-
-function _removeHtml(html, args) {
-  if (html === null || html === undefined) {
-    return null
-  }
-  if (!Array.isArray(args)) {
-    throw new TemplateCompilerException(`_removeHtml: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: args parts must be array`)
-  }
-
-  return _htmlToPlainText(html, args[0])
-}
-
-function _htmlToPlainText(html, delimiter = '\n') {
-  if (typeof delimiter !== 'string') {
-    delimiter = '\n' // Fallback to default if not a string
-  }
-
-  // First decode HTML entities and normalize whitespace
-  const decodedHtml = html
-    .replace(/&nbsp;/g, ' ')
-    .replace(/\s+/g, ' ') // Collapse all whitespace to single spaces
-
-  // Process HTML tags
-  let text = decodedHtml
-    // Replace block tags with temporary marker (~~~)
-    .replace(/<\/?(p|div|h[1-6]|ul|ol|li|pre|section|article|table|tr|td|th)(\s[^>]*)?>/gi, '~~~')
-    // Replace <br> tags with temporary marker (~~~)
-    .replace(/<br\s*\/?>/gi, '~~~')
-    // Remove all other tags
-    .replace(/<[^>]+>/g, '')
-    // Convert markers to specified delimiter
-    .replace(/~{3,}/g, delimiter)
-    // Trim and clean whitespace
-    .trim()
-
-  // Special handling for empty delimiter
-  if (delimiter === '') {
-    // Collapse all whitespace to single space
-    text = text.replace(/\s+/g, ' ')
-  } else {
-    // Collapse multiple delimiters to single
-    text = text.replace(new RegExp(`${escapeRegExp(delimiter)}+`, 'g'), delimiter)
-    // Remove leading/trailing delimiters
-    text = text.replace(new RegExp(`^${escapeRegExp(delimiter)}|${escapeRegExp(delimiter)}$`, 'g'), '')
-  }
-
-  return text
-}
-
-function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_sum.js
-function _sum(data, args) {
-  if (Number.isNaN(data) || data === null || (typeof data === 'undefined') || data === '') {
-    return data
-  }
-  return args.reduce((acc, e) => (acc + e), data)
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_toLowerCase.js
-
-
-function _toLowerCase(data, args) {
-  if (args !== undefined) {
-    throw new TemplateCompilerException(`_toLowerCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: ${args.join(', ')}`)
-  }
-  if (data === null || (typeof data === 'undefined') || typeof data !== 'string') {
-    return null
-  }
-  return String(data).toLowerCase()
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/_toUpperCase.js
-
-
-function _toUpperCase(data, args) {
-  if (typeof data !== 'string') {
-    throw new TemplateCompilerException(`_toUpperCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the data must be string: ${data}`)
-  }
-  if (args !== undefined) {
-    throw new TemplateCompilerException(`_toUpperCase: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException}: the argument must be empty: ${args.join(', ')}`)
-  }
-  if (data === null || (typeof data === 'undefined') || typeof data !== 'string') {
-    return null
-  }
-  return String(data).toUpperCase()
-}
-
-
-
-;// ./lib/models/templateCompiler/helpers/index.js
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-;// ./lib/models/templateCompiler/templateCompiler.js
-
-
-
-
-class TemplateCompiler {
-  constructor(data) {
-    this.data = data
-  }
-  static init(options) {
-    return new this(options)
-  }
-  static initFromArray(arr = []) {
-    if (Array.isArray(arr)) {
-      return arr.map((a) => this.init(a))
-    }
-    return []
-  }
-  static initOnlyValidFromArray(arr = []) {
-    return this.initFromArray(arr).filter((i) => i)
-  }
-  static concatIf(data, args) {
-    return _concatIf(data, args)
-  }
-  static divide(data, args) {
-    return _divide(data, args)
-  }
-  static eq(data, args) {
-    return _eq(data, args)
-  }
-
-  static filterAll(data, args) {
-    return _filterAll(data, args)
-  }
-
-  static formatDate(data, args) {
-    return _formatDate(data, args)
-  }
-  static get(data, key, failover = null) {
-    return _get(data, key, failover)
-  }
-  static gt(data, args) {
-    return _gt(data, args)
-  }
-  static gte(data, args) {
-    return _gte(data, args)
-  }
-  static isEmpty(data, args) {
-    return _isEmpty(data, args)
-  }
-  static isNotEmpty(data, args) {
-    return _isNotEmpty(data, args)
-  }
-  static join(data, separator = '') {
-    return _join(data, separator)
-  }
-  static lt(data, args) {
-    return _lt(data, args)
-  }
-  static lte(data, args) {
-    return _lte(data, args)
-  }
-  static map(data, args = []) {
-    return _map(data, args)
-  }
-  static neq(data, args) {
-    return _neq(data, args)
-  }
-  static removeHtml(data, args) {
-    return _removeHtml(data, args)
-  }
-  static sum(data, args) {
-    return _sum(data, args)
-  }
-  static toLowerCase(data, args) {
-    return _toLowerCase(data, args)
-  }
-  static toUpperCase(data, args) {
-    return _toUpperCase(data, args)
-  }
-  static parseFunction(expression) {
-    return _parseFunction(expression, _FN_NAMES)
-  }
-  static parseParams(parameters) {
-    return _parseParams(parameters)
-  }
-
-  pipe(expression = '') {
-    this.delimiters = expression.substring(0, 2) === '{{' ? TAGS_HANDLEBAR : TAGS_EJS
-    const regex = new RegExp(`${this.delimiters[0]}\\s(.*?)\\s${this.delimiters[1]}`)
-    const match = expression.match(regex)
-    if (match !== null) {
-      try {
-        const functionList = _parseFunction(match[1], _FN_NAMES)
-        return functionList.reduce((acc, fn) => {
-          return _callFunction(acc, fn.name, fn.args)
-        }, this.data)
-      } catch (e) {
-        throw new TemplateCompilerException(`TemplateCompiler engine error: ${e.message}`)
-      }
-    }
-    throw new TemplateCompilerException(`TemplateCompiler engine error: ${TEMPLATE_COMPILER_EXCEPTION_TYPE.invalidRegExpException}`)
-  }
-}
-
-function _parseFunction(expression, existFunctionNames) {
-  const regExp = new RegExp(/(\w+)\(([^)]*)\)/)
-  let parts
-  if (expression.includes('|')) {
-    parts = expression.split('|')
-  } else {
-    parts = [expression]
-  }
-  return parts.reduce((acc, part) => {
-    const match = part.match(regExp)
-    if (match !== null) {
-      const functionName = match[1]
-      const parameters = match[2]
-      const paramList = _parseParams(parameters)
-      if (existFunctionNames.includes(functionName)) {
-        acc.push({
-          name: functionName,
-          args: paramList
-        })
-      } else {
-        throw new TemplateCompilerException(`${functionName} is not a valid function`)
-      }
-    }
-    return acc
-  }, [])
-}
-
-function _parseParams(parameters) {
-  const _parameters = parameters.trim()
-  const regExp = new RegExp(/^[^\w\s]+$/)
-  const match = _parameters.match(regExp)
-  if (match !== null) {
-    return [_parameters.substring(1, _parameters.length - 1)]
-  }
-  if (_parameters.includes(',')) {
-    // 用正则表达式匹配逗号，但忽略方括号中的逗号
-    const parts = _splitIgnoringBrackets(_parameters)
-    return parts.map((part) => _parseSinglePart(part))
-  }
-  return [_parseSinglePart(_parameters)]
-}
-
-function _splitIgnoringBrackets(input) {
-  const regExp2 = new RegExp(/^\d+(\.\d+)?$/)
-  const regExp = new RegExp(/(?![^[]*\])\s*,\s*/)
-  const parts = input.split(regExp)
-  return parts.map((part) => {
-    const _part = part.trim()
-    if (_part !== '' && !!_part.match(regExp2)) {
-      // 如果是数字，转换为 num 类型
-      return Number.isNaN(_part) ? _part : Number.parseInt(_part, 10)
-    }
-    // 否则当作字符串处理
-    return _part
-  })
-}
-
-function _parseSinglePart(input) {
-  if (typeof input === 'string') {
-    if (input.startsWith('"') && input.endsWith('"')) {
-      // 去掉双引号，返回
-      return input.substring(1, input.length - 1)
-    }
-    if (input.startsWith('\'') && input.endsWith('\'')) {
-      // 去掉双引号，返回
-      return input.substring(1, input.length - 1)
-    }
-
-    const _input = _toBasicType(input)
-
-    if (typeof _input !== 'string') {
-      return _input
-    }
-
-    // 如果是一个列表形式（例如 ["p", "d"] 或 [p, d]）
-    if (_input.startsWith('[') && _input.endsWith(']')) {
-      const listContent = _input.substring(1, _input.length - 1).trim()
-      if (listContent !== '') {
-        return listContent.split(',').map((item) => {
-          return _toBasicType(item.trim())
-        })
-      }
-      return []
-    }
-    return input
-  }
-  return input
-}
-
-function _toBasicType(input) {
-  if (input.startsWith('"') && input.endsWith('"')) {
-    // 去掉双引号，返回
-    return input.substring(1, input.length - 1)
-  }
-  if (input.startsWith('\'') && input.endsWith('\'')) {
-    // 去掉双引号，返回
-    return input.substring(1, input.length - 1)
-  }
-  if (input === 'true') {
-    return true
-  }
-  if (input === 'false') {
-    return false
-  }
-  if (input === 'undefined') {
-    return undefined
-  }
-  if (input === 'null') {
-    return null
-  }
-  if (!Number.isNaN(input) && !Number.isNaN(Number.parseFloat(input))) {
-    return Number(input)
-  }
-  return input
-}
-
-function _callFunction(data, functionName, parameters) {
-  try {
-    let failover
-    switch (functionName) {
-      case 'concatIf':
-        return _concatIf(data, parameters)
-      case 'divide':
-        return _divide(data, parameters)
-      case 'eq':
-        return _eq(data, parameters)
-      case 'exec':
-        return _exec(data, parameters)
-      case 'filterAll':
-        return _filterAll(data, parameters)
-      case 'filterOne':
-        return _filterOne(data, parameters)
-      case 'formatDate':
-        return _formatDate(data, parameters)
-      case 'get':
-        if (parameters.length > 2) {
-          throw new TemplateCompilerException(TEMPLATE_COMPILER_EXCEPTION_TYPE.argumentFormatException)
-        }
-        if (parameters.length === 2) {
-          failover = parameters[parameters.length - 1]
-        }
-        return _get(data, parameters[0], failover)
-      case 'gt':
-        return _gt(data, parameters)
-      case 'gte':
-        return _gte(data, parameters)
-      case 'isEmpty':
-        return _isEmpty(data, parameters)
-      case 'isNotEmpty':
-        return _isNotEmpty(data, parameters)
-      case 'join':
-        return _join(data, parameters[0])
-      case 'lt':
-        return _lt(data, parameters)
-      case 'lte':
-        return _lte(data, parameters)
-      case 'map':
-        return _map(data, parameters)
-      case 'neq':
-        return _neq(data, parameters)
-      case 'removeHtml':
-        return _removeHtml(data, parameters)
-      case 'sum':
-        return _sum(data, parameters)
-      case 'toLowerCase':
-        return _toLowerCase(data)
-      case 'toUpperCase':
-        return _toUpperCase(data)
-      default:
-        throw new Error(`${functionName} is not a valid function`)
-    }
-  } catch (e) {
-    throw e
-  }
-}
-
-
-
-;// ./lib/models/templateCompiler/index.js
-
-
-
-
-;// ./lib/models/tenantAwareEntity/tenantAwareEntity.js
-
-
-
-
-class TenantAwareEntity extends TrackedEntity {
-  constructor(options = {}) {
-    options = options || {}
-
-    /**
-     * instead of throw error, we choose to implement the isValid checking
-     */
-    // if (!options.tenantCode) {
-    //   throw new Error('tenantCode required')
-    // }
-
-    super(options)
-
-    this._tenant = options._tenant
-
-    this.metadata = Metadata.initOnlyValidFromArray(options.metadata)
-    this.remarks = keyValueObject_KeyValueObject.initOnlyValidFromArray(options.remarks)
-    this.tenantCode = options.tenantCode // Required for multi-tenancy
-  }
-
-  // Class methods
-  static get _classname() {
-    return 'TenantAwareEntity'
-  }
-  static get _superclass() {
-    return 'TenantAwareEntity'
-  }
-
-  // getters
-  get __valid() {
-    return {
-      ...super.__valid,
-      tenantCode: this.tenantCode
-    }
-  }
-  get isValid() {
-    return super.isValid && !!this.tenantCode // Required for multi-tenancy
-  }
-
-  // instance methods
-  insertOrUpdateMetadata(key, value) {
-    this.metadata = Metadata.insertOrUpdateRecord(this.metadata, key, value)
-    return this
-  }
-  getMetadata() {
-    return this.metadata
-  }
-  getMetadataByKey(key) {
-    return Metadata.foundByKey(this.metadata, key)
-  }
-  getMetadataValueByKey(key) {
-    const found = this.getMetadataByKey(key)
-    return found ? found.value : null
-  }
-  getMetadataValueByKeys(keys, kv) {
-    if (!Array.isArray(keys)) {
-      return null
-    }
-    kv = kv || this.metadata
-    if (keys.length === 0) {
-      return kv
-    }
-    const key = keys.shift()
-    const _val = Metadata.getMetadataValueByKeyAsArray(kv, key)
-    return this.getMetadataValueByKeys(keys, _val)
-  }
-  getMetadataValueByKeyAsArray(key) {
-    return Metadata.getMetadataValueByKeyAsArray(this.metadata, key)
-  }
-  getRemarks() {
-    return this.remarks
-  }
-  getRemarkByKey(key) {
-    return keyValueObject_KeyValueObject.foundByKey(this.remarks, key)
-  }
-  getRemarksValueByKey(key) {
-    const found = this.getRemarkByKey(key)
-    return found ? found.value : null
-  }
-  getTenantCode() {
-    return this.tenantCode
-  }
-
-  update(update) {
-    if (update.metadata && Array.isArray(update.metadata)) {
-      this.metadata = Metadata.initOnlyValidFromArray(update.metadata)
-    }
-    if (update.remarks && Array.isArray(update.remarks)) {
-      this.remarks = keyValueObject_KeyValueObject.initOnlyValidFromArray(update.remarks)
-    }
-    return super.update(update)
-  }
-}
-
-;// ./lib/models/tenantAwareEntity/index.js
-
-
-
-;// ./lib/models/uniqueKeyGenerator/uniqueKeyGenerator.js
-
-
-class UniqueKeyGenerator {
-  static get _classname() {
-    return 'UniqueKeyGenerator'
-  }
-  static get _superclass() {
-    return 'UniqueKeyGenerator'
-  }
-  static makeFormatter({ fieldName, format, options }) {
-    switch (format) {
-      case 'set_code':
-        return _makeSetCode(fieldName, options)
-      default:
-        return _makeSetCode(fieldName, options)
-    }
-  }
-  static makeGenerator(arr) {
-    const fns = arr.map((item) => this.makeFormatter(item))
-    return async (obj) => {
-      const output = await pReduce(fns, async (acc, fn) => {
-        const _obj = await fn(obj)
-        return Object.assign(acc, _obj)
-      }, obj)
-      return output
-    }
-  }
-}
-
-function _makeSetCode(fieldName, options) {
-  return async (obj = {}) => {
-    if (obj[fieldName]) {
-      return {}
-    }
-    return {
-      [fieldName]: stringHelper.setCode()
-    }
-  }
-}
-
-
-
-;// ./lib/models/uniqueKeyGenerator/index.js
-
-
-
-
-;// ./lib/models/index.js
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-;// ./lib/helpers/getValidation/getValidation.js
-
-
-
-
-function getValidation(rule, data, getDataByKey = _getDataByKey, KeyValueObject = keyValueObject_KeyValueObject) {
-  if (!rule) {
-    return true
-  }
-  if (typeof getDataByKey !== 'function' || (KeyValueObject && typeof KeyValueObject !== 'function')) {
-    return false
-  }
-  const { key = '', value, placeholder, keyValuePath = '' } = rule
-  const [valueAttribute] = Object.keys(value)
-
-  if (!key && typeof placeholder === 'undefined') {
-    switch (valueAttribute) {
-      case '$and': {
-        return value.$and.reduce((acc, item) => (acc && getValidation(item, data, getDataByKey, KeyValueObject)), true)
-      }
-      case '$or': {
-        return value.$or.reduce((acc, item) => (acc || getValidation(item, data, getDataByKey, KeyValueObject)), false)
-      }
-      default:
-        return false
-    }
-  }
-  let rowValue = typeof placeholder === 'undefined' ? getDataByKey(key, data) : placeholder
-
-  // if KeyValue object
-  if (keyValuePath) {
-    const rowValueData = KeyValueObject.toObject(rowValue)
-    rowValue = getDataByKey(keyValuePath, rowValueData)
-  }
-
-  switch (valueAttribute) {
-    case '$after': {
-      if (isConvertibleToNumber(value?.$after)) {
-        const _value = Number(String(value?.$after))
-        return Date.now() > _value
-      }
-      return false
-    }
-    case '$before': {
-      if (isConvertibleToNumber(value?.$before)) {
-        const _value = Number(String(value?.$before))
-        return Date.now() < _value
-      }
-      return false
-    }
-    case '$empty': {
-      const isEmpty = rowValue === null || rowValue === undefined
-      return isEmpty === value.$empty
-    }
-    case '$eq': {
-      return rowValue === value.$eq
-    }
-    case '$gt': {
-      return rowValue > value.$gt
-    }
-    case '$gte': {
-      return rowValue >= value.$gte
-    }
-    case '$hasOverlap': {
-      return _hasOverlap(rowValue, value.$hasOverlap)
-    }
-    case '$lt': {
-      return rowValue < value.$lt
-    }
-    case '$lte': {
-      return rowValue <= value.$lte
-    }
-    case '$in': {
-      if (Array.isArray(rowValue)) {
-        return !!rowValue.find((e) => (value.$in.includes(e)))
-      }
-      if (typeof rowValue !== 'object') {
-        return !!value.$in.includes(rowValue)
-      }
-      return false
-    }
-    case '$includes': {
-      if (Array.isArray(rowValue)) {
-        return rowValue.includes(value.$includes)
-      }
-      return false
-    }
-    case '$intervalTimeGt': {
-      const now = new Date().getTime()
-      const timestamp = new Date(rowValue).getTime()
-      return (now - timestamp) > value.$intervalTimeGt
-    }
-    case '$intervalTimeLt': {
-      const now = new Date().getTime()
-      const timestamp = new Date(rowValue).getTime()
-      return (now - timestamp) < value.$intervalTimeLt
-    }
-    case '$inValue': {
-      const result = getDataByKey(value.$inValue, data)
-      const _value = Array.isArray(result) ? result : []
-      if (Array.isArray(rowValue)) {
-        return !!rowValue.find((e) => (_value.includes(e)))
-      }
-      if (typeof rowValue === 'string') {
-        return !!_value.includes(rowValue)
-      }
-      return false
-    }
-    case '$isToday': {
-      const currentDate = new Date()
-      const start = currentDate.setHours(0, 0, 0, 0)
-      const end = currentDate.setHours(23, 59, 59, 59)
-      const dateValue = new Date(rowValue).getTime()
-      return (start <= dateValue && end >= dateValue) === value.$isToday
-    }
-    case '$ne': {
-      return rowValue !== value.$ne
-    }
-    case '$notIn': {
-      if (Array.isArray(rowValue)) {
-        return !rowValue.find((e) => (value.$notIn.includes(e)))
-      }
-      if (typeof rowValue !== 'object') {
-        return !value.$notIn.includes(rowValue)
-      }
-      return false
-    }
-    case '$notInValue': {
-      const result = getDataByKey(value.$notInValue, data)
-      const _value = Array.isArray(result) ? result : []
-      if (Array.isArray(rowValue)) {
-        return !rowValue.find((e) => (_value.includes(e)))
-      }
-      if (typeof rowValue !== 'object') {
-        return !_value.includes(rowValue)
-      }
-      return false
-    }
-    case '$range': {
-      const [min, max] = value.$range
-      if (typeof min === 'number' && typeof max === 'number' && rowValue >= min && rowValue <= max) {
-        return true
-      }
-      return false
-    }
-    default:
-      return false
-  }
-}
-
-function _getDataByKey(key, data) {
-  return getValueByKeys_getValueByKeys(key.split('.'), data)
-}
-
-function _hasOverlap(item1, item2) {
-  let arr1 = item1
-  let arr2 = item2
-  if (typeof arr1 === 'string') {
-    arr1 = arr1.split(',')
-  }
-  if (typeof arr2 === 'string') {
-    arr2 = arr2.split(',')
-  }
-  const set1 = new Set(arr1)
-  return arr2.find((i) => (set1.has(i)))
-}
-
-/* harmony default export */ const getValidation_getValidation = ({
-  getValidation
-});
-
-
-;// ./lib/helpers/getValidation/index.js
-
-
-;// ./lib/helpers/formatDate/formatDate.js
-function formatDate(date, format) {
-  const _date = date && date instanceof Date ? date : new Date(date)
-  const dayMapChi = ['日', '一', '二', '三', '四', '五', '六']
-  const dayMapEng = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
-  const dayMapEngShort = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
-  const _format = format || 'YYYY/MM/DD hh:mm'
-  const e = _date.getDay()
-  const ee = dayMapEngShort[e]
-  const eee = dayMapChi[e]
-  const eeee = dayMapEng[e]
-  const y = _date.getFullYear()
-  const m = _date.getMonth() + 1
-  const d = _date.getDate()
-  const h = _date.getHours()
-  const mm = _date.getMinutes()
-  const s = _date.getSeconds()
-
-  return _format.replace('YYYY', y)
-    .replace('MM', padding(m))
-    .replace('MM', padding(m))
-    .replace('DD', padding(d))
-    .replace('hh', padding(h))
-    .replace('mm', padding(mm))
-    .replace('ss', padding(s))
-    .replace('M', m)
-    .replace('D', d)
-    .replace('h', h)
-    .replace('m', mm)
-    .replace('s', s)
-    .replace('EEEE', padding(eeee))
-    .replace('EEE', padding(eee))
-    .replace('EE', padding(ee))
-    .replace('E', padding(e))
-}
-
-function padding(m) {
-  return m < 10 ? `0${m}` : m
-}
-
-/* harmony default export */ const formatDate_formatDate = ({
-  formatDate
-});
-
-
-;// ./lib/helpers/formatDate/index.js
-
-
-;// ./lib/helpers/concatStringByArray/concatStringByArray.js
-
-
-
-
-
-function concatStringByArray(arrTemplate, data) {
-  return arrTemplate.reduce((acc, item) => {
-    const { type, value = '', restriction, template, format, showMinutes } = item
-    switch (type) {
-      case ('array'): {
-        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
-          const _value = getValueByKeys_getValueByKeys(value.split('.'), data) || []
-          acc += _value.reduce((_acc, item) => {
-            return _acc += concatStringByArray(template, item)
-          }, '')
-        }
-        break
-      }
-      case ('date'): {
-        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
-          const _value = getValueByKeys_getValueByKeys(value.split('.'), data) || ''
-          acc += (formatDate(_value, format).toString())
-        }
-        break
-      }
-      case ('ellipsis'): {
-        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
-          const { maxLength } = item
-          const _value = getValueByKeys_getValueByKeys(value.split('.'), data) || ''
-          if (_value.length <= maxLength) {
-            acc += (_value.toString())
-          } else {
-            acc += `${_value.substr(0, maxLength)}...`
-          }
-        }
-        break
-      }
-      case ('group'): {
-        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
-          return concatStringByArray(value, data)
-        }
-        break
-      }
-      case ('label'): {
-        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
-          acc += (value.toString())
-        }
-        break
-      }
-      case ('templateCompiler'): {
-        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
-          const templateCompiler = new TemplateCompiler({ data })
-          acc += templateCompiler.pipe(value)
-        }
-        break
-      }
-      case ('value'): {
-        if (getValidation(restriction, data, getValueByKeys_getValueByKeys)) {
-          const _value = getValueByKeys_getValueByKeys(value.split('.'), data) || ''
-          acc += (_value.toString())
-        }
-        break
-      }
-    }
-    return acc
-  }, '')
-}
-/* harmony default export */ const concatStringByArray_concatStringByArray = ({
-  concatStringByArray
-});
-
-
-;// ./lib/helpers/concatStringByArray/index.js
-
-
-;// ./lib/helpers/convertString/convertString.js
-
-
-function convertString(string, patternMatch = /\$\{(.+?)\}/g, value, getValueByKeys) {
-  if (!string) {
-    return ''
-  }
-  const _getValueByKeys = typeof getValueByKeys === 'function' ? getValueByKeys : getValueByKeys_getValueByKeys
-  const reg = new RegExp(patternMatch, 'g')
-  return string.replace(reg, (match, key) => {
-    const result = _getValueByKeys({ keys: key.split('.'), obj: value })
-    if (result === null || result === undefined) {
-      return ''
-    }
-    return typeof result === 'object' ? JSON.stringify(result) : result
-  })
-}
-
-/* harmony default export */ const convertString_convertString = ({
-  convertString
-});
-
-
-;// ./lib/helpers/convertString/index.js
-
-
-;// ./lib/helpers/detectControlCharacters/detectControlCharacters.js
-/**
- * Detects and reports hidden/control characters in a string without modifying it.
- * @param {string} input - The string to analyze.
- * @param {Object} [options] - Configuration options.
- * @param {boolean} [options.preserveBasicWhitespace=true] - Whether to consider basic whitespace as valid.
- * @returns {Object} Report object with detection results.
- */
-function detectControlCharacters(input, options = {}) {
-  const {
-    preserveBasicWhitespace = true,
-    removeNewlines = false
-  } = options
-
-  if (typeof input !== 'string') {
-    return {
-      hasControlChars: false,
-      matches: [],
-      inputType: typeof input,
-      message: 'Input is not a string'
-    }
-  }
-
-  const matches = []
-  let regex
-
-  if (preserveBasicWhitespace && !removeNewlines) {
-    // Same regex as Phase 1 preserve mode - keep tab (\t), newline (\n), carriage return (\r)
-    regex = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F\u200B-\u200D\uFEFF\u202A-\u202E]/g
-  } else {
-    // Same regex as Phase 1 full removal mode - use consistent escape sequences
-    regex = /[\x00-\x1F\x7F-\x9F\u200B-\u200D\uFEFF\u202A-\u202E]/g
-  }
-
-  // Use a replacer function to capture matches without modifying the string
-  input.replace(regex, (match, offset) => {
-    matches.push({
-      character: match,
-      code: match.charCodeAt(0),
-      hex: '0x' + match.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0'),
-      position: offset,
-      context: getContext(input, offset, 10) // Show surrounding text
-    })
-    return '' // Return empty but we don't use the result
-  })
-
-  return {
-    hasControlChars: matches.length > 0,
-    matches,
-    totalFound: matches.length,
-    inputPreview: input.length > 50 ? input.substring(0, 50) + '...' : input,
-    inputLength: input.length,
-    optionsUsed: { preserveBasicWhitespace },
-    regexPattern: regex.toString()
-  }
-}
-
-/**
- * Helper function to get context around a match
- */
-function getContext(str, position, contextLength = 10) {
-  const start = Math.max(0, position - contextLength)
-  const end = Math.min(str.length, position + contextLength + 1)
-  let context = str.substring(start, end)
-  
-  // Replace control characters with their escape sequences for readability
-  context = context.replace(/[\x00-\x1F\x7F-\x9F]/g, (match) => {
-    return '\\u' + match.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')
-  })
-  
-  return context
-}
-
-/**
- * Pretty print the detection results to console
- */
-function printControlCharReport(report) {
-  console.log('=== Control Character Detection Report ===')
-  console.log(`Input: "${report.inputPreview}" (${report.inputLength} chars)`)
-  console.log(`Options: preserveBasicWhitespace = ${report.optionsUsed.preserveBasicWhitespace}`)
-  console.log(`Regex pattern: ${report.regexPattern}`)
-  console.log(`Control characters found: ${report.totalFound}`)
-  
-  if (report.hasControlChars) {
-    console.log('\n📋 Matches found:')
-    report.matches.forEach((match, index) => {
-      console.log(`\n${index + 1}. Character: ${JSON.stringify(match.character)}`)
-      console.log(`   Code: ${match.code} (${match.hex})`)
-      console.log(`   Position: ${match.position}`)
-      console.log(`   Context: "...${match.context}..."`)
-    })
-  } else {
-    console.log('✅ No control characters detected in Phase 1 range')
-  }
-  
-  console.log('=== End Report ===')
-}
-
-;// ./lib/helpers/detectControlCharacters/index.js
-
-
-;// ./lib/helpers/downloadFileByUrl/downloadFileByUrl.js
-function downloadFileByUrl({ dataUrl = '', filename = '' } = {}) {
-  const link = document.createElement('a')
-  link.download = filename
-  link.href = dataUrl
-  document.body.appendChild(link)
-  link.click()
-  document.body.removeChild(link)
-}
-
-
-
-;// ./lib/helpers/downloadFileByUrl/index.js
-
-
-
-
-;// ./lib/helpers/escapeRegex/escapeRegex.js
-function escapeRegex(string) {
-  return String(string).replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')
-}
-
-;// ./lib/helpers/escapeRegex/index.js
-
-
-;// ./lib/helpers/expressHelper/customHandler.js
-function customHandler({ responseHelper, handler, ignoreError = false }) {
-  return async (req, res, next) => {
-    try {
-      await handler({ req, res })
-      await next()
-    } catch (err) {
-      if (ignoreError || !responseHelper) {
-        await next()
-      } else {
-        res.status(400).json(responseHelper.standardizeResponse({ err, message: err.message || err }))
-      }
-    }
-  }
-}
-
-;// ./lib/helpers/expressHelper/findAllResult.js
-function findAllResult({ responseHelper, service }) {
-  return async (req, res, next) => {
-    try {
-      const { query } = req
-      const result = await service.findAll({ query })
-      res.locals.findAllResult = result
-      await next()
-    } catch (err) {
-      res.status(400).json(responseHelper.standardizeResponse({ err, message: err.message || err }))
-    }
-  }
-}
-
-;// ./lib/helpers/expressHelper/findOneResult.js
-function findOneResult({ responseHelper, service }) {
-  return async (req, res, next) => {
-    try {
-      const { params, query } = req
-      const { id } = params
-      const result = await service.findOne({
-        query: {
-          ...query,
-          id
-        }
-      })
-      res.locals.findOneResult = result
-      await next()
-    } catch (err) {
-      res.status(400).json(responseHelper.standardizeResponse({ err, message: err.message || err }))
-    }
-  }
-}
-
-;// ./lib/helpers/expressHelper/postResult.js
-function postResult({ responseHelper, service }) {
-  return async (req, res, next) => {
-    try {
-      const { body } = req
-      let result
-      if (Array.isArray(body)) {
-        result = await service.saveAll({ docs: body })
-      } else {
-        result = await service.saveOne({ doc: body })
-      }
-      res.locals.postResult = result
-      await next()
-    } catch (err) {
-      res.status(400).json(responseHelper.standardizeResponse({ err, message: err.message || err }))
-    }
-  }
-}
-
-;// ./lib/helpers/expressHelper/updateOneResult.js
-function updateOneResult({ responseHelper, service }) {
-  return async (req, res, next) => {
-    try {
-      const { body, params } = req
-      const { id } = params
-      if (id !== body.id) {
-        throw new Error('id in params and body must be same')
-      }
-      const { data } = await service.findOne({ query: { id } })
-      const doc = data[0]
-      doc.update(body)
-      const result = await service.saveOne({ doc })
-      res.locals.updateOneResult = result
-      await next()
-    } catch (err) {
-      res.status(400).json(responseHelper.standardizeResponse({ err, message: err.message || err }))
-    }
-  }
-}
-
-;// ./lib/helpers/expressHelper/index.js
-
-
-
-
-
-
-const expressHelper = {
-  customHandler: customHandler,
-  findAllResult: findAllResult,
-  findOneResult: findOneResult,
-  postResult: postResult,
-  updateOneResult: updateOneResult,
-}
-
-;// ./lib/helpers/extractEmails/extractEmails.js
-/**
- * Extracts and normalizes unique email addresses from an array containing messy entries
- * @param {Array} dirtyArray - Array that may contain emails in various formats (may include null/empty entries)
- * @returns {Array} Sorted array of unique, lowercase email addresses
- */
-function extractEmails(dirtyArray) {
-  const emailRegex = /[\w.%+-]+@[a-z0-9.-]+\.[a-z]{2,}/gi
-  const emails = new Set()
-
-  // Handle null/undefined input array
-  if (!dirtyArray)
-    return []
-
-  dirtyArray.forEach((entry) => {
-    // Skip null, undefined, empty, or whitespace-only entries
-    if (!entry || typeof entry !== 'string' || !entry.trim())
-      return
-
-    try {
-      const cleanEntry = entry
-        .replace(/[\u200B-\u200D\uFEFF\u202A-\u202E]/g, '') // Remove hidden chars
-        .replace(/[<>]/g, ' ') // Convert email delimiters to spaces
-        .replace(/\s+/g, ' ') // Collapse multiple whitespace
-        .trim()
-
-      // Extract all email matches
-      const matches = cleanEntry.match(emailRegex)
-      if (matches) {
-        matches.forEach((email) => emails.add(email.toLowerCase())) // Normalize to lowercase
-      }
-    } catch (e) {
-      console.warn('Failed to process entry:', entry, e)
-    }
-  })
-
-  // Convert Set to array and sort alphabetically
-  return Array.from(emails).sort((a, b) => a.localeCompare(b))
-}
-
-;// ./lib/helpers/extractEmails/index.js
-
-
-;// ./lib/helpers/pReduce/pReduce.js
-async function pReduce(iterable, reducer, initialValue) {
-  return new Promise((resolve, reject) => {
-    const iterator = iterable[Symbol.iterator]()
-    let index = 0
-
-    const next = async (total) => {
-      const element = iterator.next()
-
-      if (element.done) {
-        resolve(total)
-        return
-      }
-
-      try {
-        const [resolvedTotal, resolvedValue] = await Promise.all([total, element.value])
-        next(reducer(resolvedTotal, resolvedValue, index++))
-      } catch (error) {
-        reject(error)
-      }
-    }
-
-    next(initialValue)
-  })
-}
-
-
-
-;// ./lib/helpers/generalPost/generalPost.js
-
-
-
-
-
-async function generalPost({ body = {}, GeneralModel, UniqueKeyGenerator, resourceInfo }) {
-  const { resources, data, globalShared = {}, shared = {}, relationship = {} } = body
-  const _resourceInfo = resourceInfo || body.resourceInfo
-  _attachShared(data, globalShared, shared)
-  const obj = await pReduce(resources, async (acc, resource) => {
-    const service = _makeService(resource, _resourceInfo, UniqueKeyGenerator, GeneralModel)
-    _createRelationship(data, relationship[resource], acc)
-    const _data = data[resource]
-    const result = await service.saveAll({ docs: [].concat(_data) })
-    acc[resource] = Array.isArray(_data) ? result._data : result._data[0]
-    return acc
-  }, {})
-  return obj
-}
-
-function _attachShared(data, globalShared = {}, shared = {}) {
-  Object.keys(shared).forEach((key) => {
-    const _data = data[key]
-    if (Array.isArray(_data)) {
-      data[key] = _data.map((_dataItem) => {
-        return objectHelper.merge({}, _dataItem, globalShared, shared[key] || {})
-      })
-    } else {
-      data[key] = objectHelper.merge({}, _data, globalShared, shared[key] || {})
-    }
-  })
-}
-
-function _createRelationship(data, relationship = {}, object) {
-  Object.keys(relationship).forEach((key) => {
-    const path = relationship[key]
-    const val = objectHelper.get(object, path)
-    objectHelper.set(data, key, val)
-  })
-}
-
-function _makeService(resource, resourceInfo, UniqueKeyGenerator, GeneralModel) {
-  const { collectionName, fields } = resourceInfo[resource]
-  const uniqueKeyGenerator = UniqueKeyGenerator.makeGenerator(fields)
-  const model = new GeneralModel({ collectionName, uniqueKeyGenerator })
-  return makeService({
-    repo: new Repo({ model })
-  })
-}
-
-
-
-;// ./lib/helpers/generalPost/index.js
-
-
-
-
-;// ./lib/helpers/getObjectByArr/getObjectByArr.js
-
-
-function getObjectByArr(arr, data, getValueByKeys, getValidation, KeyValueObject) {
-  const _KeyValueObject = KeyValueObject || keyValueObject_KeyValueObject
-  if (!Array.isArray(arr) || arr.length === 0) {
-    return null
-  }
-  return arr.reduce((acc, e) => {
-    const { key, type, value, restriction } = e
-    const isValid = getValidation && typeof getValidation === 'function' ? getValidation({ rule: restriction, data }) : true
-    if (isValid) {
-      let _value = value
-      switch (type) {
-        case 'array': {
-          // _value = _getObjectByArr(value, data, getValueByKeys, getValidation)
-          _value = value.map((el) => {
-            const result = getValueByKeys({ keys: el.value.split('.'), obj: data })
-            return result
-          })
-          break
-        }
-        case 'fromKeyValue': {
-          const { dataPath, key: valueKey } = value
-          const keyValues = getValueByKeys({ keys: dataPath.split('.'), obj: data })
-          _value = _KeyValueObject.getValuesByKey(keyValues, valueKey)[0]
-          break
-        }
-        case 'toKeyValue': {
-          const keyValues = getValueByKeys({ keys: value.split('.'), obj: data })
-          _value = _KeyValueObject.fromObject(keyValues)
-          break
-        }
-        case 'nested': {
-          _value = getObjectByArr(value, data, getValueByKeys, getValidation)
-          break
-        }
-        case 'path': {
-          _value = getValueByKeys({ keys: value.split('.'), obj: data })
-          break
-        }
-        // should be deleted
-        case 'orgin': {
-          _value = value
-          break
-        }
-        case 'origin': {
-          _value = value
-          break
-        }
-        default: {
-          _value = value
-          break
-        }
-      }
-      if (key) {
-        return {
-          ...acc,
-          [key]: _value,
-        }
-      }
-      if (typeof _value === 'string') {
-        return _value
-      }
-      return {
-        ...acc,
-        ..._value,
-      }
-    }
-    return acc
-  }, {})
-}
-
-
-/* harmony default export */ const getObjectByArr_getObjectByArr = ({
-  getObjectByArr,
-});
-
-
-;// ./lib/helpers/getObjectByArr/index.js
-
-
-;// ./lib/helpers/groupArrayByKey/groupArrayByKey.js
-function groupArrayByKey(arr, key) {
-  if (!key || typeof key !== 'string') {
-    return {}
-  }
-  return arr.reduce((acc, curr) => {
-    if (!acc[curr[key]]) {
-      acc[curr[key]] = 0
-    }
-    acc[curr[key]]++
-    return acc
-  }, {})
-}
-
-;// ./lib/helpers/groupArrayByKey/index.js
-
-
-;// ./lib/helpers/init/init.js
-function init(_class, options) {
-  if (options instanceof _class) {
-    return options
-  }
-  try {
-    const instance = new _class(options)
-    return instance.isValid !== false ? instance : null
-  } catch (e) {
-    console.log(`init failed for class: ${_class._classname || 'no _classname'}`, e)
-    return null
-  }
-}
-
-;// ./lib/helpers/init/index.js
-
-
-;// ./lib/helpers/initFromArray/initFromArray.js
-
-
-function initFromArray(_class, arr) {
-  if (Array.isArray(arr)) {
-    return arr.map((a) => init(_class, a))
-  }
-  return []
-}
-
-;// ./lib/helpers/initFromArray/index.js
-
-
-;// ./lib/helpers/initOnlyValidFromArray/initOnlyValidFromArray.js
-
-
-function initOnlyValidFromArray(_class, arr) {
-  return initFromArray(_class, arr).filter((i) => i)
-}
-
-;// ./lib/helpers/initOnlyValidFromArray/index.js
-
-
-;// ./lib/helpers/isConvertibleToNumber/index.js
-
-
-;// ./lib/helpers/mergeArraysByKey/mergeArraysByKey.js
-function mergeArraysByKey(arr1, arr2) {
-  // Handle undefined/null inputs by defaulting to empty arrays
-  const safeArr1 = Array.isArray(arr1) ? arr1 : []
-  const safeArr2 = Array.isArray(arr2) ? arr2 : []
-
-  const mergedMap = new Map()
-
-  // Helper function to merge values based on their type
-  const mergeValues = (existingValue, newValue) => {
-    if (existingValue === undefined)
-      return newValue
-
-    // Handle arrays by concatenating
-    if (Array.isArray(existingValue) && Array.isArray(newValue)) {
-      return [...new Set([...existingValue, ...newValue])]
-    }
-
-    // Handle objects by merging
-    if (typeof existingValue === 'object' && typeof newValue === 'object'
-      && !Array.isArray(existingValue) && !Array.isArray(newValue)) {
-      return { ...existingValue, ...newValue }
-    }
-
-    // // Handle numbers by adding
-    // if (typeof existingValue === 'number' && typeof newValue === 'number') {
-    //   return existingValue
-    // }
-
-    // // Handle strings by concatenating
-    // if (typeof existingValue === 'string' && typeof newValue === 'string') {
-    //   return existingValue
-    // }
-
-    // Default: use the new value
-    return newValue
-  }
-
-  // Process first array
-  safeArr1.forEach((item) => {
-    mergedMap.set(item.key, item.value)
-  })
-
-  // Process second array and merge values
-  safeArr2.forEach((item) => {
-    const existingValue = mergedMap.get(item.key)
-    mergedMap.set(item.key, mergeValues(existingValue, item.value))
-  })
-
-  // Convert back to array format
-  return Array.from(mergedMap.entries()).map(([key, value]) => ({
-    key,
-    value
-  }))
-}
-
-;// ./lib/helpers/mergeArraysByKey/index.js
-
-
-;// ./lib/helpers/padZeros/padZeros.js
-function padZeros(num, minLength = 6) {
-  num = num.toString()
-  if (num.length < minLength) {
-    return padZeros(`0${num}`, minLength)
-  }
-  return num
-}
-
-
-
-;// ./lib/helpers/padZeros/index.js
-
-
-
-
-;// ./lib/helpers/pMap/pMap.js
-async function pMap(
-  iterable,
-  mapper,
-  {
-    concurrency = Number.POSITIVE_INFINITY,
-    stopOnError = true,
-    signal,
-  } = {},
-) {
-  return new Promise((resolve_, reject_) => {
-    if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
-      throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`)
-    }
-
-    if (typeof mapper !== 'function') {
-      throw new TypeError('Mapper function is required')
-    }
-
-    if (!((Number.isSafeInteger(concurrency) && concurrency >= 1) || concurrency === Number.POSITIVE_INFINITY)) {
-      throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`)
-    }
-
-    const result = []
-    const errors = []
-    const skippedIndexesMap = new Map()
-    let isRejected = false
-    let isResolved = false
-    let isIterableDone = false
-    let resolvingCount = 0
-    let currentIndex = 0
-    const iterator = iterable[Symbol.iterator] === undefined ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]()
-
-    const signalListener = () => {
-      reject(signal.reason)
-    }
-
-    const cleanup = () => {
-      signal?.removeEventListener('abort', signalListener)
-    }
-
-    const resolve = (value) => {
-      resolve_(value)
-      cleanup()
-    }
-
-    const reject = (reason) => {
-      isRejected = true
-      isResolved = true
-      reject_(reason)
-      cleanup()
-    }
-
-    if (signal) {
-      if (signal.aborted) {
-        reject(signal.reason)
-      }
-
-      signal.addEventListener('abort', signalListener, { once: true })
-    }
-
-    const next = async () => {
-      if (isResolved) {
-        return
-      }
-
-      const nextItem = await iterator.next()
-
-      const index = currentIndex
-      currentIndex++
-
-      // Note: `iterator.next()` can be called many times in parallel.
-      // This can cause multiple calls to this `next()` function to
-      // receive a `nextItem` with `done === true`.
-      // The shutdown logic that rejects/resolves must be protected
-      // so it runs only one time as the `skippedIndex` logic is
-      // non-idempotent.
-      if (nextItem.done) {
-        isIterableDone = true
-
-        if (resolvingCount === 0 && !isResolved) {
-          if (!stopOnError && errors.length > 0) {
-            reject(new AggregateError(errors)) // eslint-disable-line unicorn/error-message
-            return
-          }
-
-          isResolved = true
-
-          if (skippedIndexesMap.size === 0) {
-            resolve(result)
-            return
-          }
-
-          const pureResult = []
-
-          // Support multiple `pMapSkip`'s.
-          for (const [index, value] of result.entries()) {
-            if (skippedIndexesMap.get(index) === pMapSkip) {
-              continue
-            }
-
-            pureResult.push(value)
-          }
-
-          resolve(pureResult)
-        }
-
-        return
-      }
-
-      resolvingCount++;
-
-      // Intentionally detached
-      (async () => {
-        try {
-          const element = await nextItem.value
-
-          if (isResolved) {
-            return
-          }
-
-          const value = await mapper(element, index)
-
-          // Use Map to stage the index of the element.
-          if (value === pMapSkip) {
-            skippedIndexesMap.set(index, value)
-          }
-
-          result[index] = value
-
-          resolvingCount--
-          await next()
-        } catch (error) {
-          if (stopOnError) {
-            reject(error)
-          } else {
-            errors.push(error)
-            resolvingCount--
-
-            // In that case we can't really continue regardless of `stopOnError` state
-            // since an iterable is likely to continue throwing after it throws once.
-            // If we continue calling `next()` indefinitely we will likely end up
-            // in an infinite loop of failed iteration.
-            try {
-              await next()
-            } catch (error) {
-              reject(error)
-            }
-          }
-        }
-      })()
-    };
-
-    // Create the concurrent runners in a detached (non-awaited)
-    // promise. We need this so we can await the `next()` calls
-    // to stop creating runners before hitting the concurrency limit
-    // if the iterable has already been marked as done.
-    // NOTE: We *must* do this for async iterators otherwise we'll spin up
-    // infinite `next()` calls by default and never start the event loop.
-    (async () => {
-      for (let index = 0; index < concurrency; index++) {
-        try {
-          await next()
-        } catch (error) {
-          reject(error)
-          break
-        }
-
-        if (isIterableDone || isRejected) {
-          break
-        }
-      }
-    })()
-  })
-}
-
-function pMapIterable(
-  iterable,
-  mapper,
-  {
-    concurrency = Number.POSITIVE_INFINITY,
-    backpressure = concurrency,
-  } = {},
-) {
-  if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
-    throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`)
-  }
-
-  if (typeof mapper !== 'function') {
-    throw new TypeError('Mapper function is required')
-  }
-
-  if (!((Number.isSafeInteger(concurrency) && concurrency >= 1) || concurrency === Number.POSITIVE_INFINITY)) {
-    throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`)
-  }
-
-  if (!((Number.isSafeInteger(backpressure) && backpressure >= concurrency) || backpressure === Number.POSITIVE_INFINITY)) {
-    throw new TypeError(`Expected \`backpressure\` to be an integer from \`concurrency\` (${concurrency}) and up or \`Infinity\`, got \`${backpressure}\` (${typeof backpressure})`)
-  }
-
-  return {
-    async* [Symbol.asyncIterator]() {
-      const iterator = iterable[Symbol.asyncIterator] === undefined ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]()
-
-      const promises = []
-      let pendingPromisesCount = 0
-      let isDone = false
-      let index = 0
-
-      function trySpawn() {
-        if (isDone || !(pendingPromisesCount < concurrency && promises.length < backpressure)) {
-          return
-        }
-
-        pendingPromisesCount++
-
-        const promise = (async () => {
-          const { done, value } = await iterator.next()
-
-          if (done) {
-            pendingPromisesCount--
-            return { done: true }
-          }
-
-          // Spawn if still below concurrency and backpressure limit
-          trySpawn()
-
-          try {
-            const returnValue = await mapper(await value, index++)
-
-            pendingPromisesCount--
-
-            if (returnValue === pMapSkip) {
-              const index = promises.indexOf(promise)
-
-              if (index > 0) {
-                promises.splice(index, 1)
-              }
-            }
-
-            // Spawn if still below backpressure limit and just dropped below concurrency limit
-            trySpawn()
-
-            return { done: false, value: returnValue }
-          } catch (error) {
-            pendingPromisesCount--
-            isDone = true
-            return { error }
-          }
-        })()
-
-        promises.push(promise)
-      }
-
-      trySpawn()
-
-      while (promises.length > 0) {
-        const { error, done, value } = await promises[0]
-
-        promises.shift()
-
-        if (error) {
-          throw error
-        }
-
-        if (done) {
-          return
-        }
-
-        // Spawn if just dropped below backpressure limit and below the concurrency limit
-        trySpawn()
-
-        if (value === pMapSkip) {
-          continue
-        }
-
-        yield value
-      }
-    },
-  }
-}
-
-const pMapSkip = Symbol('skip')
-
-;// ./lib/helpers/pMap/index.js
-
-
-;// ./lib/helpers/pReduce/index.js
-
-
-
-
-;// ./lib/helpers/replacePlaceholders/replacePlaceholders.js
-function replacePlaceholders({ content, mapping }) {
-  let isObjectMode = false
-
-  if (typeof content === 'object' && content !== null) {
-    content = JSON.stringify(content)
-    isObjectMode = true
-  }
-
-  /** 
-  // [[ eventRegistration.eventRegistrationCode | 0  ]]
-  const regex = /(\[*)\[\[\s*([\w.\-]+)(?:\s*\|\s*([^:\]\s]+))?(?:\s*:\s*([^\]\s]+))?\s*\]\](\]*)/g
-
-  const result = content.replace(regex, (match, leadingBrackets, path, defaultValue, type, trailingBrackets) => {
-    // Split the path into parts
-    const keys = path.trim().split('.')
-
-    // Traverse the nested object structure
-    let value = mapping
-    for (const key of keys) {
-      // Handle empty keys (in case of double dots or leading/trailing dots)
-      if (!key)
-        continue
-
-      value = value?.[key]
-      if (value === undefined) {
-        break
-      }
-    }
-
-    // Apply default if missing
-    if (value === undefined)
-      value = defaultValue?.trim()
-    if (value === undefined)
-      return isObjectMode ? undefined : match
-
-    value = value !== undefined
-      ? leadingBrackets + value + trailingBrackets
-      : match
-
-    // Return replacement or original if not found
-    return value
-  })
-    */
-
-  // Regex to match both simple and complex expressions
-  const regex = /\[\[\s*([^[\]]+?)\s*\]\]/g;
-
-  const result = content.replace(regex, (match, expression) => {
-    // Trim whitespace from the expression
-    const trimmedExpr = expression.trim();
-    
-    // Check if it's a simple path (alphanumeric, dots, hyphens only)
-    if (/^[\w.\-]+$/.test(trimmedExpr)) {
-      // Try to find this path in the mapping
-      const keys = trimmedExpr.split('.');
-      let value = mapping;
-      
-      for (const key of keys) {
-        if (!key) continue;
-        value = value?.[key];
-        if (value === undefined) break;
-      }
-      
-      // If found in mapping, return the value
-      if (value !== undefined) {
-        return value;
-      }
-    }
-    
-    // For complex expressions or unmatched simple expressions, convert to EJS syntax
-    return `<%= ${trimmedExpr} %>`;
-  })
-
-  if (isObjectMode) {
-    return JSON.parse(result)
-  }
-  return result
-}
-
-;// ./lib/helpers/replacePlaceholders/index.js
-
-
-;// ./lib/helpers/sanitizeText/sanitizeText.js
-/**
- * Sanitizes input by removing hidden/control characters with customizable whitespace handling.
- * @param {string} input - The string to sanitize.
- * @param {object} [options] - Configuration options.
- * @param {boolean} [options.normalizeWhitespace] - Collapse multiple spaces/tabs into one space.
- * @param {boolean} [options.removeNewlines] - If true, replaces newlines with spaces.
- * @param {boolean} [options.trim] - If true, trims leading/trailing whitespace.
- * @param {boolean} [options.debug] - If true, logs debug information about removed characters.
- * @returns {string} The sanitized string.
- */
-function sanitizeText(input, options = {}) {
-  const {
-    normalizeWhitespace = true,
-    removeNewlines = false,
-    trim = true,
-    preserveBasicWhitespace = true,
-    debug = false, // new option for debugging
-  } = options
-
-  if (typeof input !== 'string') {
-    return input
-  }
-
-  let result = input
-
-  if (debug) {
-    console.log('Original input:', JSON.stringify(input))
-    console.log('Options:', { normalizeWhitespace, removeNewlines, trim, preserveBasicWhitespace })
-  }
-
-  // Phase 1: Remove all control characters except basic whitespace if requested
-  if (preserveBasicWhitespace && !removeNewlines) {
-    if (debug) {
-      const before = result
-      const matches = []
-      // Use a replacer function to capture what's being removed
-      result = result.replace(/[\x00-\x08\v\f\x0E-\x1F\x7F-\x9F\u200B-\u200D\uFEFF\u202A-\u202E]/g, (match) => {
-        matches.push({
-          char: match,
-          code: match.charCodeAt(0),
-          hex: `0x${match.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`
-        })
-        return ''
-      })
-      if (matches.length > 0) {
-        console.log('Phase 1 (preserve mode) - Removed characters:')
-        matches.forEach((m) => {
-          console.log(`  - Character: ${JSON.stringify(m.char)}, Code: ${m.code}, Hex: ${m.hex}`)
-        })
-        console.log(`Removed ${matches.length} control character(s)`)
-      } else {
-        console.log('Phase 1 (preserve mode) - No control characters found')
-      }
-    } else {
-      result = result.replace(/[\x00-\x08\v\f\x0E-\x1F\x7F-\x9F\u200B-\u200D\uFEFF\u202A-\u202E]/g, '')
-    }
-  } else {
-    if (debug) {
-      const before = result
-      const matches = []
-      result = result.replace(/[\x00-\x1F\x7F-\x9F\u200B-\u200D\uFEFF\u202A-\u202E]/g, (match) => {
-        matches.push({
-          char: match,
-          code: match.charCodeAt(0),
-          hex: `0x${match.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`
-        })
-        return ''
-      })
-      if (matches.length > 0) {
-        console.log('Phase 1 (full removal mode) - Removed characters:')
-        matches.forEach((m) => {
-          console.log(`  - Character: ${JSON.stringify(m.char)}, Code: ${m.code}, Hex: ${m.hex}`)
-        })
-        console.log(`Removed ${matches.length} control character(s)`)
-      } else {
-        console.log('Phase 1 (full removal mode) - No control characters found')
-      }
-    } else {
-      result = result.replace(/[\x00-\x1F\x7F-\x9F\u200B-\u200D\uFEFF\u202A-\u202E]/g, '')
-    }
-  }
-
-  if (debug) {
-    console.log('After Phase 1:', JSON.stringify(result))
-  }
-
-  // Phase 2: Handle whitespace transformations
-  if (removeNewlines) {
-    if (debug) {
-      const before = result
-      result = result.replace(/[\r\n]+/g, ' ')
-      console.log('Phase 2 - Converted newlines to spaces')
-    } else {
-      result = result.replace(/[\r\n]+/g, ' ')
-    }
-  }
-
-  if (normalizeWhitespace) {
-    if (debug) {
-      const before = result
-      result = result.replace(/[ \t]+/g, ' ')
-      console.log('Phase 2 - Normalized whitespace')
-    } else {
-      result = result.replace(/[ \t]+/g, ' ')
-    }
-  }
-
-  if (debug) {
-    console.log('After Phase 2:', JSON.stringify(result))
-  }
-
-  // Phase 3: Final trimming
-  if (trim) {
-    if (debug) {
-      const before = result
-      result = result.trim()
-      console.log('Phase 3 - Trimmed leading/trailing whitespace')
-    } else {
-      result = result.trim()
-    }
-  }
-
-  if (debug) {
-    console.log('Final result:', JSON.stringify(result))
-    console.log('--- Sanitization complete ---')
-  }
-
-  return result
-}
-
-;// ./lib/helpers/sanitizeText/index.js
-
-
-;// ./lib/helpers/shuffleArray/shuffleArray.js
-function shuffleArray(array) {
-  const arr = [...array]
-  for (let i = arr.length - 1; i >= 0; i--) { // Changed `i > 0` to `i >= 0`
-    const j = Math.floor(Math.random() * (i + 1));
-    [arr[i], arr[j]] = [arr[j], arr[i]]
-  }
-  return arr
-}
-
-;// ./lib/helpers/shuffleArray/index.js
-
-
-;// ./lib/helpers/stringFormatter/index.js
-
-
-
-
-;// ./lib/helpers/stringHelper/stringHelper.js
-function baseXEncode(num, base = 34) {
-  const charset = getBaseCharset(base)
-  return encode(num, charset)
-}
-
-function encode(int, charset) {
-  const { byCode } = charset
-  if (int === 0) {
-    return byCode[0]
-  }
-
-  let res = ''
-  const max = charset.length
-  while (int > 0) {
-    res = byCode[int % max] + res
-    int = Math.floor(int / max)
-  }
-  return res
-}
-
-function getBaseCharset(base) {
-  let charset = '9876543210ABCDEFGHJKLMNPQRSTUVWXYZ'
-  if (base === 58) {
-    charset = '9876543210ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz'
-  }
-  return indexCharset(charset)
-}
-
-function indexCharset(str) {
-  const byCode = {}
-  const byChar = {}
-  const { length } = str
-  let char
-  for (let i = 0; i < length; i++) {
-    char = str[i]
-    byCode[i] = char
-    byChar[char] = i
-  }
-  return { byCode, byChar, length }
-}
-
-function isSame(str1, str2) {
-  if (typeof str1 !== 'string' || typeof str2 !== 'string') {
-    return false
-  }
-  return str1.trim().toUpperCase() === str2.trim().toUpperCase()
-}
-
-function randomString({ len = 16, pattern = 'a1' } = {}) {
-  const A = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-  const a = 'abcdefghijklmnopqrstuvwxyz'
-  const num = '1234567890'
-  const mark = '~!@#$%^&*_+-='
-  let str = ''
-  if (pattern.includes('A')) {
-    str += A
-  }
-  if (pattern.includes('a')) {
-    str += a
-  }
-  if (pattern.includes('1')) {
-    str += num
-  }
-  if (pattern.includes('#')) {
-    str += mark
-  }
-  const chars = [...str]
-  return [...new Array(len)].map((i) => {
-    return chars[(Math.random() * chars.length) | 0]
-  }).join``
-}
-
-function reverse(str) {
-  const _str = (typeof str !== 'string') ? str.toString() : str
-  const splitString = _str.split('')
-  const reverseArray = splitString.reverse()
-  return reverseArray.join('')
-}
-
-function setCode(base = 34) {
-  const now = (new Date()).valueOf()
-  const random = randomString({
-    len: 8,
-    pattern: '1'
-  })
-  const str = reverse(`${now}${random}`)
-  // const str = `${now}${random}`
-  return baseXEncode(str, base)
-}
-
-function toCamelCase(str) {
-  if (!str)
-    return ''
-  return str
-    .trim()
-    .split(/\s+/)
-    .map((word, index) => {
-      if (!word)
-        return ''
-      if (index === 0) {
-        return word.toLowerCase()
-      }
-      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
-    })
-    .join('')
-}
-
-function toLowerCase(str) {
-  if (!str)
-    return ''
-  return str
-    .trim()
-    .toLowerCase()
-}
-
-function toScreamingSnakeCase(str) {
-  return str
-    .replace(/([a-z])([A-Z])/g, '$1_$2')
-    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
-    .toUpperCase()
-}
-
-const stringHelper = {
-  isSame,
-  setCode,
-  toCamelCase,
-  toLowerCase,
-  toScreamingSnakeCase,
-}
-
-
-
-;// ./lib/helpers/stringHelper/index.js
-
-
-
-
-;// ./lib/helpers/trackingPlugin/trackingPlugin.js
-function trackingPlugin(schema, options) {
-  // Add meta fields
-  schema.add({
-    meta: {
-      active: { type: Boolean, default: true },
-      created: { type: Number },
-      creator: { type: String },
-      deleted: { type: Boolean, default: false },
-      modified: { type: Number },
-      owner: { type: String },
-    }
-  })
-
-  // Auto-update hook
-  schema.pre('save', function (next) {
-    this.meta.modified = Date.now()
-    next()
-  })
-
-  // Add core indexes
-  schema.index({
-    'meta.active': 1,
-    'meta.deleted': 1
-  }, {
-    name: 'tracking_status_index',
-    background: true,
-    partialFilterExpression: {
-      'meta.active': true,
-      'meta.deleted': false
-    }
-  })
-
-  // Optional: Add helper methods
-  // schema.methods.touch = function(userId) {
-  //   this.meta.updatedAt = new Date()
-  //   this.meta.updatedBy = userId
-  // }
-}
-
-;// ./lib/helpers/tenantPlugin/tenantPlugin.js
-
-
-function tenantPlugin(schema, options) {
-  // Apply tracking plugin first if not already present
-  if (!schema.path('meta')) {
-    trackingPlugin(schema, options)
-  }
-
-  // Add tenant-specific fields
-  schema.add({
-    metadata: [{ type: Object }], // Instead of Schema.Types.Mixed
-    remarks: [{ type: Object }],
-    tenantCode: { type: String, required: true }
-  })
-
-  // Add core indexes
-  schema.index({
-    tenantCode: 1
-  }, {
-    name: 'tenant_core_index',
-    background: true
-  })
-
-  // 1. ENHANCE EXISTING TRACKING INDEXES
-  const existingIndexes = schema.indexes()
-
-  // Check if tracking_status_index exists
-  const hasTenantStatusIndex = existingIndexes.some((idx) =>
-    idx.name === 'tenant_status_index' // Check by name for reliability
-  )
-
-  if (!hasTenantStatusIndex) {
-    schema.index({
-      tenantCode: 1, // Unique field first
-      _type: 1, // Low-cardinality field last
-    }, {
-      name: 'tenant_status_index',
-      background: true,
-      partialFilterExpression: {
-        '_type': 'Tenant',
-        'meta.active': true,
-        'meta.deleted': false
-      }
-    })
-  }
-}
-
-;// ./lib/helpers/tenantPlugin/index.js
-
-
-;// ./lib/helpers/trackingPlugin/index.js
-
-
-;// ./lib/helpers/index.js
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-;// ./lib/index.js
-
-
-
-;// ./index.js
-
-
-/******/ 	return __webpack_exports__;
-/******/ })()
-;
-});