@enonic/js-utils/dist/esm/index.mjs

Enonic XP JavaScript Utils

var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};

// array/index.ts
var array_exports = {};
__export(array_exports, {
  findIndex: () => findIndex,
  flatten: () => flatten,
  forceArray: () => forceArray,
  includes: () => includes,
  isStringArray: () => isStringArray,
  sortByProperty: () => sortByProperty
});

// value/isStringLiteral.ts
var isStringLiteral = (value) => typeof value === "string";

// array/isStringArray.ts
function isStringArray(value) {
  return Array.isArray(value) && value.every(isStringLiteral);
}

// array/findIndex.ts
function findIndex(array, callbackFn) {
  const length = array.length >>> 0;
  for (let i = 0; i < length; i++) {
    if (callbackFn(array[i], i, array)) {
      return i;
    }
  }
  return -1;
}

// array/flatten.ts
function flatten(arr, d = 1) {
  return d > 0 ? arr.reduce((acc, val) => acc.concat(
    Array.isArray(val) ? flatten(val, d - 1) : val
  ), []) : arr.slice();
}

// array/forceArray.ts
function forceArray(data) {
  return Array.isArray(data) ? data : [data];
}

// array/includes.ts
function sameValueZero(x, y) {
  return x === y || typeof x === "number" && typeof y === "number" && isNaN(x) && isNaN(y);
}
function includes(array, searchElement, fromIndex = 0) {
  if (array == null) {
    throw new TypeError('"array" is null or not defined');
  }
  const o = Object(array);
  const len = o.length >>> 0;
  if (len === 0) {
    return false;
  }
  const n = fromIndex | 0;
  let k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
  while (k < len) {
    if (sameValueZero(o[k], searchElement)) {
      return true;
    }
    k++;
  }
  return false;
}

// value/isBasicObject.ts
var isBasicObject = (value) => typeof value === "object";

// value/isNumber.ts
function isNumber(value) {
  return typeof value === "number" && isFinite(value);
}

// value/isStringObject.ts
var isStringObject = (value) => value instanceof String;

// value/isString.ts
var isString = (value) => isStringLiteral(value) || isStringObject(value);

// value/isSymbol.ts
var isSymbol = (value) => typeof value === "symbol";

// value/isPropertyKey.ts
var isPropertyKey = (value) => isString(value) || isNumber(value) || isSymbol(value);

// value/toStr.ts
function toStr(value, replacer, space = 4) {
  return JSON.stringify(value, replacer, space);
}

// object/hasOwnProperty.ts
function hasOwnProperty(obj, propKey) {
  if (!isBasicObject(obj)) {
    throw new Error(`First parameter to hasOwnProperty must be a basic Object! ${toStr(obj)}`);
  }
  if (!isPropertyKey(propKey)) {
    throw new Error(`Second parameter to hasOwnProperty must be a PropertyKey (string|number|symbol)! ${toStr(propKey)}`);
  }
  return obj.hasOwnProperty(propKey);
}

// value/isObject.ts
var isObject = (value) => Object.prototype.toString.call(value).slice(8, -1) === "Object";

// array/sortBy.ts
function compareNumbers(a, b) {
  return a - b;
}
function compareStrings(a, b, caseSensitive = true) {
  if (!caseSensitive) {
    a = a.toLowerCase();
    b = b.toLowerCase();
  }
  if (a < b) {
    return -1;
  }
  if (a > b) {
    return 1;
  }
  return 0;
}
function sortByProperty(array, propertyName) {
  const localArray = JSON.parse(JSON.stringify(array));
  return localArray.sort((a, b) => {
    if (!isObject(a) || !isObject(b)) {
      throw new TypeError(`sortByProperty: a or b not an object! a:${toStr(a)} b:${toStr(b)}`);
    }
    if (!hasOwnProperty(a, propertyName)) {
      throw new TypeError(`sortByProperty: a doesn't have a property named:'${propertyName}'! a:${toStr(a)}`);
    }
    if (!hasOwnProperty(b, propertyName)) {
      throw new TypeError(`sortByProperty: b doesn't have a property named:'${propertyName}'! b:${toStr(b)}`);
    }
    const valueA = a[propertyName];
    const valueB = b[propertyName];
    if (isNumber(valueA) && isNumber(valueB)) {
      return compareNumbers(
        valueA,
        valueB
      );
    }
    if (isString(valueA) && isString(valueB)) {
      return compareStrings(
        valueA,
        valueB
      );
    }
    throw new TypeError(`sortByProperty: Value of propertyName:${propertyName} is neither number nor string! a:${toStr(a)} b:${toStr(b)}`);
  });
}

// object/deleteIn.ts
function deleteIn(obj, ...paths) {
  if (!obj || !paths) {
    return;
  }
  const uniformPath = [];
  for (let i = 0; i < paths.length; i++) {
    const path = paths[i];
    if (typeof path === "string") {
      path.split(".").forEach((p) => uniformPath.push(p));
    } else if (Array.isArray(path)) {
      path.forEach((p) => uniformPath.push(p));
    } else {
      uniformPath.push(path);
    }
  }
  for (let i = 0; i < uniformPath.length - 1; i++) {
    obj = obj[uniformPath[i]];
    if (typeof obj === "undefined") {
      return;
    }
  }
  delete obj[uniformPath.pop()];
}
var deleteIn_default = deleteIn;

// object/mapKeys.ts
function mapKeys(obj, fn) {
  if (!isObject(obj)) {
    throw new TypeError(`mapKeys: First param must be an object! got:${toStr(obj)}`);
  }
  const result = {};
  const keys3 = Object.keys(obj);
  for (let i = 0; i < keys3.length; i++) {
    const key = keys3[i];
    fn({
      key,
      result,
      value: obj[key]
    });
  }
  return result;
}

// object/lcKeys.ts
function lcKeys(obj) {
  return mapKeys(obj, ({
    key,
    result,
    value
  }) => {
    result[String(key).toLowerCase()] = value;
  });
}

// object/entries.ts
function entries(o) {
  return Object.keys(o).map((key) => [key, o[key]]);
}

// object/getIn.ts
function getIn(source, path, def) {
  if (!Array.isArray(path)) {
    if (isNumber(path)) {
      path = [path];
    } else {
      path = path.split(".");
    }
  }
  let leafKey = path[0];
  let obj = source;
  if (path.length > 1) {
    const pathLength = path.length;
    leafKey = path[pathLength - 1];
    for (let i = 0; i < pathLength - 1; i++) {
      const branchKey = path[i];
      if (!isBasicObject(obj) || !hasOwnProperty(obj, branchKey) || typeof obj[branchKey] === "undefined") {
        return def;
      }
      obj = obj[branchKey];
    }
  }
  if (!isBasicObject(obj) || !hasOwnProperty(obj, leafKey) || typeof obj[leafKey] === "undefined") {
    return def;
  }
  return obj[leafKey];
}

// object/setIn.ts
function isUnsafeKey(key) {
  return key === "__proto__" || key === "constructor" || key === "prototype";
}
function setIn(target, path, value) {
  if (!path || !isObject(target)) return target;
  if (!Array.isArray(path)) {
    path = path.split(".");
  }
  let leafKey = path[0];
  if (isUnsafeKey(leafKey)) {
    throw new Error(`setIn: unsafe root key: "${String(leafKey)}"`);
  }
  let obj = target;
  if (path.length > 1) {
    const pathLength = path.length;
    leafKey = path[pathLength - 1];
    if (isUnsafeKey(leafKey)) {
      throw new Error(`setIn: unsafe leaf key: "${String(leafKey)}"`);
    }
    for (let i = 0; i < pathLength - 1; i++) {
      const branchKey = path[i];
      if (isUnsafeKey(branchKey)) {
        throw new Error(`setIn: unsafe branch key: "${String(branchKey)}"`);
      }
      if (!hasOwnProperty(obj, branchKey)) {
        obj[branchKey] = {};
      }
      obj = obj[branchKey];
    }
  }
  if (typeof value !== "undefined") {
    obj[leafKey] = value;
  } else {
    delete obj[leafKey];
  }
  return target;
}

// object/sortKeys.ts
var { isArray } = Array;
var { keys } = Object;
function sortKeys(obj) {
  if (typeof obj !== "object" || isArray(obj)) {
    throw new Error("sortKeys");
  }
  const newObject = {};
  const sortedKeys = keys(obj).sort();
  for (let i = 0, l = sortedKeys.length; i < l; i++) {
    const k = sortedKeys[i];
    newObject[k] = obj[k];
  }
  return newObject;
}

// object/sortKeysRec.ts
var { isArray: isArray2 } = Array;
var { keys: keys2 } = Object;
function sortKeysRec(obj) {
  if (isArray2(obj)) {
    const newArray = [];
    for (let i = 0, l = obj.length; i < l; i++) {
      newArray[i] = sortKeysRec(obj[i]);
    }
    return newArray;
  }
  if (typeof obj !== "object" || obj === null) {
    return obj;
  }
  const sortedKeys = keys2(obj).sort();
  const newObject = {};
  for (let i = 0, l = sortedKeys.length; i < l; i++) {
    const k = sortedKeys[i];
    newObject[k] = sortKeysRec(obj[k]);
  }
  return newObject;
}

// object/values.ts
function values(o) {
  return Object.keys(o).map((key) => o[key]);
}

// http/constants.ts
var HTTP_REQUEST_MODE_EDIT = "edit";
var HTTP_REQUEST_MODE_INLINE = "inline";
var HTTP_REQUEST_MODE_LIVE = "live";
var HTTP_REQUEST_MODE_PREVIEW = "preview";
var HTTP_REQUEST_MODES = [
  HTTP_REQUEST_MODE_EDIT,
  HTTP_REQUEST_MODE_INLINE,
  HTTP_REQUEST_MODE_LIVE,
  HTTP_REQUEST_MODE_PREVIEW
];

// storage/index.ts
var storage_exports = {};
__export(storage_exports, {
  AGGREGATION_COUNT: () => AGGREGATION_COUNT,
  AGGREGATION_DATE_HISTOGRAM: () => AGGREGATION_DATE_HISTOGRAM,
  AGGREGATION_DATE_RANGE: () => AGGREGATION_DATE_RANGE,
  AGGREGATION_GEO_DISTANCE: () => AGGREGATION_GEO_DISTANCE,
  AGGREGATION_MAX: () => AGGREGATION_MAX,
  AGGREGATION_MIN: () => AGGREGATION_MIN,
  AGGREGATION_RANGE: () => AGGREGATION_RANGE,
  AGGREGATION_STATS: () => AGGREGATION_STATS,
  AGGREGATION_TERMS: () => AGGREGATION_TERMS,
  DSL_EXPRESSION_VALUE_TYPE_DATE_TIME: () => DSL_EXPRESSION_VALUE_TYPE_DATE_TIME2,
  DSL_EXPRESSION_VALUE_TYPE_TIME: () => DSL_EXPRESSION_VALUE_TYPE_TIME2,
  FILTER_CLAUSES: () => FILTER_CLAUSES,
  FILTER_CLAUSE_MUST: () => FILTER_CLAUSE_MUST,
  FILTER_CLAUSE_MUST_NOT: () => FILTER_CLAUSE_MUST_NOT,
  FILTER_CLAUSE_SHOULD: () => FILTER_CLAUSE_SHOULD,
  HIGHLIGHT_FIELD_ALLTEXT: () => HIGHLIGHT_FIELD_ALLTEXT,
  HIGHLIGHT_OPTION_ENCODERS: () => HIGHLIGHT_OPTION_ENCODERS,
  HIGHLIGHT_OPTION_ENCODER_DEFAULT: () => HIGHLIGHT_OPTION_ENCODER_DEFAULT,
  HIGHLIGHT_OPTION_ENCODER_HTML: () => HIGHLIGHT_OPTION_ENCODER_HTML,
  INDEX_CONFIG_DECIDE_BY_TYPE: () => INDEX_CONFIG_DECIDE_BY_TYPE,
  INDEX_CONFIG_DECIDE_BY_TYPE_DEFAULT: () => INDEX_CONFIG_DECIDE_BY_TYPE_DEFAULT,
  INDEX_CONFIG_ENABLED: () => INDEX_CONFIG_ENABLED,
  INDEX_CONFIG_ENABLED_DEFAULT: () => INDEX_CONFIG_ENABLED_DEFAULT,
  INDEX_CONFIG_FULLTEXT: () => INDEX_CONFIG_FULLTEXT,
  INDEX_CONFIG_FULLTEXT_DEFAULT: () => INDEX_CONFIG_FULLTEXT_DEFAULT,
  INDEX_CONFIG_INCLUDE_IN_ALL_TEXT: () => INDEX_CONFIG_INCLUDE_IN_ALL_TEXT,
  INDEX_CONFIG_INCLUDE_IN_ALL_TEXT_DEFAULT: () => INDEX_CONFIG_INCLUDE_IN_ALL_TEXT_DEFAULT,
  INDEX_CONFIG_INDEX_VALUE_PROCESSORS: () => INDEX_CONFIG_INDEX_VALUE_PROCESSORS,
  INDEX_CONFIG_LANGUAGES: () => INDEX_CONFIG_LANGUAGES,
  INDEX_CONFIG_N_GRAM: () => INDEX_CONFIG_N_GRAM,
  INDEX_CONFIG_N_GRAM_DEFAULT: () => INDEX_CONFIG_N_GRAM_DEFAULT,
  INDEX_CONFIG_PATH: () => INDEX_CONFIG_PATH,
  INDEX_CONFIG_PATH_DEFAULT: () => INDEX_CONFIG_PATH_DEFAULT,
  INDEX_CONFIG_TEMPLATES: () => INDEX_CONFIG_TEMPLATES,
  INDEX_CONFIG_TEMPLATE_BY_TYPE: () => INDEX_CONFIG_TEMPLATE_BY_TYPE,
  INDEX_CONFIG_TEMPLATE_FULLTEXT: () => INDEX_CONFIG_TEMPLATE_FULLTEXT,
  INDEX_CONFIG_TEMPLATE_MINIMAL: () => INDEX_CONFIG_TEMPLATE_MINIMAL,
  INDEX_CONFIG_TEMPLATE_NONE: () => INDEX_CONFIG_TEMPLATE_NONE,
  INDEX_CONFIG_TEMPLATE_PATH: () => INDEX_CONFIG_TEMPLATE_PATH,
  QUERY_FUNCTION_FULLTEXT: () => QUERY_FUNCTION_FULLTEXT,
  QUERY_FUNCTION_NGRAM: () => QUERY_FUNCTION_NGRAM,
  QUERY_FUNCTION_PATH_MATCH: () => QUERY_FUNCTION_PATH_MATCH,
  QUERY_FUNCTION_RANGE: () => QUERY_FUNCTION_RANGE,
  QUERY_FUNCTION_STEMMED: () => QUERY_FUNCTION_STEMMED,
  QUERY_OPERATOR_AND: () => QUERY_OPERATOR_AND,
  QUERY_OPERATOR_OR: () => QUERY_OPERATOR_OR,
  SORT_CREATED: () => SORT_CREATED,
  SORT_DISPLAYNAME: () => SORT_DISPLAYNAME,
  SORT_MANUAL: () => SORT_MANUAL,
  SORT_MODIFIED: () => SORT_MODIFIED,
  STEMMING_LANGUAGES: () => STEMMING_LANGUAGES,
  STEMMING_LANGUAGE_CODES: () => STEMMING_LANGUAGE_CODES,
  STEMMING_LANGUAGE_CODE_ARABIC: () => STEMMING_LANGUAGE_CODE_ARABIC,
  STEMMING_LANGUAGE_CODE_ARMENIAN: () => STEMMING_LANGUAGE_CODE_ARMENIAN,
  STEMMING_LANGUAGE_CODE_BASQUE: () => STEMMING_LANGUAGE_CODE_BASQUE,
  STEMMING_LANGUAGE_CODE_BENGALI: () => STEMMING_LANGUAGE_CODE_BENGALI,
  STEMMING_LANGUAGE_CODE_BRAZILIAN: () => STEMMING_LANGUAGE_CODE_BRAZILIAN,
  STEMMING_LANGUAGE_CODE_BULGARIAN: () => STEMMING_LANGUAGE_CODE_BULGARIAN,
  STEMMING_LANGUAGE_CODE_CATALAN: () => STEMMING_LANGUAGE_CODE_CATALAN,
  STEMMING_LANGUAGE_CODE_CHINESE: () => STEMMING_LANGUAGE_CODE_CHINESE,
  STEMMING_LANGUAGE_CODE_CZECH: () => STEMMING_LANGUAGE_CODE_CZECH,
  STEMMING_LANGUAGE_CODE_DANISH: () => STEMMING_LANGUAGE_CODE_DANISH,
  STEMMING_LANGUAGE_CODE_DUTCH: () => STEMMING_LANGUAGE_CODE_DUTCH,
  STEMMING_LANGUAGE_CODE_ENGLISH: () => STEMMING_LANGUAGE_CODE_ENGLISH,
  STEMMING_LANGUAGE_CODE_FINNISH: () => STEMMING_LANGUAGE_CODE_FINNISH,
  STEMMING_LANGUAGE_CODE_FRENCH: () => STEMMING_LANGUAGE_CODE_FRENCH,
  STEMMING_LANGUAGE_CODE_GALICIAN: () => STEMMING_LANGUAGE_CODE_GALICIAN,
  STEMMING_LANGUAGE_CODE_GERMAN: () => STEMMING_LANGUAGE_CODE_GERMAN,
  STEMMING_LANGUAGE_CODE_GREEK: () => STEMMING_LANGUAGE_CODE_GREEK,
  STEMMING_LANGUAGE_CODE_HINDI: () => STEMMING_LANGUAGE_CODE_HINDI,
  STEMMING_LANGUAGE_CODE_HUNGARIAN: () => STEMMING_LANGUAGE_CODE_HUNGARIAN,
  STEMMING_LANGUAGE_CODE_INDONESIAN: () => STEMMING_LANGUAGE_CODE_INDONESIAN,
  STEMMING_LANGUAGE_CODE_IRISH: () => STEMMING_LANGUAGE_CODE_IRISH,
  STEMMING_LANGUAGE_CODE_ITALIAN: () => STEMMING_LANGUAGE_CODE_ITALIAN,
  STEMMING_LANGUAGE_CODE_JAPANESE: () => STEMMING_LANGUAGE_CODE_JAPANESE,
  STEMMING_LANGUAGE_CODE_KOREAN: () => STEMMING_LANGUAGE_CODE_KOREAN,
  STEMMING_LANGUAGE_CODE_LATVIAN: () => STEMMING_LANGUAGE_CODE_LATVIAN,
  STEMMING_LANGUAGE_CODE_LITHUANIAN: () => STEMMING_LANGUAGE_CODE_LITHUANIAN,
  STEMMING_LANGUAGE_CODE_NORWEGIAN: () => STEMMING_LANGUAGE_CODE_NORWEGIAN,
  STEMMING_LANGUAGE_CODE_PERSIAN: () => STEMMING_LANGUAGE_CODE_PERSIAN,
  STEMMING_LANGUAGE_CODE_PORTUGUESE: () => STEMMING_LANGUAGE_CODE_PORTUGUESE,
  STEMMING_LANGUAGE_CODE_ROMANIAN: () => STEMMING_LANGUAGE_CODE_ROMANIAN,
  STEMMING_LANGUAGE_CODE_RUSSIAN: () => STEMMING_LANGUAGE_CODE_RUSSIAN,
  STEMMING_LANGUAGE_CODE_SORANI: () => STEMMING_LANGUAGE_CODE_SORANI,
  STEMMING_LANGUAGE_CODE_SPANISH: () => STEMMING_LANGUAGE_CODE_SPANISH,
  STEMMING_LANGUAGE_CODE_SWEDISH: () => STEMMING_LANGUAGE_CODE_SWEDISH,
  STEMMING_LANGUAGE_CODE_THAI: () => STEMMING_LANGUAGE_CODE_THAI,
  STEMMING_LANGUAGE_CODE_TURKISH: () => STEMMING_LANGUAGE_CODE_TURKISH,
  VALUE_TYPE_ANY: () => VALUE_TYPE_ANY,
  VALUE_TYPE_BOOLEAN: () => VALUE_TYPE_BOOLEAN,
  VALUE_TYPE_DOUBLE: () => VALUE_TYPE_DOUBLE,
  VALUE_TYPE_GEO_POINT: () => VALUE_TYPE_GEO_POINT,
  VALUE_TYPE_INSTANT: () => VALUE_TYPE_INSTANT,
  VALUE_TYPE_LOCAL_DATE: () => VALUE_TYPE_LOCAL_DATE,
  VALUE_TYPE_LOCAL_DATE_TIME: () => VALUE_TYPE_LOCAL_DATE_TIME,
  VALUE_TYPE_LOCAL_TIME: () => VALUE_TYPE_LOCAL_TIME,
  VALUE_TYPE_LONG: () => VALUE_TYPE_LONG,
  VALUE_TYPE_REFERENCE: () => VALUE_TYPE_REFERENCE,
  VALUE_TYPE_SET: () => VALUE_TYPE_SET,
  VALUE_TYPE_STRING: () => VALUE_TYPE_STRING,
  addQueryFilter: () => addQueryFilter,
  and: () => and2,
  detectCommonValueType: () => detectCommonValueType,
  detectValueType: () => detectValueType,
  dirname: () => dirname,
  dsl: () => dsl_exports,
  enonify: () => enonify,
  filter: () => filter_exports,
  fulltext: () => fulltext2,
  group: () => group,
  indexTemplateToConfig: () => indexTemplateToConfig,
  isBooleanDslExpression: () => isBooleanDslExpression_default,
  isBooleanFilter: () => isBooleanFilter,
  isExistsDslExpression: () => isExistsDslExpression,
  isExistsFilter: () => isExistsFilter,
  isFilter: () => isFilter,
  isFulltextDslExpression: () => isFulltextDslExpression,
  isHasValueFilter: () => isHasValueFilter,
  isIdsFilter: () => isIdsFilter,
  isInDslExpression: () => isInDslExpression,
  isLikeDslExpression: () => isLikeDslExpression,
  isMatchAllDslExpression: () => isMatchAllDslExpression,
  isNgramDslExpression: () => isNgramDslExpression,
  isNotExistsFilter: () => isNotExistsFilter,
  isPathMatchDslExpression: () => isPathMatchDslExpression,
  isQueryDsl: () => isQueryDsl,
  isRangeDslExpression: () => isRangeDslExpression,
  isStemmedDslExpression: () => isStemmedDslExpression,
  isTermDslExpression: () => isTermDslExpression,
  join: () => join,
  ngram: () => ngram2,
  or: () => or2,
  query: () => query_exports,
  stemmed: () => stemmed2,
  trimExt: () => trimExt,
  uniqueId: () => uniqueId,
  updateIndexConfigs: () => updateIndexConfigs,
  validateRepoId: () => validateRepoId
});

// storage/aggregation.ts
var AGGREGATION_COUNT = "count";
var AGGREGATION_DATE_HISTOGRAM = "dateHistogram";
var AGGREGATION_DATE_RANGE = "dateRange";
var AGGREGATION_GEO_DISTANCE = "geoDistance";
var AGGREGATION_MAX = "max";
var AGGREGATION_MIN = "min";
var AGGREGATION_RANGE = "range";
var AGGREGATION_STATS = "stats";
var AGGREGATION_TERMS = "terms";

// storage/indexing/constants.ts
var INDEX_CONFIG_ENABLED = "enabled";
var INDEX_CONFIG_DECIDE_BY_TYPE = "decideByType";
var INDEX_CONFIG_FULLTEXT = "fulltext";
var INDEX_CONFIG_INCLUDE_IN_ALL_TEXT = "includeInAllText";
var INDEX_CONFIG_INDEX_VALUE_PROCESSORS = "indexValueProcessors";
var INDEX_CONFIG_LANGUAGES = "languages";
var INDEX_CONFIG_N_GRAM = "nGram";
var INDEX_CONFIG_PATH = "path";
var INDEX_CONFIG_ENABLED_DEFAULT = true;
var INDEX_CONFIG_DECIDE_BY_TYPE_DEFAULT = true;
var INDEX_CONFIG_FULLTEXT_DEFAULT = false;
var INDEX_CONFIG_INCLUDE_IN_ALL_TEXT_DEFAULT = false;
var INDEX_CONFIG_N_GRAM_DEFAULT = false;
var INDEX_CONFIG_PATH_DEFAULT = false;
var INDEX_CONFIG_TEMPLATE_NONE = "none";
var INDEX_CONFIG_TEMPLATE_BY_TYPE = "byType";
var INDEX_CONFIG_TEMPLATE_FULLTEXT = "fulltext";
var INDEX_CONFIG_TEMPLATE_PATH = "path";
var INDEX_CONFIG_TEMPLATE_MINIMAL = "minimal";
var INDEX_CONFIG_TEMPLATES = [
  INDEX_CONFIG_TEMPLATE_NONE,
  INDEX_CONFIG_TEMPLATE_BY_TYPE,
  INDEX_CONFIG_TEMPLATE_FULLTEXT,
  INDEX_CONFIG_TEMPLATE_PATH,
  INDEX_CONFIG_TEMPLATE_MINIMAL
];

// value/isDate.ts
function isDate(value) {
  return Object.prototype.toString.call(value).slice(8, -1) === "Date";
}

// value/isFunction.ts
function isFunction(value) {
  return Object.prototype.toString.call(value).slice(8, -1) === "Function";
}

// value/isInfinity.ts
function isInfinity(value) {
  return typeof value === "number" && !isFinite(value);
}

// storage/indexing/enonify.ts
function enonify(unknown) {
  function shouldBeDeleted(unknown2) {
    return unknown2 === null || typeof unknown2 === "undefined" || isFunction(unknown2) || isInfinity(unknown2) || isNumberButNaN(unknown2);
  }
  function enonifyArray(array) {
    const flattenedAndEnonified = flatten(array).map((v) => enonify(v)).filter((v) => !shouldBeDeleted(v));
    if (flattenedAndEnonified.length === 0) {
      return void 0;
    }
    if (flattenedAndEnonified.length === 1) {
      return flattenedAndEnonified[0];
    }
    return flattenedAndEnonified;
  }
  function isNumberButNaN(unknown2) {
    return typeof unknown2 === "number" && isNaN(unknown2);
  }
  if (isObject(unknown)) {
    Object.keys(unknown).forEach((k) => {
      let value = unknown[k];
      if (Array.isArray(value)) {
        value = enonifyArray(value);
      }
      if (Array.isArray(value)) {
        unknown[k] = value;
      } else {
        if (shouldBeDeleted(value)) {
          delete unknown[k];
        } else {
          unknown[k] = enonify(value);
        }
      }
    });
    return unknown;
  }
  if (Array.isArray(unknown)) {
    return enonifyArray(unknown);
  }
  if (isDate(unknown)) {
    return unknown.toISOString();
  }
  if (isNumberButNaN(unknown)) {
    return void 0;
  }
  if (isInfinity(unknown)) {
    return void 0;
  }
  return unknown;
}

// value/isBigInt.ts
function isBigInt(value) {
  return typeof value === "bigint";
}

// value/isBoolean.ts
function isBoolean(value) {
  return Object.prototype.toString.call(value).slice(8, -1) === "Boolean";
}

// value/isDateString.ts
function isDateString(value) {
  return typeof value === "string" && !isNaN(Date.parse(value));
}

// value/isFalse.ts
function isFalse(value) {
  return value === false;
}

// value/isGeoPointArray.ts
function isGeoPointArray(v) {
  if (!Array.isArray(v) || v.length !== 2) {
    return false;
  }
  const [lat, lon] = v;
  if (!isNumber(lat) && !isNumber(lon)) {
    return false;
  }
  if (lat < -90 || lat > 90) {
    return false;
  }
  if (lon < -180 || lon > 180) {
    return false;
  }
  return true;
}

// value/isGeoPointString.ts
function isGeoPointString(v) {
  if (!isString(v)) {
    return false;
  }
  const array = v.split(",");
  if (array.length !== 2) {
    return false;
  }
  const [lat, lon] = array;
  if (!isString(lat) || !isString(lon)) {
    return false;
  }
  return isGeoPointArray([
    parseFloat(lat),
    parseFloat(lon)
  ]);
}

// value/isGeoPoint.ts
function isGeoPoint(v) {
  return isString(v) ? isGeoPointString(v) : isGeoPointArray(v);
}

// value/isInstantString.ts
var REGEXP_INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}\:\d{2}\:\d{2}(\.\d{0,9})?Z$/;
function isInstantString(v) {
  if (!isString(v)) {
    return false;
  }
  const matches = v.match(REGEXP_INSTANT);
  if (matches) {
    try {
      const d = new Date(Date.parse(matches[0]));
      if (v.substring(0, 19) === d.toISOString().substring(0, 19)) {
        return true;
      }
      return false;
    } catch (e) {
    }
  }
  return false;
}

// value/isInt.ts
function isInt(value) {
  return typeof value === "number" && isFinite(value) && // TODO Is isFinite() available in Enonic XP?
  Math.floor(value) === value;
}

// value/isInteger.ts
var isInteger = "isInteger" in Number && isFunction(Number.isInteger) ? Number.isInteger : isInt;

// value/isLocalDateString.ts
var REGEXP_DATE = /^\d{4}-\d{2}-\d{2}$/;
function isLocalDateString(v) {
  if (!isString(v)) {
    return false;
  }
  const matches = v.match(REGEXP_DATE);
  if (matches) {
    try {
      const d = new Date(Date.parse(matches[0]));
      if (v.substring(0, 10) === d.toISOString().substring(0, 10)) {
        return true;
      }
      return false;
    } catch (e) {
    }
  }
  return false;
}

// value/isLocalDateTimeString.ts
var REGEXP_DATE2 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d{0,9})?)?$/;
function isLocalDateTimeString(v) {
  if (!isString(v)) {
    return false;
  }
  const matches = v.match(REGEXP_DATE2);
  if (matches) {
    const localDateTimeStringToParse = `${matches[0].substring(0, 19)}Z`;
    try {
      const d = new Date(Date.parse(localDateTimeStringToParse));
      let inputTrimmed = v.substring(0, 19);
      if (inputTrimmed.length === 16) {
        inputTrimmed += ":00";
      }
      const parsedTrimmed = d.toJSON().substring(0, 19);
      if (inputTrimmed === parsedTrimmed) {
        return true;
      }
      return false;
    } catch (e) {
    }
  }
  return false;
}

// value/isNonNegativeIntegerString.ts
function isNonNegativeIntegerString(s) {
  if (!isString(s) || !s.length || s.length > 1 && s.charCodeAt(0) === 48) {
    return false;
  }
  for (let i = s.length - 1; i >= 0; i--) {
    const d = s.charCodeAt(i);
    if (d < 48 || d > 57) {
      return false;
    }
  }
  return true;
}

// value/isNotSet.ts
var isNotSet = (value) => value === null || typeof value === "undefined";

// value/isNull.ts
function isNull(value) {
  return value === null;
}

// value/isPositiveInteger.ts
function isPositiveInteger(v) {
  if (!isInt(v) || v < 0) {
    return false;
  }
  return true;
}

// value/isSet.ts
function isSet(value) {
  if (typeof value === "boolean") {
    return true;
  }
  return value !== null && typeof value !== "undefined";
}

// value/isTimeString.ts
var REGEXP_TIME = /^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9](\.\d{0,9})?)?$/;
function isTimeString(v) {
  if (!isString(v)) {
    return false;
  }
  return REGEXP_TIME.test(v);
}

// value/isTime.ts
function isTime(v) {
  return isDate(v) || isTimeString(v);
}

// value/isTrue.ts
function isTrue(value) {
  return value === true;
}

// value/isUndefined.ts
function isUndefined(value) {
  return typeof value === "undefined";
}

// value/isUuidV4String.ts
var REGEXP = /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
function isUuidV4String(value) {
  return isString(value) ? REGEXP.test(value) : false;
}

// value/index.ts
function isNotFalse(value) {
  return value !== false;
}
function isNotTrue(value) {
  return value !== true;
}

// storage/indexing/indexTemplateToConfig.ts
function indexTemplateToConfig({
  template,
  indexValueProcessors,
  // = [],
  languages
  // = []
}) {
  if (isObject(template)) {
    const configObject = JSON.parse(JSON.stringify(template));
    if (indexValueProcessors) {
      configObject.indexValueProcessors = indexValueProcessors;
    }
    if (languages) {
      configObject.languages = languages;
    }
    return configObject;
  }
  if (template === INDEX_CONFIG_TEMPLATE_NONE) {
    const rv = {
      [INDEX_CONFIG_DECIDE_BY_TYPE]: false,
      [INDEX_CONFIG_ENABLED]: false,
      [INDEX_CONFIG_FULLTEXT]: false,
      [INDEX_CONFIG_INCLUDE_IN_ALL_TEXT]: false
    };
    if (indexValueProcessors) {
      rv[INDEX_CONFIG_INDEX_VALUE_PROCESSORS] = indexValueProcessors;
    }
    if (languages) {
      rv[INDEX_CONFIG_LANGUAGES] = languages;
    }
    rv[INDEX_CONFIG_N_GRAM] = false;
    rv[INDEX_CONFIG_PATH] = false;
    return rv;
  }
  if (template === INDEX_CONFIG_TEMPLATE_BY_TYPE) {
    const rv = {
      [INDEX_CONFIG_DECIDE_BY_TYPE]: true,
      [INDEX_CONFIG_ENABLED]: true,
      [INDEX_CONFIG_FULLTEXT]: false,
      [INDEX_CONFIG_INCLUDE_IN_ALL_TEXT]: false
    };
    if (indexValueProcessors) {
      rv[INDEX_CONFIG_INDEX_VALUE_PROCESSORS] = indexValueProcessors;
    }
    if (languages) {
      rv[INDEX_CONFIG_LANGUAGES] = languages;
    }
    rv[INDEX_CONFIG_N_GRAM] = false;
    rv[INDEX_CONFIG_PATH] = false;
    return rv;
  }
  if (template === INDEX_CONFIG_TEMPLATE_FULLTEXT) {
    const rv = {
      [INDEX_CONFIG_DECIDE_BY_TYPE]: false,
      [INDEX_CONFIG_ENABLED]: true,
      [INDEX_CONFIG_FULLTEXT]: true,
      [INDEX_CONFIG_INCLUDE_IN_ALL_TEXT]: true
    };
    if (indexValueProcessors) {
      rv[INDEX_CONFIG_INDEX_VALUE_PROCESSORS] = indexValueProcessors;
    }
    if (languages) {
      rv[INDEX_CONFIG_LANGUAGES] = languages;
    }
    rv[INDEX_CONFIG_N_GRAM] = true;
    rv[INDEX_CONFIG_PATH] = false;
    return rv;
  }
  if (template === INDEX_CONFIG_TEMPLATE_PATH) {
    const rv = {
      [INDEX_CONFIG_DECIDE_BY_TYPE]: false,
      [INDEX_CONFIG_ENABLED]: true,
      [INDEX_CONFIG_FULLTEXT]: false,
      [INDEX_CONFIG_INCLUDE_IN_ALL_TEXT]: false
    };
    if (indexValueProcessors) {
      rv[INDEX_CONFIG_INDEX_VALUE_PROCESSORS] = indexValueProcessors;
    }
    if (languages) {
      rv[INDEX_CONFIG_LANGUAGES] = languages;
    }
    rv[INDEX_CONFIG_N_GRAM] = false;
    rv[INDEX_CONFIG_PATH] = true;
    return rv;
  }
  if (template === INDEX_CONFIG_TEMPLATE_MINIMAL) {
    const rv = {
      [INDEX_CONFIG_DECIDE_BY_TYPE]: false,
      [INDEX_CONFIG_ENABLED]: true,
      [INDEX_CONFIG_FULLTEXT]: false,
      [INDEX_CONFIG_INCLUDE_IN_ALL_TEXT]: false
    };
    if (indexValueProcessors) {
      rv[INDEX_CONFIG_INDEX_VALUE_PROCESSORS] = indexValueProcessors;
    }
    if (languages) {
      rv[INDEX_CONFIG_LANGUAGES] = languages;
    }
    rv[INDEX_CONFIG_N_GRAM] = false;
    rv[INDEX_CONFIG_PATH] = false;
    return rv;
  }
  throw new Error(`Unknown indexing template:${template}!`);
}

// storage/indexing/path/join.ts
function join(paths, separator = "/") {
  let parts = [];
  for (let i = 0; i < paths.length; i += 1) {
    parts = parts.concat(paths[i].split(separator));
  }
  const newParts = [];
  for (let i = 0; i < parts.length; i += 1) {
    const part = parts[i];
    if (!part || part === ".") continue;
    if (part === "..") newParts.pop();
    else newParts.push(part);
  }
  if (parts[0] === "") newParts.unshift("");
  return newParts.join(separator) || (newParts.length ? separator : ".");
}

// storage/indexing/path/dirname.ts
function dirname(path, separator = "/") {
  return join([path, ".."], separator);
}

// storage/indexing/path/trimExt.ts
function trimExt(s) {
  return s.replace(/\.[^/.]+$/, "");
}

// storage/indexing/stemming.ts
var STEMMING_LANGUAGE_CODE_ARABIC = "ar";
var STEMMING_LANGUAGE_CODE_BULGARIAN = "bg";
var STEMMING_LANGUAGE_CODE_BENGALI = "bn";
var STEMMING_LANGUAGE_CODE_CATALAN = "ca";
var STEMMING_LANGUAGE_CODE_CZECH = "cs";
var STEMMING_LANGUAGE_CODE_DANISH = "da";
var STEMMING_LANGUAGE_CODE_GERMAN = "de";
var STEMMING_LANGUAGE_CODE_GREEK = "el";
var STEMMING_LANGUAGE_CODE_ENGLISH = "en";
var STEMMING_LANGUAGE_CODE_BASQUE = "eu";
var STEMMING_LANGUAGE_CODE_PERSIAN = "fa";
var STEMMING_LANGUAGE_CODE_FINNISH = "fi";
var STEMMING_LANGUAGE_CODE_FRENCH = "fr";
var STEMMING_LANGUAGE_CODE_IRISH = "ga";
var STEMMING_LANGUAGE_CODE_GALICIAN = "gl";
var STEMMING_LANGUAGE_CODE_HINDI = "in";
var STEMMING_LANGUAGE_CODE_HUNGARIAN = "hu";
var STEMMING_LANGUAGE_CODE_ARMENIAN = "hy";
var STEMMING_LANGUAGE_CODE_INDONESIAN = "id";
var STEMMING_LANGUAGE_CODE_ITALIAN = "it";
var STEMMING_LANGUAGE_CODE_JAPANESE = "ja";
var STEMMING_LANGUAGE_CODE_KOREAN = "ko";
var STEMMING_LANGUAGE_CODE_SORANI = "ku";
var STEMMING_LANGUAGE_CODE_LITHUANIAN = "lt";
var STEMMING_LANGUAGE_CODE_LATVIAN = "lv";
var STEMMING_LANGUAGE_CODE_DUTCH = "nl";
var STEMMING_LANGUAGE_CODE_NORWEGIAN = "no";
var STEMMING_LANGUAGE_CODE_PORTUGUESE = "pt";
var STEMMING_LANGUAGE_CODE_BRAZILIAN = "pt-br";
var STEMMING_LANGUAGE_CODE_ROMANIAN = "ro";
var STEMMING_LANGUAGE_CODE_RUSSIAN = "ru";
var STEMMING_LANGUAGE_CODE_SPANISH = "es";
var STEMMING_LANGUAGE_CODE_SWEDISH = "sv";
var STEMMING_LANGUAGE_CODE_TURKISH = "tr";
var STEMMING_LANGUAGE_CODE_THAI = "th";
var STEMMING_LANGUAGE_CODE_CHINESE = "zh";
var STEMMING_LANGUAGE_CODES = [
  STEMMING_LANGUAGE_CODE_ARABIC,
  STEMMING_LANGUAGE_CODE_BULGARIAN,
  STEMMING_LANGUAGE_CODE_BENGALI,
  STEMMING_LANGUAGE_CODE_CATALAN,
  STEMMING_LANGUAGE_CODE_CZECH,
  STEMMING_LANGUAGE_CODE_DANISH,
  STEMMING_LANGUAGE_CODE_GERMAN,
  STEMMING_LANGUAGE_CODE_GREEK,
  STEMMING_LANGUAGE_CODE_ENGLISH,
  STEMMING_LANGUAGE_CODE_BASQUE,
  STEMMING_LANGUAGE_CODE_PERSIAN,
  STEMMING_LANGUAGE_CODE_FINNISH,
  STEMMING_LANGUAGE_CODE_FRENCH,
  STEMMING_LANGUAGE_CODE_IRISH,
  STEMMING_LANGUAGE_CODE_GALICIAN,
  STEMMING_LANGUAGE_CODE_HINDI,
  STEMMING_LANGUAGE_CODE_HUNGARIAN,
  STEMMING_LANGUAGE_CODE_ARMENIAN,
  STEMMING_LANGUAGE_CODE_INDONESIAN,
  STEMMING_LANGUAGE_CODE_ITALIAN,
  STEMMING_LANGUAGE_CODE_JAPANESE,
  STEMMING_LANGUAGE_CODE_KOREAN,
  STEMMING_LANGUAGE_CODE_SORANI,
  STEMMING_LANGUAGE_CODE_LITHUANIAN,
  STEMMING_LANGUAGE_CODE_LATVIAN,
  STEMMING_LANGUAGE_CODE_DUTCH,
  STEMMING_LANGUAGE_CODE_NORWEGIAN,
  STEMMING_LANGUAGE_CODE_PORTUGUESE,
  STEMMING_LANGUAGE_CODE_BRAZILIAN,
  STEMMING_LANGUAGE_CODE_ROMANIAN,
  STEMMING_LANGUAGE_CODE_RUSSIAN,
  STEMMING_LANGUAGE_CODE_SPANISH,
  STEMMING_LANGUAGE_CODE_SWEDISH,
  STEMMING_LANGUAGE_CODE_TURKISH,
  STEMMING_LANGUAGE_CODE_THAI,
  STEMMING_LANGUAGE_CODE_CHINESE
];
var STEMMING_LANGUAGES = [
  {
    code: STEMMING_LANGUAGE_CODE_ARABIC,
    language: "Arabic"
  },
  {
    code: STEMMING_LANGUAGE_CODE_BULGARIAN,
    language: "Bulgarian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_BENGALI,
    language: "Bengali"
  },
  {
    code: STEMMING_LANGUAGE_CODE_CATALAN,
    language: "Catalan"
  },
  {
    code: STEMMING_LANGUAGE_CODE_CZECH,
    language: "Czech"
  },
  {
    code: STEMMING_LANGUAGE_CODE_DANISH,
    language: "Danish"
  },
  {
    code: STEMMING_LANGUAGE_CODE_GERMAN,
    language: "German"
  },
  {
    code: STEMMING_LANGUAGE_CODE_GREEK,
    language: "Greek"
  },
  {
    code: STEMMING_LANGUAGE_CODE_ENGLISH,
    language: "English"
  },
  {
    code: STEMMING_LANGUAGE_CODE_BASQUE,
    language: "Basque"
  },
  {
    code: STEMMING_LANGUAGE_CODE_PERSIAN,
    language: "Persian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_FINNISH,
    language: "Finnish"
  },
  {
    code: STEMMING_LANGUAGE_CODE_FRENCH,
    language: "French"
  },
  {
    code: STEMMING_LANGUAGE_CODE_IRISH,
    language: "Irish"
  },
  {
    code: STEMMING_LANGUAGE_CODE_GALICIAN,
    language: "Galician"
  },
  {
    code: STEMMING_LANGUAGE_CODE_HINDI,
    language: "Hindi"
  },
  {
    code: STEMMING_LANGUAGE_CODE_HUNGARIAN,
    language: "Hungarian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_ARMENIAN,
    language: "Armenian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_INDONESIAN,
    language: "Indonesian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_ITALIAN,
    language: "Italian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_JAPANESE,
    language: "Japanese"
  },
  {
    code: STEMMING_LANGUAGE_CODE_KOREAN,
    language: "Korean"
  },
  {
    code: STEMMING_LANGUAGE_CODE_SORANI,
    language: "Sorani"
  },
  {
    code: STEMMING_LANGUAGE_CODE_LITHUANIAN,
    language: "Lithuanian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_LATVIAN,
    language: "Latvian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_DUTCH,
    language: "Dutch"
  },
  {
    code: STEMMING_LANGUAGE_CODE_NORWEGIAN,
    language: "Norwegian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_PORTUGUESE,
    language: "Portuguese"
  },
  {
    code: STEMMING_LANGUAGE_CODE_BRAZILIAN,
    language: "Brazilian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_ROMANIAN,
    language: "Romanian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_RUSSIAN,
    language: "Russian"
  },
  {
    code: STEMMING_LANGUAGE_CODE_SPANISH,
    language: "Spanish"
  },
  {
    code: STEMMING_LANGUAGE_CODE_SWEDISH,
    language: "Swedish"
  },
  {
    code: STEMMING_LANGUAGE_CODE_TURKISH,
    language: "Turkish"
  },
  {
    code: STEMMING_LANGUAGE_CODE_THAI,
    language: "Thai"
  },
  {
    code: STEMMING_LANGUAGE_CODE_CHINESE,
    language: "Chinese"
  }
];

// constants.ts
var COLON_SIGN = ":";
var DOT_SIGN = ".";
var ELLIPSIS = "\u2026";
var EVENT_TYPE_PREFIX_CUSTOM = "custom";
var EVENT_TYPE_APPLICATION = "application";
var EVENT_TYPE_APPLICATION_CLUSTER = "application.cluster";
var EVENT_TYPE_APPLICATION_CLUSTER_EVENT_TYPE_START = "start";
var EVENT_TYPE_APPLICATION_CLUSTER_EVENT_TYPE_STATE = "state";
var EVENT_TYPE_APPLICATION_CLUSTER_EVENT_TYPE_STOP = "stop";
var EVENT_TYPE_APPLICATION_CLUSTER_EVENT_TYPE_UNINSTALL = "uninstall";
var EVENT_TYPE_APPLICATION_CLUSTER_EVENT_TYPE_UNINSTALLED = "uninstalled";
var EVENT_TYPE_APPLICATION_CLUSTER_EVENT_TYPES = [
  EVENT_TYPE_APPLICATION_CLUSTER_EVENT_TYPE_START,
  EVENT_TYPE_APPLICATION_CLUSTER_EVENT_TYPE_STATE,
  EVENT_TYPE_APPLICATION_CLUSTER_EVENT_TYPE_STOP,
  EVENT_TYPE_APPLICATION_CLUSTER_EVENT_TYPE_UNINSTALL,
  EVENT_TYPE_APPLICATION_CLUSTER_EVENT_TYPE_UNINSTALLED
];
var EVENT_TYPE_APPLICATION_EVENT_TYPE_INSTALLED = "INSTALLED";
var EVENT_TYPE_APPLICATION_EVENT_TYPE_STARTED = "STARTED";
var EVENT_TYPE_APPLICATION_EVENT_TYPE_STOPPED = "STOPPED";
var EVENT_TYPE_APPLICATION_EVENT_TYPE_UNINSTALLED = "UNINSTALLED";
var EVENT_TYPE_APPLICATION_EVENT_TYPES = [
  EVENT_TYPE_APPLICATION_EVENT_TYPE_INSTALLED,
  EVENT_TYPE_APPLICATION_EVENT_TYPE_STARTED,
  EVENT_TYPE_APPLICATION_EVENT_TYPE_STOPPED,
  EVENT_TYPE_APPLICATION_EVENT_TYPE_UNINSTALLED
];
var EVENT_TYPE_NODE_CREATED = "node.created";
var EVENT_TYPE_NODE_DELETED = "node.deleted";
var EVENT_TYPE_NODE_UPDATED = "node.updated";
var EVENT_TYPES_NODE = [
  EVENT_TYPE_NODE_CREATED,
  EVENT_TYPE_NODE_DELETED,
  EVENT_TYPE_NODE_UPDATED
];
var EVENT_TYPE_TASK_FINISHED = "task.finished";
var EVENT_TYPE_TASK_REMOVED = "task.removed";
var EVENT_TYPE_TASK_UPDATED = "task.updated";
var EVENT_TYPES_TASK = [
  EVENT_TYPE_TASK_FINISHED,
  EVENT_TYPE_TASK_REMOVED,
  EVENT_TYPE_TASK_UPDATED
];
var EVENT_TYPES = [
  EVENT_TYPE_APPLICATION,
  EVENT_TYPE_APPLICATION_CLUSTER,
  EVENT_TYPE_NODE_CREATED,
  EVENT_TYPE_NODE_DELETED,
  EVENT_TYPE_NODE_UPDATED,
  EVENT_TYPE_TASK_FINISHED,
  EVENT_TYPE_TASK_REMOVED,
  EVENT_TYPE_TASK_UPDATED
];
var RESPONSE_TYPE_JSON = "text/json;charset=utf-8";
var RESPONSE_TYPE_HTML = "text/html;charset=utf-8";
var PRINCIPAL_ROLE_SYSTEM_ADMIN = "role:system.admin";
var PRINCIPAL_ROLE_SYSTEM_ADMIN_LOGIN = "role:system.admin.login";
var PRINCIPAL_ROLE_SYSTEM_AUTHENTICATED = "role:system.authenticated";
var PRINCIPAL_ROLE_SYSTEM_AUDITLOG = "role:system.auditlog";
var PRINCIPAL_ROLE_SYSTEM_EVERYONE = "role:system.everyone";
var PRINCIPAL_ROLE_SYSTEM_USER_ADMIN = "role:system.user.admin";
var PRINCIPAL_ROLE_SYSTEM_USER_APP = "role:system.user.app";
var PRINCIPAL_USER_SYSTEM_SU = "user:system:su";

// storage/indexing/uniqueId.ts
function uniqueId({
  repoId,
  branchId,
  nodeId,
  versionKey
}) {
  if (!repoId) {
    throw new TypeError("uniqueId: Missing required named parameter repoId!");
  }
  if (!nodeId) {
    throw new TypeError("uniqueId: Missing required named parameter nodeId!");
  }
  const parts = [repoId];
  if (branchId) {
    parts.push(branchId);
  }
  parts.push(nodeId);
  if (versionKey) {
    parts.push(versionKey);
  }
  return parts.join(DOT_SIGN);
}

// storage/indexing/updateIndexConfigs.ts
function updateIndexConfigs({
  configs,
  updates = []
}) {
  const dereffedConfigs = JSON.parse(JSON.stringify(configs));
  for (let i = 0; i < updates.length; i++) {
    const anUpdate = updates[i];
    const j = findIndex(
      dereffedConfigs,
      //({path}: IndexConfigsItem) => path === anUpdate.path
      (item) => item.path === anUpdate.path
    );
    if (j !== -1) {
      dereffedConfigs.splice(j, 1, anUpdate);
    } else {
      dereffedConfigs.push(anUpdate);
    }
  }
  dereffedConfigs.sort(
    (a, b) => a.path > b.path ? 1 : -1
  );
  return dereffedConfigs;
}

// storage/indexing/valueType/constants.ts
var VALUE_TYPE_ANY = "any";
var VALUE_TYPE_BOOLEAN = "boolean";
var VALUE_TYPE_DOUBLE = "double";
var VALUE_TYPE_GEO_POINT = "geoPoint";
var VALUE_TYPE_INSTANT = "instant";
var VALUE_TYPE_LOCAL_DATE = "localDate";
var VALUE_TYPE_LOCAL_DATE_TIME = "localDateTime";
var VALUE_TYPE_LOCAL_TIME = "localTime";
var VALUE_TYPE_LONG = "long";
var VALUE_TYPE_REFERENCE = "reference";
var VALUE_TYPE_SET = "set";
var VALUE_TYPE_STRING = "string";

// storage/indexing/valueType/detectValueType.ts
function detectCommonValueType(array) {
  let anyStringCount = 0;
  let geoPointArrayCount = 0;
  let objectCount = 0;
  let commonValueType;
  for (let i = 0; i < array.length; i++) {
    const value = array[i];
    if (isGeoPointArray(value)) {
      if (!commonValueType) {
        commonValueType = VALUE_TYPE_GEO_POINT;
      } else if (objectCount) {
        return VALUE_TYPE_ANY;
      } else if (commonValueType === VALUE_TYPE_DOUBLE || commonValueType === VALUE_TYPE_GEO_POINT) {
      } else if (anyStringCount) {
        commonValueType = VALUE_TYPE_STRING;
      }
      geoPointArrayCount++;
    } else if (Array.isArray(value)) {
      throw new Error("TODO: Enonic XP doesn't support Matrixes!");
    } else if (isBoolean(value)) {
      if (!commonValueType || commonValueType === VALUE_TYPE_BOOLEAN) {
        commonValueType = VALUE_TYPE_BOOLEAN;
      } else if (objectCount) {
        return VALUE_TYPE_ANY;
      } else if (anyStringCount) {
        commonValueType = VALUE_TYPE_STRING;
      }
    } else if (isDate(value)) {
      if (!commonValueType || commonValueType === VALUE_TYPE_INSTANT) {
        commonValueType = VALUE_TYPE_INSTANT;
      } else if (objectCount) {
        return VALUE_TYPE_ANY;
      } else if (anyStringCount) {
        commonValueType = VALUE_TYPE_STRING;
      }
    } else if (isNumber(value)) {
      if (!commonValueType) {
        commonValueType = VALUE_TYPE_DOUBLE;
      } else if (objectCount) {
        return VALUE_TYPE_ANY;
      } else if (commonValueType === VALUE_TYPE_DOUBLE) {
      } else if (anyStringCount) {
        commonValueType = VALUE_TYPE_STRING;
      } else if (geoPointArrayCount) {
        commonValueType = VALUE_TYPE_DOUBLE;
      }
    } else if (isObject(value)) {
      if (!commonValueType || commonValueType === VALUE_TYPE_SET) {
        commonValueType = VALUE_TYPE_SET;
      } else {
        return VALUE_TYPE_ANY;
      }
      objectCount++;
    } else if (isString(value)) {
      if (isGeoPointString(value)) {
        if (!commonValueType || commonValueType === VALUE_TYPE_GEO_POINT) {
          commonValueType = VALUE_TYPE_GEO_POINT;
        } else if (anyStringCount) {
          commonValueType = VALUE_TYPE_STRING;
        }
      } else if (isInstantString(value)) {
        if (!commonValueType || commonValueType === VALUE_TYPE_INSTANT) {
          commonValueType = VALUE_TYPE_INSTANT;
        } else if (anyStringCount) {
          commonValueType = VALUE_TYPE_STRING;
        }
      } else if (isLocalDateString(value)) {
        if (!commonValueType || commonValueType === VALUE_TYPE_LOCAL_DATE) {
          commonValueType = VALUE_TYPE_LOCAL_DATE;
        } else if (anyStringCount) {
          commonValueType = VALUE_TYPE_STRING;
        }
      } else if (isLocalDateTimeString(value)) {
        if (!commonValueType || commonValueType === VALUE_TYPE_LOCAL_DATE_TIME) {
          commonValueType = VALUE_TYPE_LOCAL_DATE_TIME;
        } else if (anyStringCount) {
          commonValueType = VALUE_TYPE_STRING;
        }
      } else if (isTimeString(value)) {
        if (!commonValueType || commonValueType === VALUE_TYPE_LOCAL_TIME) {
          commonValueType = VALUE_TYPE_LOCAL_TIME;
        } else if (anyStringCount) {
          commonValueType = VALUE_TYPE_STRING;
        }
      } else if (isUuidV4String(value)) {
        if (!commonValueType || commonValueType === VALUE_TYPE_REFERENCE) {
          commonValueType = VALUE_TYPE_REFERENCE;
        } else if (anyStringCount) {
          commonValueType = VALUE_TYPE_STRING;
        }
      } else {
        commonValueType = VALUE_TYPE_STRING;
      }
      anyStringCount++;
    } else {
      return VALUE_TYPE_ANY;
    }
  }
  return commonValueType;
}
function detectValueType(value) {
  if (isGeoPointArray(value)) {
    return VALUE_TYPE_GEO_POINT;
  }
  if (Array.isArray(value)) {
    if (!value.length) {
      return VALUE_TYPE_ANY;
    }
    return detectCommonValueType(value);
  }
  if (isBoolean(value)) {
    return VALUE_TYPE_BOOLEAN;
  }
  if (isDate(value)) {
    return VALUE_TYPE_INSTANT;
  }
  if (isNumber(value)) {
    return VALUE_TYPE_DOUBLE;
  }
  if (isObject(value)) {
    return VALUE_TYPE_SET;
  }
  if (isString(value)) {
    if (isGeoPointString(value)) {
      return VALUE_TYPE_GEO_POINT;
    }
    if (isInstantString(value)) {
      return VALUE_TYPE_INSTANT;
    }
    if (isLocalDateString(value)) {
      return VALUE_TYPE_LOCAL_DATE;
    }
    if (isLocalDateTimeString(value)) {
      return VALUE_TYPE_LOCAL_DATE_TIME;
    }
    if (isTimeString(value)) {
      return VALUE_TYPE_LOCAL_TIME;
    }
    if (isUuidV4String(value)) {
      return VALUE_TYPE_REFERENCE;
    }
    return VALUE_TYPE_STRING;
  }
  return VALUE_TYPE_ANY;
}

// storage/highlighting/index.ts
var HIGHLIGHT_FIELD_ALLTEXT = "_alltext";
var HIGHLIGHT_OPTION_ENCODER_DEFAULT = "default";
var HIGHLIGHT_OPTION_ENCODER_HTML = "html";
var HIGHLIGHT_OPTION_ENCODERS = [
  HIGHLIGHT_OPTION_ENCODER_DEFAULT,
  HIGHLIGHT_OPTION_ENCODER_HTML
];

// storage/query/index.ts
var query_exports = {};
__export(query_exports, {
  DSL_EXPRESSION_VALUE_TYPE_DATE_TIME: () => DSL_EXPRESSION_VALUE_TYPE_DATE_TIME2,
  DSL_EXPRESSION_VALUE_TYPE_TIME: () => DSL_EXPRESSION_VALUE_TYPE_TIME2,
  FILTER_CLAUSES: () => FILTER_CLAUSES,
  FILTER_CLAUSE_MUST: () => FILTER_CLAUSE_MUST,
  FILTER_CLAUSE_MUST_NOT: () => FILTER_CLAUSE_MUST_NOT,
  FILTER_CLAUSE_SHOULD: () => FILTER_CLAUSE_SHOULD,
  QUERY_FUNCTION_FULLTEXT: () => QUERY_FUNCTION_FULLTEXT,
  QUERY_FUNCTION_NGRAM: () => QUERY_FUNCTION_NGRAM,
  QUERY_FUNCTION_PATH_MATCH: () => QUERY_FUNCTION_PATH_MATCH,
  QUERY_FUNCTION_RANGE: () => QUERY_FUNCTION_RANGE,
  QUERY_FUNCTION_STEMMED: () => QUERY_FUNCTION_STEMMED,
  QUERY_OPERATOR_AND: () => QUERY_OPERATOR_AND,
  QUERY_OPERATOR_OR: () => QUERY_OPERATOR_OR,
  SORT_CREATED: () => SORT_CREATED,
  SORT_DISPLAYNAME: () => SORT_DISPLAYNAME,
  SORT_MANUAL: () => SORT_MANUAL,
  SORT_MODIFIED: () => SORT_MODIFIED,
  addQueryFilter: () => addQueryFilter,
  aggregation: () => aggregation_exports,
  and: () => and2,
  dsl: () => dsl_exports,
  filter: () => filter_exports,
  fulltext: () => fulltext2,
  group: () => group,
  isBooleanDslExpression: () => isBooleanDslExpression_default,
  isBooleanFilter: () => isBooleanFilter,
  isExistsDslExpression: () => isExistsDslExpression,
  isExistsFilter: () => isExistsFilter,
  isFilter: () => isFilter,
  isFulltextDslExpression: () => isFulltextDslExpression,
  isHasValueFilter: () => isHasValueFilter,
  isIdsFilter: () => isIdsFilter,
  isInDslExpression: () => isInDslExpression,
  isLikeDslExpression: () => isLikeDslExpression,
  isMatchAllDslExpression: () => isMatchAllDslExpression,
  isNgramDslExpression: () => isNgramDslExpression,
  isNotExistsFilter: () => isNotExistsFilter,
  isPathMatchDslExpression: () => isPathMatchDslExpression,
  isQueryDsl: () => isQueryDsl,
  isRangeDslExpression: () => isRangeDslExpression,
  isStemmedDslExpression: () => isStemmedDslExpression,
  isTermDslExpression: () => isTermDslExpression,
  ngram: () => ngram2,
  or: () => or2,
  stemmed: () => stemmed2
});

// storage/query/aggregation/index.ts
var aggregation_exports = {};
__export(aggregation_exports, {
  stats: () => stats,
  statsParams: () => statsParams,
  terms: () => terms,
  termsParams: () => termsParams
});

// storage/query/aggregation/stats.ts
function statsParams(field) {
  const stats2 = {
    field
  };
  return stats2;
}
function stats(field) {
  const statsAggregation = {
    stats: statsParams(
      field
    )
  };
  return statsAggregation;
}

// storage/query/aggregation/terms.ts
function termsParams(field, order, size, minDocCount) {
  const terms2 = {
    field
  };
  if (order) {
    terms2.order = order;
  }
  if (size) {
    terms2.size = size;
  }
  if (minDocCount) {
    terms2.minDocCount = minDocCount;
  }
  return terms2;
}
function terms(field, ...optionalArgs) {
  let order;
  let size;
  let minDocCount;
  let aggregations;
  for (let i = 0; i < optionalArgs.length; i++) {
    const optinalArg = optionalArgs[i];
    if (isString(optinalArg)) {
      if (order) {
        throw new Error(`terms: You can only provide one optional order parameter!`);
      }
      order = optinalArg;
    } else if (isNumber(optinalArg)) {
      if (isSet(minDocCount)) {
        throw new Error(`terms: You can only provide one or two optional number parameters!`);
      }
      if (isSet(size)) {
        minDocCount = optinalArg;
      } else {
        size = optinalArg;
      }
    } else if (isObject(optinalArg)) {
      if (aggregations) {
        throw new Error(`terms: You can only provide one optional aggregations parameter!`);
      }
      aggregations = optinalArg;
    } else {
      throw new Error(`terms: Unknown optional parameter type!`);
    }
  }
  const termsAggregation = {
    terms: termsParams(
      field,
      order,
      size,
      minDocCount
    )
  };
  if (aggregations) {
    termsAggregation.aggregations = aggregations;
  }
  return termsAggregation;
}

// storage/query/dsl/index.ts
var dsl_exports = {};
__export(dsl_exports, {
  DSL_EXPRESSION_VALUE_TYPE_DATE_TIME: () => DSL_EXPRESSION_VALUE_TYPE_DATE_TIME2,
  DSL_EXPRESSION_VALUE_TYPE_TIME: () => DSL_EXPRESSION_VALUE_TYPE_TIME2,
  and: () => and,
  bool: () => bool,
  fulltext: () => fulltext,
  inQuery: () => inQuery,
  isBooleanDslExpression: () => isBooleanDslExpression_default,
  isExistsDslExpression: () => isExistsDslExpression,
  isFulltextDslExpression: () => isFulltextDslExpression,
  isInDslExpression: () => isInDslExpression,
  isLikeDslExpression: () => isLikeDslExpression,
  isMatchAllDslExpression: () => isMatchAllDslExpression,
  isNgramDslExpression: () => isNgramDslExpression,
  isPathMatchDslExpression: () => isPathMatchDslExpression,
  isQueryDsl: () => isQueryDsl,
  isRangeDslExpression: () => isRangeDslExpression,
  isStemmedDslExpression: () => isStemmedDslExpression,
  isTermDslExpression: () => isTermDslExpression,
  like: () => like,
  must: () => must,
  mustNot: () => mustNot,
  ngram: () => ngram,
  not: () => not,
  or: () => or,
  pathMatch: () => pathMatch,
  range: () => range,
  should: () => should,
  sort: () => sort,
  stemmed: () => stemmed,
  term: () => term
});

// storage/query/dsl/isDslQueryType.ts
var DSL_EXPRESSION_VALUE_TYPE_DATE_TIME = "dateTime";
var DSL_EXPRESSION_VALUE_TYPE_TIME = "time";
function isDslQueryType(value) {
  return isString(value) && (value === DSL_EXPRESSION_VALUE_TYPE_DATE_TIME || value === DSL_EXPRESSION_VALUE_TYPE_TIME);
}

// storage/query/dsl/isInDslExpression.ts
function isInDslExpression(value) {
  return isObject(value) && hasOwnProperty(value, "field") && hasOwnProperty(value, "values") && isString(value.field) && Array.isArray(value.values) && (hasOwnProperty(value, "type") ? isDslQueryType(value.type) : true) && (hasOwnProperty(value, "boost") ? isNumber(value.boost) : true);
}

// storage/query/dsl/isExistsDslExpression.ts
function isExistsDslExpression(value) {
  return isObject(value) && hasOwnProperty(value, "field") && isString(value.field) && (hasOwnProperty(value, "boost") ? isNumber(value.boost) : true);
}

// storage/query/constants.ts
var FILTER_CLAUSE_MUST = "must";
var FILTER_CLAUSE_MUST_NOT = "mustNot";
var FILTER_CLAUSE_SHOULD = "should";
var FILTER_CLAUSES = [
  FILTER_CLAUSE_MUST,
  FILTER_CLAUSE_MUST_NOT,
  FILTER_CLAUSE_SHOULD
];
var QUERY_FUNCTION_FULLTEXT = "fulltext";
var QUERY_FUNCTION_NGRAM = "ngram";
var QUERY_FUNCTION_RANGE = "range";
var QUERY_FUNCTION_PATH_MATCH = "pathMatch";
var QUERY_FUNCTION_STEMMED = "stemmed";
var QUERY_OPERATOR_AND = "AND";
var QUERY_OPERATOR_OR = "OR";
var QUERY_OPERATORS = [
  QUERY_OPERATOR_AND,
  QUERY_OPERATOR_OR
];

// storage/query/dsl/isDslOperator.ts
function isDslOperator(value) {
  return isString(value) && includes(QUERY_OPERATORS, value);
}