{"version":3,"sources":["libs/lexicon/src/lib/constants.ts","node_modules/@angular/localize/fesm2022/localize.mjs","node_modules/@angular/localize/fesm2022/init.mjs","node_modules/@vendasta/lexicon/fesm2020/vendasta-lexicon.mjs","libs/lexicon/src/lib/converters.ts","libs/lexicon/src/lib/merge.ts","libs/lexicon/src/lib/lexicon.loader.ts","libs/lexicon/src/lib/lexicon.missing-translation-handler.ts","libs/lexicon/src/lib/lexicon.module.ts","libs/lexicon/src/lib/index.ts","libs/lexicon/src/index.ts"],"sourcesContent":["import { InjectionToken } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nexport enum LEXICON_FILE_FORMAT_OPTION {\n  NESTED_JSON = 'nested_json',\n  FLAT_JSON = 'flat_json',\n  XLIFF1 = 'xliff1',\n}\n\nexport const LEXICON_TRANSLATE_PORTAL_URL = 'https://weblate.apigateway.co';\nexport const LEXICON_COMPONENT_NAME = new InjectionToken<string>('lexiconComponentName');\nexport const LEXICON_PARTNER_ID = new InjectionToken<Observable<string>>('lexiconPartnerId');\nexport const LEXICON_DISABLE_OTW = new InjectionToken<boolean>('lexiconDisableOtw');\nexport const LEXICON_BASE_TRANSLATION = new InjectionToken('lexiconBaseTranslation');\nexport const LEXICON_ROOT_COMPONENT = new InjectionToken<string>('lexiconRootComponent');\nexport const LEXICON_FILE_FORMAT = new InjectionToken<LEXICON_FILE_FORMAT_OPTION>('lexiconFileFormat');\n\nexport type translations = { [key: string]: string | translations };\n","/**\n * @license Angular v17.3.0\n * (c) 2010-2022 Google LLC. https://angular.io/\n * License: MIT\n */\n\n/**\n * The character used to mark the start and end of a \"block\" in a `$localize` tagged string.\n * A block can indicate metadata about the message or specify a name of a placeholder for a\n * substitution expressions.\n *\n * For example:\n *\n * ```ts\n * $localize`Hello, ${title}:title:!`;\n * $localize`:meaning|description@@id:source message text`;\n * ```\n */\nconst BLOCK_MARKER$1 = ':';\n/**\n * The marker used to separate a message's \"meaning\" from its \"description\" in a metadata block.\n *\n * For example:\n *\n * ```ts\n * $localize `:correct|Indicates that the user got the answer correct: Right!`;\n * $localize `:movement|Button label for moving to the right: Right!`;\n * ```\n */\nconst MEANING_SEPARATOR = '|';\n/**\n * The marker used to separate a message's custom \"id\" from its \"description\" in a metadata block.\n *\n * For example:\n *\n * ```ts\n * $localize `:A welcome message on the home page@@myApp-homepage-welcome: Welcome!`;\n * ```\n */\nconst ID_SEPARATOR = '@@';\n/**\n * The marker used to separate legacy message ids from the rest of a metadata block.\n *\n * For example:\n *\n * ```ts\n * $localize `:@@custom-id␟2df64767cd895a8fabe3e18b94b5b6b6f9e2e3f0: Welcome!`;\n * ```\n *\n * Note that this character is the \"symbol for the unit separator\" (␟) not the \"unit separator\n * character\" itself, since that has no visual representation. See https://graphemica.com/%E2%90%9F.\n *\n * Here is some background for the original \"unit separator character\":\n * https://stackoverflow.com/questions/8695118/whats-the-file-group-record-unit-separator-control-characters-and-its-usage\n */\nconst LEGACY_ID_INDICATOR = '\\u241F';\n\n/**\n * A lazily created TextEncoder instance for converting strings into UTF-8 bytes\n */\nlet textEncoder;\n/**\n * Return the message id or compute it using the XLIFF1 digest.\n */\nfunction digest(message) {\n  return message.id || computeDigest(message);\n}\n/**\n * Compute the message id using the XLIFF1 digest.\n */\nfunction computeDigest(message) {\n  return sha1(serializeNodes(message.nodes).join('') + `[${message.meaning}]`);\n}\n/**\n * Return the message id or compute it using the XLIFF2/XMB/$localize digest.\n */\nfunction decimalDigest(message) {\n  return message.id || computeDecimalDigest(message);\n}\n/**\n * Compute the message id using the XLIFF2/XMB/$localize digest.\n */\nfunction computeDecimalDigest(message) {\n  const visitor = new _SerializerIgnoreIcuExpVisitor();\n  const parts = message.nodes.map(a => a.visit(visitor, null));\n  return computeMsgId(parts.join(''), message.meaning);\n}\n/**\n * Serialize the i18n ast to something xml-like in order to generate an UID.\n *\n * The visitor is also used in the i18n parser tests\n *\n * @internal\n */\nclass _SerializerVisitor {\n  visitText(text, context) {\n    return text.value;\n  }\n  visitContainer(container, context) {\n    return `[${container.children.map(child => child.visit(this)).join(', ')}]`;\n  }\n  visitIcu(icu, context) {\n    const strCases = Object.keys(icu.cases).map(k => `${k} {${icu.cases[k].visit(this)}}`);\n    return `{${icu.expression}, ${icu.type}, ${strCases.join(', ')}}`;\n  }\n  visitTagPlaceholder(ph, context) {\n    return ph.isVoid ? `<ph tag name=\"${ph.startName}\"/>` : `<ph tag name=\"${ph.startName}\">${ph.children.map(child => child.visit(this)).join(', ')}</ph name=\"${ph.closeName}\">`;\n  }\n  visitPlaceholder(ph, context) {\n    return ph.value ? `<ph name=\"${ph.name}\">${ph.value}</ph>` : `<ph name=\"${ph.name}\"/>`;\n  }\n  visitIcuPlaceholder(ph, context) {\n    return `<ph icu name=\"${ph.name}\">${ph.value.visit(this)}</ph>`;\n  }\n  visitBlockPlaceholder(ph, context) {\n    return `<ph block name=\"${ph.startName}\">${ph.children.map(child => child.visit(this)).join(', ')}</ph name=\"${ph.closeName}\">`;\n  }\n}\nconst serializerVisitor = /*#__PURE__*/new _SerializerVisitor();\nfunction serializeNodes(nodes) {\n  return nodes.map(a => a.visit(serializerVisitor, null));\n}\n/**\n * Serialize the i18n ast to something xml-like in order to generate an UID.\n *\n * Ignore the ICU expressions so that message IDs stays identical if only the expression changes.\n *\n * @internal\n */\nclass _SerializerIgnoreIcuExpVisitor extends _SerializerVisitor {\n  visitIcu(icu, context) {\n    let strCases = Object.keys(icu.cases).map(k => `${k} {${icu.cases[k].visit(this)}}`);\n    // Do not take the expression into account\n    return `{${icu.type}, ${strCases.join(', ')}}`;\n  }\n}\n/**\n * Compute the SHA1 of the given string\n *\n * see https://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf\n *\n * WARNING: this function has not been designed not tested with security in mind.\n *          DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT.\n */\nfunction sha1(str) {\n  textEncoder ??= new TextEncoder();\n  const utf8 = [...textEncoder.encode(str)];\n  const words32 = bytesToWords32(utf8, Endian.Big);\n  const len = utf8.length * 8;\n  const w = new Uint32Array(80);\n  let a = 0x67452301,\n    b = 0xefcdab89,\n    c = 0x98badcfe,\n    d = 0x10325476,\n    e = 0xc3d2e1f0;\n  words32[len >> 5] |= 0x80 << 24 - len % 32;\n  words32[(len + 64 >> 9 << 4) + 15] = len;\n  for (let i = 0; i < words32.length; i += 16) {\n    const h0 = a,\n      h1 = b,\n      h2 = c,\n      h3 = d,\n      h4 = e;\n    for (let j = 0; j < 80; j++) {\n      if (j < 16) {\n        w[j] = words32[i + j];\n      } else {\n        w[j] = rol32(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);\n      }\n      const fkVal = fk(j, b, c, d);\n      const f = fkVal[0];\n      const k = fkVal[1];\n      const temp = [rol32(a, 5), f, e, k, w[j]].reduce(add32);\n      e = d;\n      d = c;\n      c = rol32(b, 30);\n      b = a;\n      a = temp;\n    }\n    a = add32(a, h0);\n    b = add32(b, h1);\n    c = add32(c, h2);\n    d = add32(d, h3);\n    e = add32(e, h4);\n  }\n  // Convert the output parts to a 160-bit hexadecimal string\n  return toHexU32(a) + toHexU32(b) + toHexU32(c) + toHexU32(d) + toHexU32(e);\n}\n/**\n * Convert and format a number as a string representing a 32-bit unsigned hexadecimal number.\n * @param value The value to format as a string.\n * @returns A hexadecimal string representing the value.\n */\nfunction toHexU32(value) {\n  // unsigned right shift of zero ensures an unsigned 32-bit number\n  return (value >>> 0).toString(16).padStart(8, '0');\n}\nfunction fk(index, b, c, d) {\n  if (index < 20) {\n    return [b & c | ~b & d, 0x5a827999];\n  }\n  if (index < 40) {\n    return [b ^ c ^ d, 0x6ed9eba1];\n  }\n  if (index < 60) {\n    return [b & c | b & d | c & d, 0x8f1bbcdc];\n  }\n  return [b ^ c ^ d, 0xca62c1d6];\n}\n/**\n * Compute the fingerprint of the given string\n *\n * The output is 64 bit number encoded as a decimal string\n *\n * based on:\n * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java\n */\nfunction fingerprint(str) {\n  textEncoder ??= new TextEncoder();\n  const utf8 = textEncoder.encode(str);\n  const view = new DataView(utf8.buffer, utf8.byteOffset, utf8.byteLength);\n  let hi = hash32(view, utf8.length, 0);\n  let lo = hash32(view, utf8.length, 102072);\n  if (hi == 0 && (lo == 0 || lo == 1)) {\n    hi = hi ^ 0x130f9bef;\n    lo = lo ^ -0x6b5f56d8;\n  }\n  return BigInt.asUintN(32, BigInt(hi)) << BigInt(32) | BigInt.asUintN(32, BigInt(lo));\n}\nfunction computeMsgId(msg, meaning = '') {\n  let msgFingerprint = fingerprint(msg);\n  if (meaning) {\n    // Rotate the 64-bit message fingerprint one bit to the left and then add the meaning\n    // fingerprint.\n    msgFingerprint = BigInt.asUintN(64, msgFingerprint << BigInt(1)) | msgFingerprint >> BigInt(63) & BigInt(1);\n    msgFingerprint += fingerprint(meaning);\n  }\n  return BigInt.asUintN(63, msgFingerprint).toString();\n}\nfunction hash32(view, length, c) {\n  let a = 0x9e3779b9,\n    b = 0x9e3779b9;\n  let index = 0;\n  const end = length - 12;\n  for (; index <= end; index += 12) {\n    a += view.getUint32(index, true);\n    b += view.getUint32(index + 4, true);\n    c += view.getUint32(index + 8, true);\n    const res = mix(a, b, c);\n    a = res[0], b = res[1], c = res[2];\n  }\n  const remainder = length - index;\n  // the first byte of c is reserved for the length\n  c += length;\n  if (remainder >= 4) {\n    a += view.getUint32(index, true);\n    index += 4;\n    if (remainder >= 8) {\n      b += view.getUint32(index, true);\n      index += 4;\n      // Partial 32-bit word for c\n      if (remainder >= 9) {\n        c += view.getUint8(index++) << 8;\n      }\n      if (remainder >= 10) {\n        c += view.getUint8(index++) << 16;\n      }\n      if (remainder === 11) {\n        c += view.getUint8(index++) << 24;\n      }\n    } else {\n      // Partial 32-bit word for b\n      if (remainder >= 5) {\n        b += view.getUint8(index++);\n      }\n      if (remainder >= 6) {\n        b += view.getUint8(index++) << 8;\n      }\n      if (remainder === 7) {\n        b += view.getUint8(index++) << 16;\n      }\n    }\n  } else {\n    // Partial 32-bit word for a\n    if (remainder >= 1) {\n      a += view.getUint8(index++);\n    }\n    if (remainder >= 2) {\n      a += view.getUint8(index++) << 8;\n    }\n    if (remainder === 3) {\n      a += view.getUint8(index++) << 16;\n    }\n  }\n  return mix(a, b, c)[2];\n}\n// clang-format off\nfunction mix(a, b, c) {\n  a -= b;\n  a -= c;\n  a ^= c >>> 13;\n  b -= c;\n  b -= a;\n  b ^= a << 8;\n  c -= a;\n  c -= b;\n  c ^= b >>> 13;\n  a -= b;\n  a -= c;\n  a ^= c >>> 12;\n  b -= c;\n  b -= a;\n  b ^= a << 16;\n  c -= a;\n  c -= b;\n  c ^= b >>> 5;\n  a -= b;\n  a -= c;\n  a ^= c >>> 3;\n  b -= c;\n  b -= a;\n  b ^= a << 10;\n  c -= a;\n  c -= b;\n  c ^= b >>> 15;\n  return [a, b, c];\n}\n// clang-format on\n// Utils\nvar Endian = /*#__PURE__*/function (Endian) {\n  Endian[Endian[\"Little\"] = 0] = \"Little\";\n  Endian[Endian[\"Big\"] = 1] = \"Big\";\n  return Endian;\n}(Endian || {});\nfunction add32(a, b) {\n  return add32to64(a, b)[1];\n}\nfunction add32to64(a, b) {\n  const low = (a & 0xffff) + (b & 0xffff);\n  const high = (a >>> 16) + (b >>> 16) + (low >>> 16);\n  return [high >>> 16, high << 16 | low & 0xffff];\n}\n// Rotate a 32b number left `count` position\nfunction rol32(a, count) {\n  return a << count | a >>> 32 - count;\n}\nfunction bytesToWords32(bytes, endian) {\n  const size = bytes.length + 3 >>> 2;\n  const words32 = [];\n  for (let i = 0; i < size; i++) {\n    words32[i] = wordAt(bytes, i * 4, endian);\n  }\n  return words32;\n}\nfunction byteAt(bytes, index) {\n  return index >= bytes.length ? 0 : bytes[index];\n}\nfunction wordAt(bytes, index, endian) {\n  let word = 0;\n  if (endian === Endian.Big) {\n    for (let i = 0; i < 4; i++) {\n      word += byteAt(bytes, index + i) << 24 - 8 * i;\n    }\n  } else {\n    for (let i = 0; i < 4; i++) {\n      word += byteAt(bytes, index + i) << 8 * i;\n    }\n  }\n  return word;\n}\n\n// This module specifier is intentionally a relative path to allow bundling the code directly\n/**\n * Parse a `$localize` tagged string into a structure that can be used for translation or\n * extraction.\n *\n * See `ParsedMessage` for an example.\n */\nfunction parseMessage(messageParts, expressions, location, messagePartLocations, expressionLocations = []) {\n  const substitutions = {};\n  const substitutionLocations = {};\n  const associatedMessageIds = {};\n  const metadata = parseMetadata(messageParts[0], messageParts.raw[0]);\n  const cleanedMessageParts = [metadata.text];\n  const placeholderNames = [];\n  let messageString = metadata.text;\n  for (let i = 1; i < messageParts.length; i++) {\n    const {\n      messagePart,\n      placeholderName = computePlaceholderName(i),\n      associatedMessageId\n    } = parsePlaceholder(messageParts[i], messageParts.raw[i]);\n    messageString += `{$${placeholderName}}${messagePart}`;\n    if (expressions !== undefined) {\n      substitutions[placeholderName] = expressions[i - 1];\n      substitutionLocations[placeholderName] = expressionLocations[i - 1];\n    }\n    placeholderNames.push(placeholderName);\n    if (associatedMessageId !== undefined) {\n      associatedMessageIds[placeholderName] = associatedMessageId;\n    }\n    cleanedMessageParts.push(messagePart);\n  }\n  const messageId = metadata.customId || computeMsgId(messageString, metadata.meaning || '');\n  const legacyIds = metadata.legacyIds ? metadata.legacyIds.filter(id => id !== messageId) : [];\n  return {\n    id: messageId,\n    legacyIds,\n    substitutions,\n    substitutionLocations,\n    text: messageString,\n    customId: metadata.customId,\n    meaning: metadata.meaning || '',\n    description: metadata.description || '',\n    messageParts: cleanedMessageParts,\n    messagePartLocations,\n    placeholderNames,\n    associatedMessageIds,\n    location\n  };\n}\n/**\n * Parse the given message part (`cooked` + `raw`) to extract the message metadata from the text.\n *\n * If the message part has a metadata block this function will extract the `meaning`,\n * `description`, `customId` and `legacyId` (if provided) from the block. These metadata properties\n * are serialized in the string delimited by `|`, `@@` and `␟` respectively.\n *\n * (Note that `␟` is the `LEGACY_ID_INDICATOR` - see `constants.ts`.)\n *\n * For example:\n *\n * ```ts\n * `:meaning|description@@custom-id:`\n * `:meaning|@@custom-id:`\n * `:meaning|description:`\n * `:description@@custom-id:`\n * `:meaning|:`\n * `:description:`\n * `:@@custom-id:`\n * `:meaning|description@@custom-id␟legacy-id-1␟legacy-id-2:`\n * ```\n *\n * @param cooked The cooked version of the message part to parse.\n * @param raw The raw version of the message part to parse.\n * @returns A object containing any metadata that was parsed from the message part.\n */\nfunction parseMetadata(cooked, raw) {\n  const {\n    text: messageString,\n    block\n  } = splitBlock(cooked, raw);\n  if (block === undefined) {\n    return {\n      text: messageString\n    };\n  } else {\n    const [meaningDescAndId, ...legacyIds] = block.split(LEGACY_ID_INDICATOR);\n    const [meaningAndDesc, customId] = meaningDescAndId.split(ID_SEPARATOR, 2);\n    let [meaning, description] = meaningAndDesc.split(MEANING_SEPARATOR, 2);\n    if (description === undefined) {\n      description = meaning;\n      meaning = undefined;\n    }\n    if (description === '') {\n      description = undefined;\n    }\n    return {\n      text: messageString,\n      meaning,\n      description,\n      customId,\n      legacyIds\n    };\n  }\n}\n/**\n * Parse the given message part (`cooked` + `raw`) to extract any placeholder metadata from the\n * text.\n *\n * If the message part has a metadata block this function will extract the `placeholderName` and\n * `associatedMessageId` (if provided) from the block.\n *\n * These metadata properties are serialized in the string delimited by `@@`.\n *\n * For example:\n *\n * ```ts\n * `:placeholder-name@@associated-id:`\n * ```\n *\n * @param cooked The cooked version of the message part to parse.\n * @param raw The raw version of the message part to parse.\n * @returns A object containing the metadata (`placeholderName` and `associatedMessageId`) of the\n *     preceding placeholder, along with the static text that follows.\n */\nfunction parsePlaceholder(cooked, raw) {\n  const {\n    text: messagePart,\n    block\n  } = splitBlock(cooked, raw);\n  if (block === undefined) {\n    return {\n      messagePart\n    };\n  } else {\n    const [placeholderName, associatedMessageId] = block.split(ID_SEPARATOR);\n    return {\n      messagePart,\n      placeholderName,\n      associatedMessageId\n    };\n  }\n}\n/**\n * Split a message part (`cooked` + `raw`) into an optional delimited \"block\" off the front and the\n * rest of the text of the message part.\n *\n * Blocks appear at the start of message parts. They are delimited by a colon `:` character at the\n * start and end of the block.\n *\n * If the block is in the first message part then it will be metadata about the whole message:\n * meaning, description, id.  Otherwise it will be metadata about the immediately preceding\n * substitution: placeholder name.\n *\n * Since blocks are optional, it is possible that the content of a message block actually starts\n * with a block marker. In this case the marker must be escaped `\\:`.\n *\n * @param cooked The cooked version of the message part to parse.\n * @param raw The raw version of the message part to parse.\n * @returns An object containing the `text` of the message part and the text of the `block`, if it\n * exists.\n * @throws an error if the `block` is unterminated\n */\nfunction splitBlock(cooked, raw) {\n  if (raw.charAt(0) !== BLOCK_MARKER$1) {\n    return {\n      text: cooked\n    };\n  } else {\n    const endOfBlock = findEndOfBlock(cooked, raw);\n    return {\n      block: cooked.substring(1, endOfBlock),\n      text: cooked.substring(endOfBlock + 1)\n    };\n  }\n}\nfunction computePlaceholderName(index) {\n  return index === 1 ? 'PH' : `PH_${index - 1}`;\n}\n/**\n * Find the end of a \"marked block\" indicated by the first non-escaped colon.\n *\n * @param cooked The cooked string (where escaped chars have been processed)\n * @param raw The raw string (where escape sequences are still in place)\n *\n * @returns the index of the end of block marker\n * @throws an error if the block is unterminated\n */\nfunction findEndOfBlock(cooked, raw) {\n  for (let cookedIndex = 1, rawIndex = 1; cookedIndex < cooked.length; cookedIndex++, rawIndex++) {\n    if (raw[rawIndex] === '\\\\') {\n      rawIndex++;\n    } else if (cooked[cookedIndex] === BLOCK_MARKER$1) {\n      return cookedIndex;\n    }\n  }\n  throw new Error(`Unterminated $localize metadata block in \"${raw}\".`);\n}\nclass MissingTranslationError extends Error {\n  constructor(parsedMessage) {\n    super(`No translation found for ${describeMessage(parsedMessage)}.`);\n    this.parsedMessage = parsedMessage;\n    this.type = 'MissingTranslationError';\n  }\n}\nfunction isMissingTranslationError(e) {\n  return e.type === 'MissingTranslationError';\n}\n/**\n * Translate the text of the `$localize` tagged-string (i.e. `messageParts` and\n * `substitutions`) using the given `translations`.\n *\n * The tagged-string is parsed to extract its `messageId` which is used to find an appropriate\n * `ParsedTranslation`. If this doesn't match and there are legacy ids then try matching a\n * translation using those.\n *\n * If one is found then it is used to translate the message into a new set of `messageParts` and\n * `substitutions`.\n * The translation may reorder (or remove) substitutions as appropriate.\n *\n * If there is no translation with a matching message id then an error is thrown.\n * If a translation contains a placeholder that is not found in the message being translated then an\n * error is thrown.\n */\nfunction translate$1(translations, messageParts, substitutions) {\n  const message = parseMessage(messageParts, substitutions);\n  // Look up the translation using the messageId, and then the legacyId if available.\n  let translation = translations[message.id];\n  // If the messageId did not match a translation, try matching the legacy ids instead\n  if (message.legacyIds !== undefined) {\n    for (let i = 0; i < message.legacyIds.length && translation === undefined; i++) {\n      translation = translations[message.legacyIds[i]];\n    }\n  }\n  if (translation === undefined) {\n    throw new MissingTranslationError(message);\n  }\n  return [translation.messageParts, translation.placeholderNames.map(placeholder => {\n    if (message.substitutions.hasOwnProperty(placeholder)) {\n      return message.substitutions[placeholder];\n    } else {\n      throw new Error(`There is a placeholder name mismatch with the translation provided for the message ${describeMessage(message)}.\\n` + `The translation contains a placeholder with name ${placeholder}, which does not exist in the message.`);\n    }\n  })];\n}\n/**\n * Parse the `messageParts` and `placeholderNames` out of a target `message`.\n *\n * Used by `loadTranslations()` to convert target message strings into a structure that is more\n * appropriate for doing translation.\n *\n * @param message the message to be parsed.\n */\nfunction parseTranslation(messageString) {\n  const parts = messageString.split(/{\\$([^}]*)}/);\n  const messageParts = [parts[0]];\n  const placeholderNames = [];\n  for (let i = 1; i < parts.length - 1; i += 2) {\n    placeholderNames.push(parts[i]);\n    messageParts.push(`${parts[i + 1]}`);\n  }\n  const rawMessageParts = messageParts.map(part => part.charAt(0) === BLOCK_MARKER$1 ? '\\\\' + part : part);\n  return {\n    text: messageString,\n    messageParts: makeTemplateObject(messageParts, rawMessageParts),\n    placeholderNames\n  };\n}\n/**\n * Create a `ParsedTranslation` from a set of `messageParts` and `placeholderNames`.\n *\n * @param messageParts The message parts to appear in the ParsedTranslation.\n * @param placeholderNames The names of the placeholders to intersperse between the `messageParts`.\n */\nfunction makeParsedTranslation(messageParts, placeholderNames = []) {\n  let messageString = messageParts[0];\n  for (let i = 0; i < placeholderNames.length; i++) {\n    messageString += `{$${placeholderNames[i]}}${messageParts[i + 1]}`;\n  }\n  return {\n    text: messageString,\n    messageParts: makeTemplateObject(messageParts, messageParts),\n    placeholderNames\n  };\n}\n/**\n * Create the specialized array that is passed to tagged-string tag functions.\n *\n * @param cooked The message parts with their escape codes processed.\n * @param raw The message parts with their escaped codes as-is.\n */\nfunction makeTemplateObject(cooked, raw) {\n  Object.defineProperty(cooked, 'raw', {\n    value: raw\n  });\n  return cooked;\n}\nfunction describeMessage(message) {\n  const meaningString = message.meaning && ` - \"${message.meaning}\"`;\n  const legacy = message.legacyIds && message.legacyIds.length > 0 ? ` [${message.legacyIds.map(l => `\"${l}\"`).join(', ')}]` : '';\n  return `\"${message.id}\"${legacy} (\"${message.text}\"${meaningString})`;\n}\n\n/**\n * Load translations for use by `$localize`, if doing runtime translation.\n *\n * If the `$localize` tagged strings are not going to be replaced at compiled time, it is possible\n * to load a set of translations that will be applied to the `$localize` tagged strings at runtime,\n * in the browser.\n *\n * Loading a new translation will overwrite a previous translation if it has the same `MessageId`.\n *\n * Note that `$localize` messages are only processed once, when the tagged string is first\n * encountered, and does not provide dynamic language changing without refreshing the browser.\n * Loading new translations later in the application life-cycle will not change the translated text\n * of messages that have already been translated.\n *\n * The message IDs and translations are in the same format as that rendered to \"simple JSON\"\n * translation files when extracting messages. In particular, placeholders in messages are rendered\n * using the `{$PLACEHOLDER_NAME}` syntax. For example the message from the following template:\n *\n * ```html\n * <div i18n>pre<span>inner-pre<b>bold</b>inner-post</span>post</div>\n * ```\n *\n * would have the following form in the `translations` map:\n *\n * ```ts\n * {\n *   \"2932901491976224757\":\n *      \"pre{$START_TAG_SPAN}inner-pre{$START_BOLD_TEXT}bold{$CLOSE_BOLD_TEXT}inner-post{$CLOSE_TAG_SPAN}post\"\n * }\n * ```\n *\n * @param translations A map from message ID to translated message.\n *\n * These messages are processed and added to a lookup based on their `MessageId`.\n *\n * @see {@link clearTranslations} for removing translations loaded using this function.\n * @see {@link $localize} for tagging messages as needing to be translated.\n * @publicApi\n */\nfunction loadTranslations(translations) {\n  // Ensure the translate function exists\n  if (!$localize.translate) {\n    $localize.translate = translate;\n  }\n  if (!$localize.TRANSLATIONS) {\n    $localize.TRANSLATIONS = {};\n  }\n  Object.keys(translations).forEach(key => {\n    $localize.TRANSLATIONS[key] = parseTranslation(translations[key]);\n  });\n}\n/**\n * Remove all translations for `$localize`, if doing runtime translation.\n *\n * All translations that had been loading into memory using `loadTranslations()` will be removed.\n *\n * @see {@link loadTranslations} for loading translations at runtime.\n * @see {@link $localize} for tagging messages as needing to be translated.\n *\n * @publicApi\n */\nfunction clearTranslations() {\n  $localize.translate = undefined;\n  $localize.TRANSLATIONS = {};\n}\n/**\n * Translate the text of the given message, using the loaded translations.\n *\n * This function may reorder (or remove) substitutions as indicated in the matching translation.\n */\nfunction translate(messageParts, substitutions) {\n  try {\n    return translate$1($localize.TRANSLATIONS, messageParts, substitutions);\n  } catch (e) {\n    console.warn(e.message);\n    return [messageParts, substitutions];\n  }\n}\n\n/**\n * Tag a template literal string for localization.\n *\n * For example:\n *\n * ```ts\n * $localize `some string to localize`\n * ```\n *\n * **Providing meaning, description and id**\n *\n * You can optionally specify one or more of `meaning`, `description` and `id` for a localized\n * string by pre-pending it with a colon delimited block of the form:\n *\n * ```ts\n * $localize`:meaning|description@@id:source message text`;\n *\n * $localize`:meaning|:source message text`;\n * $localize`:description:source message text`;\n * $localize`:@@id:source message text`;\n * ```\n *\n * This format is the same as that used for `i18n` markers in Angular templates. See the\n * [Angular i18n guide](guide/i18n-common-prepare#mark-text-in-component-template).\n *\n * **Naming placeholders**\n *\n * If the template literal string contains expressions, then the expressions will be automatically\n * associated with placeholder names for you.\n *\n * For example:\n *\n * ```ts\n * $localize `Hi ${name}! There are ${items.length} items.`;\n * ```\n *\n * will generate a message-source of `Hi {$PH}! There are {$PH_1} items`.\n *\n * The recommended practice is to name the placeholder associated with each expression though.\n *\n * Do this by providing the placeholder name wrapped in `:` characters directly after the\n * expression. These placeholder names are stripped out of the rendered localized string.\n *\n * For example, to name the `items.length` expression placeholder `itemCount` you write:\n *\n * ```ts\n * $localize `There are ${items.length}:itemCount: items`;\n * ```\n *\n * **Escaping colon markers**\n *\n * If you need to use a `:` character directly at the start of a tagged string that has no\n * metadata block, or directly after a substitution expression that has no name you must escape\n * the `:` by preceding it with a backslash:\n *\n * For example:\n *\n * ```ts\n * // message has a metadata block so no need to escape colon\n * $localize `:some description::this message starts with a colon (:)`;\n * // no metadata block so the colon must be escaped\n * $localize `\\:this message starts with a colon (:)`;\n * ```\n *\n * ```ts\n * // named substitution so no need to escape colon\n * $localize `${label}:label:: ${}`\n * // anonymous substitution so colon must be escaped\n * $localize `${label}\\: ${}`\n * ```\n *\n * **Processing localized strings:**\n *\n * There are three scenarios:\n *\n * * **compile-time inlining**: the `$localize` tag is transformed at compile time by a\n * transpiler, removing the tag and replacing the template literal string with a translated\n * literal string from a collection of translations provided to the transpilation tool.\n *\n * * **run-time evaluation**: the `$localize` tag is a run-time function that replaces and\n * reorders the parts (static strings and expressions) of the template literal string with strings\n * from a collection of translations loaded at run-time.\n *\n * * **pass-through evaluation**: the `$localize` tag is a run-time function that simply evaluates\n * the original template literal string without applying any translations to the parts. This\n * version is used during development or where there is no need to translate the localized\n * template literals.\n *\n * @param messageParts a collection of the static parts of the template string.\n * @param expressions a collection of the values of each placeholder in the template string.\n * @returns the translated string, with the `messageParts` and `expressions` interleaved together.\n *\n * @globalApi\n * @publicApi\n */\nconst $localize$1 = function (messageParts, ...expressions) {\n  if ($localize$1.translate) {\n    // Don't use array expansion here to avoid the compiler adding `__read()` helper unnecessarily.\n    const translation = $localize$1.translate(messageParts, expressions);\n    messageParts = translation[0];\n    expressions = translation[1];\n  }\n  let message = stripBlock(messageParts[0], messageParts.raw[0]);\n  for (let i = 1; i < messageParts.length; i++) {\n    message += expressions[i - 1] + stripBlock(messageParts[i], messageParts.raw[i]);\n  }\n  return message;\n};\nconst BLOCK_MARKER = ':';\n/**\n * Strip a delimited \"block\" from the start of the `messagePart`, if it is found.\n *\n * If a marker character (:) actually appears in the content at the start of a tagged string or\n * after a substitution expression, where a block has not been provided the character must be\n * escaped with a backslash, `\\:`. This function checks for this by looking at the `raw`\n * messagePart, which should still contain the backslash.\n *\n * @param messagePart The cooked message part to process.\n * @param rawMessagePart The raw message part to check.\n * @returns the message part with the placeholder name stripped, if found.\n * @throws an error if the block is unterminated\n */\nfunction stripBlock(messagePart, rawMessagePart) {\n  return rawMessagePart.charAt(0) === BLOCK_MARKER ? messagePart.substring(findEndOfBlock(messagePart, rawMessagePart) + 1) : messagePart;\n}\n\n// This file exports all the `utils` as private exports so that other parts of `@angular/localize`\n\n// This file contains the public API of the `@angular/localize` entry-point\n\n// DO NOT ADD public exports to this file.\n\nexport { clearTranslations, loadTranslations, $localize$1 as ɵ$localize, MissingTranslationError as ɵMissingTranslationError, computeMsgId as ɵcomputeMsgId, findEndOfBlock as ɵfindEndOfBlock, isMissingTranslationError as ɵisMissingTranslationError, makeParsedTranslation as ɵmakeParsedTranslation, makeTemplateObject as ɵmakeTemplateObject, parseMessage as ɵparseMessage, parseMetadata as ɵparseMetadata, parseTranslation as ɵparseTranslation, splitBlock as ɵsplitBlock, translate$1 as ɵtranslate };\n","/**\n * @license Angular v17.3.0\n * (c) 2010-2022 Google LLC. https://angular.io/\n * License: MIT\n */\n\nimport { ɵ$localize } from '@angular/localize';\nexport { ɵ$localize as $localize } from '@angular/localize';\n\n// Attach $localize to the global context, as a side-effect of this module.\nglobalThis.$localize = ɵ$localize;\n","import * as i0 from '@angular/core';\nimport { Injectable } from '@angular/core';\nimport * as i1 from '@angular/common/http';\nimport { HttpHeaders } from '@angular/common/http';\nimport { map } from 'rxjs/operators';\nconst environment = (window ? window['environment'] : 'prod') ?? 'prod';\nconst hostMap = {\n  'local': 'lexicon-api.vendasta-local.com',\n  'test': '',\n  'demo': 'lexicon-demo.apigateway.co',\n  'prod': 'lexicon-prod.apigateway.co',\n  'production': 'lexicon-prod.apigateway.co'\n};\nlet HostService = /*#__PURE__*/(() => {\n  class HostService {\n    get host() {\n      return hostMap[environment.toLowerCase()];\n    }\n    get hostWithScheme() {\n      return 'https://' + this.host;\n    }\n  }\n  HostService.ɵfac = function HostService_Factory(t) {\n    return new (t || HostService)();\n  };\n  HostService.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: HostService,\n    factory: HostService.ɵfac,\n    providedIn: 'root'\n  });\n  return HostService;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nclass GetSupportedLanguagesRequest {\n  static fromProto(proto) {\n    let m = new GetSupportedLanguagesRequest();\n    m = Object.assign(m, proto);\n    return m;\n  }\n  constructor(kwargs) {\n    if (!kwargs) {\n      return;\n    }\n    Object.assign(this, kwargs);\n  }\n  toApiJson() {\n    const toReturn = {};\n    if (typeof this.componentName !== 'undefined') {\n      toReturn['componentName'] = this.componentName;\n    }\n    return toReturn;\n  }\n}\nclass GetSupportedLanguagesResponse {\n  static fromProto(proto) {\n    let m = new GetSupportedLanguagesResponse();\n    m = Object.assign(m, proto);\n    if (proto.languages) {\n      m.languages = proto.languages.map(Language.fromProto);\n    }\n    return m;\n  }\n  constructor(kwargs) {\n    if (!kwargs) {\n      return;\n    }\n    Object.assign(this, kwargs);\n  }\n  toApiJson() {\n    const toReturn = {};\n    if (typeof this.languages !== 'undefined' && this.languages !== null) {\n      toReturn['languages'] = 'toApiJson' in this.languages ? this.languages.toApiJson() : this.languages;\n    }\n    return toReturn;\n  }\n}\nclass GetTranslationRequest {\n  static fromProto(proto) {\n    let m = new GetTranslationRequest();\n    m = Object.assign(m, proto);\n    return m;\n  }\n  constructor(kwargs) {\n    if (!kwargs) {\n      return;\n    }\n    Object.assign(this, kwargs);\n  }\n  toApiJson() {\n    const toReturn = {};\n    if (typeof this.componentName !== 'undefined') {\n      toReturn['componentName'] = this.componentName;\n    }\n    if (typeof this.partnerId !== 'undefined') {\n      toReturn['partnerId'] = this.partnerId;\n    }\n    if (typeof this.languageCode !== 'undefined') {\n      toReturn['languageCode'] = this.languageCode;\n    }\n    return toReturn;\n  }\n}\nclass GetTranslationResponse {\n  static fromProto(proto) {\n    let m = new GetTranslationResponse();\n    m = Object.assign(m, proto);\n    return m;\n  }\n  constructor(kwargs) {\n    if (!kwargs) {\n      return;\n    }\n    Object.assign(this, kwargs);\n  }\n  toApiJson() {\n    const toReturn = {};\n    if (typeof this.translations !== 'undefined') {\n      toReturn['translations'] = this.translations;\n    }\n    return toReturn;\n  }\n}\nclass GetTranslationsRequest {\n  static fromProto(proto) {\n    let m = new GetTranslationsRequest();\n    m = Object.assign(m, proto);\n    return m;\n  }\n  constructor(kwargs) {\n    if (!kwargs) {\n      return;\n    }\n    Object.assign(this, kwargs);\n  }\n  toApiJson() {\n    const toReturn = {};\n    if (typeof this.componentNames !== 'undefined') {\n      toReturn['componentNames'] = this.componentNames;\n    }\n    if (typeof this.partnerId !== 'undefined') {\n      toReturn['partnerId'] = this.partnerId;\n    }\n    if (typeof this.languageCode !== 'undefined') {\n      toReturn['languageCode'] = this.languageCode;\n    }\n    return toReturn;\n  }\n}\nclass GetTranslationsResponse {\n  static fromProto(proto) {\n    let m = new GetTranslationsResponse();\n    m = Object.assign(m, proto);\n    return m;\n  }\n  constructor(kwargs) {\n    if (!kwargs) {\n      return;\n    }\n    Object.assign(this, kwargs);\n  }\n  toApiJson() {\n    const toReturn = {};\n    if (typeof this.translations !== 'undefined') {\n      toReturn['translations'] = this.translations;\n    }\n    return toReturn;\n  }\n}\nclass InvalidateCacheRequest {\n  static fromProto(proto) {\n    let m = new InvalidateCacheRequest();\n    m = Object.assign(m, proto);\n    return m;\n  }\n  constructor(kwargs) {\n    if (!kwargs) {\n      return;\n    }\n    Object.assign(this, kwargs);\n  }\n  toApiJson() {\n    const toReturn = {};\n    if (typeof this.componentName !== 'undefined') {\n      toReturn['componentName'] = this.componentName;\n    }\n    if (typeof this.partnerId !== 'undefined') {\n      toReturn['partnerId'] = this.partnerId;\n    }\n    if (typeof this.languageCode !== 'undefined') {\n      toReturn['languageCode'] = this.languageCode;\n    }\n    return toReturn;\n  }\n}\nclass Language {\n  static fromProto(proto) {\n    let m = new Language();\n    m = Object.assign(m, proto);\n    if (proto.languageStatistics) {\n      m.languageStatistics = Statistics.fromProto(proto.languageStatistics);\n    }\n    return m;\n  }\n  constructor(kwargs) {\n    if (!kwargs) {\n      return;\n    }\n    Object.assign(this, kwargs);\n  }\n  toApiJson() {\n    const toReturn = {};\n    if (typeof this.languageCode !== 'undefined') {\n      toReturn['languageCode'] = this.languageCode;\n    }\n    if (typeof this.languageName !== 'undefined') {\n      toReturn['languageName'] = this.languageName;\n    }\n    if (typeof this.languageStatistics !== 'undefined' && this.languageStatistics !== null) {\n      toReturn['languageStatistics'] = 'toApiJson' in this.languageStatistics ? this.languageStatistics.toApiJson() : this.languageStatistics;\n    }\n    return toReturn;\n  }\n}\nclass Statistics {\n  static fromProto(proto) {\n    let m = new Statistics();\n    m = Object.assign(m, proto);\n    if (proto.total) {\n      m.total = parseInt(proto.total, 10);\n    }\n    if (proto.totalWords) {\n      m.totalWords = parseInt(proto.totalWords, 10);\n    }\n    if (proto.translated) {\n      m.translated = parseInt(proto.translated, 10);\n    }\n    if (proto.translatedWords) {\n      m.translatedWords = parseInt(proto.translatedWords, 10);\n    }\n    if (proto.failing) {\n      m.failing = parseInt(proto.failing, 10);\n    }\n    return m;\n  }\n  constructor(kwargs) {\n    if (!kwargs) {\n      return;\n    }\n    Object.assign(this, kwargs);\n  }\n  toApiJson() {\n    const toReturn = {};\n    if (typeof this.total !== 'undefined') {\n      toReturn['total'] = this.total;\n    }\n    if (typeof this.totalWords !== 'undefined') {\n      toReturn['totalWords'] = this.totalWords;\n    }\n    if (typeof this.translated !== 'undefined') {\n      toReturn['translated'] = this.translated;\n    }\n    if (typeof this.translatedWords !== 'undefined') {\n      toReturn['translatedWords'] = this.translatedWords;\n    }\n    if (typeof this.failing !== 'undefined') {\n      toReturn['failing'] = this.failing;\n    }\n    return toReturn;\n  }\n}\n\n// *********************************\n// Code generated by sdkgen\n// DO NOT EDIT!.\n//\n// Objects Index.\n// *********************************\n\n// *********************************\n// Code generated by sdkgen\n// DO NOT EDIT!.\n//\n// API Service.\n// *********************************\nlet LexiconApiService = /*#__PURE__*/(() => {\n  class LexiconApiService {\n    constructor(http, hostService) {\n      this.http = http;\n      this.hostService = hostService;\n      this._host = this.hostService.hostWithScheme;\n    }\n    apiOptions() {\n      return {\n        headers: new HttpHeaders({\n          'Content-Type': 'application/json'\n        }),\n        withCredentials: true\n      };\n    }\n    getTranslation(r) {\n      const request = r.toApiJson ? r : new GetTranslationRequest(r);\n      return this.http.post(this._host + \"/lexicon.v1.Lexicon/GetTranslation\", request.toApiJson(), this.apiOptions()).pipe(map(resp => GetTranslationResponse.fromProto(resp)));\n    }\n    getTranslations(r) {\n      const request = r.toApiJson ? r : new GetTranslationsRequest(r);\n      return this.http.post(this._host + \"/lexicon.v1.Lexicon/GetTranslations\", request.toApiJson(), this.apiOptions()).pipe(map(resp => GetTranslationsResponse.fromProto(resp)));\n    }\n    invalidateCache(r) {\n      const request = r.toApiJson ? r : new InvalidateCacheRequest(r);\n      return this.http.post(this._host + \"/lexicon.v1.Lexicon/InvalidateCache\", request.toApiJson(), {\n        ...this.apiOptions(),\n        observe: 'response'\n      });\n    }\n    getSupportedLanguages(r) {\n      const request = r.toApiJson ? r : new GetSupportedLanguagesRequest(r);\n      return this.http.post(this._host + \"/lexicon.v1.Lexicon/GetSupportedLanguages\", request.toApiJson(), this.apiOptions()).pipe(map(resp => GetSupportedLanguagesResponse.fromProto(resp)));\n    }\n  }\n  LexiconApiService.ɵfac = function LexiconApiService_Factory(t) {\n    return new (t || LexiconApiService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(HostService));\n  };\n  LexiconApiService.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: LexiconApiService,\n    factory: LexiconApiService.ɵfac,\n    providedIn: 'root'\n  });\n  return LexiconApiService;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n// *********************************\n// Code generated by sdkgen\n// DO NOT EDIT!.\n//\n// Index.\n// *********************************\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { GetSupportedLanguagesRequest, GetSupportedLanguagesResponse, GetTranslationRequest, GetTranslationResponse, GetTranslationsRequest, GetTranslationsResponse, HostService, InvalidateCacheRequest, Language, LexiconApiService, Statistics };\n","import { translations } from './constants';\n\nexport const convertToFlatJson = (localizeTranslations: { [key: string]: { text: string } }): translations => {\n  const result: { [key: string]: string } = {};\n  Object.entries(localizeTranslations).forEach(([key, value]) => {\n    result[key] = value.text;\n  });\n  return result;\n};\n\nexport const convertToNestedJson = (localizeTranslations: { [key: string]: { text: string } }): translations => {\n  const result: translations = {};\n\n  for (const objectPath in localizeTranslations) {\n    const parts = objectPath.split('.');\n\n    let target = result;\n    while (parts.length > 1) {\n      const part = parts.shift() as string;\n      target = target[part] = (target[part] as translations) || {};\n    }\n\n    target[parts[0]] = localizeTranslations[objectPath].text;\n  }\n\n  return result;\n};\n","import { translations } from './constants';\n\nconst isObject = (item: unknown): boolean => {\n  return item === Object(item) && !Array.isArray(item);\n};\n\nexport const deepMerge = (target: translations, sources: translations | translations[]): translations => {\n  if (!Array.isArray(sources)) {\n    sources = [sources];\n  }\n  sources\n    .filter((source) => isObject(source))\n    .forEach((source) => {\n      Object.entries(source).forEach(([key, value]) => {\n        if (typeof value === 'string') {\n          target[key] = value;\n        } else {\n          if (typeof value === 'object') {\n            if (!target[key] || !(typeof target[key] === 'object')) {\n              target[key] = {};\n            }\n            deepMerge(target[key] as translations, value);\n          }\n        }\n      });\n    });\n  return target;\n};\n","import { Inject, Injectable, Optional, SkipSelf } from '@angular/core';\nimport '@angular/localize/init';\nimport { TranslateLoader } from '@ngx-translate/core';\nimport { GetTranslationsResponse, LexiconApiService } from '@vendasta/lexicon';\nimport { PartnerServiceInterface, PartnerServiceInterfaceToken } from '@galaxy/partner';\nimport { combineLatest, Observable, of } from 'rxjs';\nimport { debounceTime, map, shareReplay, startWith, switchMap } from 'rxjs/operators';\nimport {\n  LEXICON_BASE_TRANSLATION,\n  LEXICON_COMPONENT_NAME,\n  LEXICON_DISABLE_OTW,\n  LEXICON_FILE_FORMAT,\n  LEXICON_FILE_FORMAT_OPTION,\n  translations,\n} from './constants';\nimport { convertToFlatJson, convertToNestedJson } from './converters';\nimport { deepMerge } from './merge';\n\ndeclare const $localize: { TRANSLATIONS: { [key: string]: { text: string } } };\ndeclare global {\n  interface Window {\n    partnerId: string;\n  }\n}\n\n@Injectable()\nexport class LexiconLoader implements TranslateLoader {\n  private _translations: { [lang: string]: Observable<translations> } = {};\n  private partnerId$: Observable<string>;\n\n  constructor(\n    @Inject(LEXICON_COMPONENT_NAME) private componentNames: string[],\n    @Inject(LEXICON_BASE_TRANSLATION) private baseTranslations: translations[],\n    @Inject(LEXICON_DISABLE_OTW) private disableOtw: boolean,\n    @Inject(LEXICON_FILE_FORMAT) private targetFileFormat: LEXICON_FILE_FORMAT_OPTION,\n    @Optional() @Inject(PartnerServiceInterfaceToken) private partnerService: PartnerServiceInterface,\n    private lexiconApiService: LexiconApiService,\n    @Optional() @SkipSelf() private parent?: LexiconLoader,\n  ) {\n    this.partnerId$ = !this.partnerService\n      ? of('')\n      : this.partnerService\n          .getPartnerId()\n          .pipe(\n            debounceTime(1000),\n            startWith(typeof window !== 'undefined' && window.partnerId ? window.partnerId : ''),\n          );\n  }\n\n  getTranslation(lang: string): Observable<translations> {\n    if (this._translations[lang]) {\n      return this._translations[lang];\n    }\n\n    let translations$: Observable<translations>;\n    if (this.disableOtw) {\n      translations$ = of(deepMerge({}, this.baseTranslations));\n    } else {\n      translations$ = this.partnerId$.pipe(\n        switchMap((partnerId: string) => {\n          const componentNames = this.removeDuplicateComponentNames();\n          if (componentNames.length === 0) {\n            return of(new GetTranslationsResponse({ translations: {} }));\n          }\n          return this.lexiconApiService.getTranslations({\n            componentNames: componentNames,\n            languageCode: lang,\n            partnerId: partnerId,\n          });\n        }),\n        map((response: GetTranslationsResponse) => response.translations || {}),\n      );\n    }\n\n    if (this.parent) {\n      translations$ = combineLatest([this.parent.getTranslation(lang), translations$]).pipe(\n        map(([parent, child]) => deepMerge(parent, [child])),\n      );\n    }\n\n    // Merge translations from $angular/localize store into ngx-translate store\n    translations$ = translations$.pipe(\n      map((translations) => this.augmentWithAngularLocalizeTranslations(translations)),\n      shareReplay(1),\n    );\n\n    this._translations[lang] = translations$;\n    return translations$;\n  }\n\n  private removeDuplicateComponentNames() {\n    let components = Array.from(new Set(this.componentNames || []));\n    if (this.parent?.componentNames) {\n      const p = this.parent?.componentNames;\n      components = components.filter((c) => p.indexOf(c) < 0);\n    }\n    return components.filter((c) => !!c);\n  }\n\n  augmentWithAngularLocalizeTranslations(translations: translations): translations {\n    if (!$localize || !$localize.TRANSLATIONS) {\n      return translations;\n    }\n    switch (this.targetFileFormat) {\n      case LEXICON_FILE_FORMAT_OPTION.XLIFF1:\n        // TODO: Support XLIFF1 merging\n        return translations;\n      case LEXICON_FILE_FORMAT_OPTION.FLAT_JSON: {\n        const flatJson = convertToFlatJson($localize.TRANSLATIONS);\n        return deepMerge(translations, [flatJson]);\n      }\n      case LEXICON_FILE_FORMAT_OPTION.NESTED_JSON: {\n        const nestedJson = convertToNestedJson($localize.TRANSLATIONS);\n        return deepMerge(translations, [nestedJson]);\n      }\n      default:\n        return translations;\n    }\n  }\n}\n","import { Inject, Injectable } from '@angular/core';\nimport { MissingTranslationHandler, MissingTranslationHandlerParams } from '@ngx-translate/core';\nimport { LEXICON_BASE_TRANSLATION } from './constants';\n\ninterface InterpolateParams {\n  [key: string]: string;\n}\n\n@Injectable()\nexport class LexiconMissingTranslationHandler implements MissingTranslationHandler {\n  constructor(@Inject(LEXICON_BASE_TRANSLATION) private baseTranslations: any[]) {}\n\n  handle(params: MissingTranslationHandlerParams): string {\n    for (let baseTranslation of this.baseTranslations) {\n      if (Object.prototype.hasOwnProperty.call(baseTranslation, params.key)) {\n        baseTranslation = baseTranslation[params.key];\n      }\n      const parts = params.key.split('.', -1);\n      for (const part of parts) {\n        if (Object.prototype.hasOwnProperty.call(baseTranslation, part)) {\n          baseTranslation = baseTranslation[part];\n        }\n      }\n      if (typeof baseTranslation === 'string') {\n        if (typeof params.interpolateParams === 'object') {\n          if (this.isInterpolateParams(params.interpolateParams)) {\n            for (const [param, value] of Object.entries<string>(params.interpolateParams)) {\n              baseTranslation = baseTranslation.replace(new RegExp(`{{ ?${param} ?}}`, 'g'), value);\n            }\n          }\n        }\n        return baseTranslation;\n      }\n    }\n    return params.key;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  isInterpolateParams(obj: Object): obj is InterpolateParams {\n    return Object.values(obj).every((value) => typeof value === 'string' || typeof value === 'number');\n  }\n}\n","// *********************************\n// Code generated by sdkgen - edited by you!\n//\n// This module contains any hand-written services or other things your module\n// needs to share with applications that use it.\n// *********************************\nimport { ModuleWithProviders, NgModule } from '@angular/core';\nimport {\n  DEFAULT_LANGUAGE,\n  MissingTranslationHandler,\n  TranslateCompiler,\n  TranslateDefaultParser,\n  TranslateFakeCompiler,\n  TranslateLoader,\n  TranslateModule,\n  TranslateModuleConfig,\n  TranslateParser,\n  TranslateService,\n  TranslateStore,\n  USE_DEFAULT_LANG,\n  USE_EXTEND,\n  USE_STORE,\n} from '@ngx-translate/core';\nimport {\n  LEXICON_BASE_TRANSLATION,\n  LEXICON_COMPONENT_NAME,\n  LEXICON_DISABLE_OTW,\n  LEXICON_FILE_FORMAT,\n  LEXICON_FILE_FORMAT_OPTION,\n  LEXICON_PARTNER_ID,\n  LEXICON_ROOT_COMPONENT,\n} from './constants';\nimport { LexiconLoader } from './lexicon.loader';\nimport { LexiconMissingTranslationHandler } from './lexicon.missing-translation-handler';\n\ndeclare const window: {\n  deployment: string;\n};\n\nexport interface LexiconModuleConfig extends TranslateModuleConfig {\n  componentName?: string;\n  baseTranslation?: any;\n  disableOtw?: boolean;\n  fileFormat?: LEXICON_FILE_FORMAT_OPTION;\n}\n\n@NgModule({\n  imports: [TranslateModule],\n  exports: [TranslateModule],\n})\nexport class LexiconModule {\n  public static forRoot(config: LexiconModuleConfig = {}): ModuleWithProviders<LexiconModule> {\n    return {\n      ngModule: LexiconModule,\n      providers: [\n        config.loader || {\n          provide: TranslateLoader,\n          useClass: LexiconLoader,\n        },\n        { provide: LexiconLoader, useExisting: TranslateLoader },\n        config.missingTranslationHandler || {\n          provide: MissingTranslationHandler,\n          useClass: LexiconMissingTranslationHandler,\n        },\n        config.compiler || { provide: TranslateCompiler, useClass: TranslateFakeCompiler },\n        config.parser || { provide: TranslateParser, useClass: TranslateDefaultParser },\n        TranslateStore,\n        { provide: USE_STORE, useValue: true },\n        { provide: USE_DEFAULT_LANG, useValue: true },\n        { provide: USE_EXTEND, useValue: false },\n        { provide: DEFAULT_LANGUAGE, useValue: config.defaultLanguage || 'en' },\n        { provide: LEXICON_ROOT_COMPONENT, useValue: config.componentName || '' },\n        { provide: LEXICON_COMPONENT_NAME, useValue: config.componentName || '', multi: true },\n        { provide: LEXICON_BASE_TRANSLATION, useValue: config.baseTranslation || {}, multi: true },\n        { provide: LEXICON_PARTNER_ID, useValue: '' },\n        {\n          provide: LEXICON_DISABLE_OTW,\n          useValue: config.disableOtw !== false && (typeof window === 'undefined' || window.deployment === undefined),\n        },\n        { provide: LEXICON_FILE_FORMAT, useValue: config.fileFormat || LEXICON_FILE_FORMAT_OPTION.NESTED_JSON },\n        TranslateService,\n      ],\n    };\n  }\n\n  public static forChild(config: LexiconModuleConfig = {}): ModuleWithProviders<LexiconModule> {\n    return {\n      ngModule: LexiconModule,\n      providers: [\n        config.loader || {\n          provide: TranslateLoader,\n          useClass: LexiconLoader,\n        },\n        { provide: LexiconLoader, useExisting: TranslateLoader },\n        config.missingTranslationHandler || {\n          provide: MissingTranslationHandler,\n          useClass: LexiconMissingTranslationHandler,\n        },\n        config.compiler || { provide: TranslateCompiler, useClass: TranslateFakeCompiler },\n        config.parser || { provide: TranslateParser, useClass: TranslateDefaultParser },\n        { provide: LEXICON_COMPONENT_NAME, useValue: config.componentName || '', multi: true },\n        { provide: LEXICON_BASE_TRANSLATION, useValue: config.baseTranslation || {}, multi: true },\n        TranslateService,\n      ],\n    };\n  }\n}\n","export { LexiconModule } from './lexicon.module';\nexport { LexiconLoader } from './lexicon.loader';\nexport { LexiconMissingTranslationHandler } from './lexicon.missing-translation-handler';\nexport { LexiconApiService } from '@vendasta/lexicon';\nexport * from './constants';\nexport { TranslateService, DEFAULT_LANGUAGE } from '@ngx-translate/core';\n","export * from './lib';\n"],"mappings":"wcAAA,IAGYA,EAMCC,GACAC,EACAC,GACAC,EACAC,EACAC,GACAC,EAfbC,EAAAC,EAAA,KAAAC,IAGYV,EAAZ,SAAYA,EAA0B,CACpCA,OAAAA,EAAA,YAAA,cACAA,EAAA,UAAA,YACAA,EAAA,OAAA,SAHUA,CAIZ,EAJYA,GAA0B,CAAA,CAAA,EAMzBC,GAA+B,gCAC/BC,EAAyB,IAAIS,EAAuB,sBAAsB,EAC1ER,GAAqB,IAAIQ,EAAmC,kBAAkB,EAC9EP,EAAsB,IAAIO,EAAwB,mBAAmB,EACrEN,EAA2B,IAAIM,EAAe,wBAAwB,EACtEL,GAAyB,IAAIK,EAAuB,sBAAsB,EAC1EJ,EAAsB,IAAII,EAA2C,mBAAmB,IC0MrG,SAASC,GAAYC,EAAK,CACxBC,KAAgB,IAAI,YACpB,IAAMC,EAAOD,GAAY,OAAOD,CAAG,EAC7BG,EAAO,IAAI,SAASD,EAAK,OAAQA,EAAK,WAAYA,EAAK,UAAU,EACnEE,EAAKC,GAAOF,EAAMD,EAAK,OAAQ,CAAC,EAChCI,EAAKD,GAAOF,EAAMD,EAAK,OAAQ,MAAM,EACzC,OAAIE,GAAM,IAAME,GAAM,GAAKA,GAAM,KAC/BF,EAAKA,EAAK,UACVE,EAAKA,EAAK,aAEL,OAAO,QAAQ,GAAI,OAAOF,CAAE,CAAC,GAAK,OAAO,EAAE,EAAI,OAAO,QAAQ,GAAI,OAAOE,CAAE,CAAC,CACrF,CACA,SAASC,GAAaC,EAAKC,EAAU,GAAI,CACvC,IAAIC,EAAiBX,GAAYS,CAAG,EACpC,OAAIC,IAGFC,EAAiB,OAAO,QAAQ,GAAIA,GAAkB,OAAO,CAAC,CAAC,EAAIA,GAAkB,OAAO,EAAE,EAAI,OAAO,CAAC,EAC1GA,GAAkBX,GAAYU,CAAO,GAEhC,OAAO,QAAQ,GAAIC,CAAc,EAAE,SAAS,CACrD,CACA,SAASL,GAAOF,EAAMQ,EAAQC,EAAG,CAC/B,IAAIC,EAAI,WACNC,EAAI,WACFC,EAAQ,EACNC,EAAML,EAAS,GACrB,KAAOI,GAASC,EAAKD,GAAS,GAAI,CAChCF,GAAKV,EAAK,UAAUY,EAAO,EAAI,EAC/BD,GAAKX,EAAK,UAAUY,EAAQ,EAAG,EAAI,EACnCH,GAAKT,EAAK,UAAUY,EAAQ,EAAG,EAAI,EACnC,IAAME,EAAMC,GAAIL,EAAGC,EAAGF,CAAC,EACvBC,EAAII,EAAI,CAAC,EAAGH,EAAIG,EAAI,CAAC,EAAGL,EAAIK,EAAI,CAAC,CACnC,CACA,IAAME,EAAYR,EAASI,EAE3B,OAAAH,GAAKD,EACDQ,GAAa,GACfN,GAAKV,EAAK,UAAUY,EAAO,EAAI,EAC/BA,GAAS,EACLI,GAAa,GACfL,GAAKX,EAAK,UAAUY,EAAO,EAAI,EAC/BA,GAAS,EAELI,GAAa,IACfP,GAAKT,EAAK,SAASY,GAAO,GAAK,GAE7BI,GAAa,KACfP,GAAKT,EAAK,SAASY,GAAO,GAAK,IAE7BI,IAAc,KAChBP,GAAKT,EAAK,SAASY,GAAO,GAAK,MAI7BI,GAAa,IACfL,GAAKX,EAAK,SAASY,GAAO,GAExBI,GAAa,IACfL,GAAKX,EAAK,SAASY,GAAO,GAAK,GAE7BI,IAAc,IAChBL,GAAKX,EAAK,SAASY,GAAO,GAAK,OAK/BI,GAAa,IACfN,GAAKV,EAAK,SAASY,GAAO,GAExBI,GAAa,IACfN,GAAKV,EAAK,SAASY,GAAO,GAAK,GAE7BI,IAAc,IAChBN,GAAKV,EAAK,SAASY,GAAO,GAAK,KAG5BG,GAAIL,EAAGC,EAAGF,CAAC,EAAE,CAAC,CACvB,CAEA,SAASM,GAAIL,EAAGC,EAAGF,EAAG,CACpB,OAAAC,GAAKC,EACLD,GAAKD,EACLC,GAAKD,IAAM,GACXE,GAAKF,EACLE,GAAKD,EACLC,GAAKD,GAAK,EACVD,GAAKC,EACLD,GAAKE,EACLF,GAAKE,IAAM,GACXD,GAAKC,EACLD,GAAKD,EACLC,GAAKD,IAAM,GACXE,GAAKF,EACLE,GAAKD,EACLC,GAAKD,GAAK,GACVD,GAAKC,EACLD,GAAKE,EACLF,GAAKE,IAAM,EACXD,GAAKC,EACLD,GAAKD,EACLC,GAAKD,IAAM,EACXE,GAAKF,EACLE,GAAKD,EACLC,GAAKD,GAAK,GACVD,GAAKC,EACLD,GAAKE,EACLF,GAAKE,IAAM,GACJ,CAACD,EAAGC,EAAGF,CAAC,CACjB,CAoDA,SAASQ,GAAaC,EAAcC,EAAaC,EAAUC,EAAsBC,EAAsB,CAAC,EAAG,CACzG,IAAMC,EAAgB,CAAC,EACjBC,EAAwB,CAAC,EACzBC,EAAuB,CAAC,EACxBC,EAAWC,GAAcT,EAAa,CAAC,EAAGA,EAAa,IAAI,CAAC,CAAC,EAC7DU,EAAsB,CAACF,EAAS,IAAI,EACpCG,GAAmB,CAAC,EACtBC,EAAgBJ,EAAS,KAC7B,QAASK,EAAI,EAAGA,EAAIb,EAAa,OAAQa,IAAK,CAC5C,GAAM,CACJ,YAAAC,GACA,gBAAAC,EAAkBC,GAAuBH,CAAC,EAC1C,oBAAAI,EACF,EAAIC,GAAiBlB,EAAaa,CAAC,EAAGb,EAAa,IAAIa,CAAC,CAAC,EACzDD,GAAiB,KAAKG,CAAe,IAAID,EAAW,GAChDb,IAAgB,SAClBI,EAAcU,CAAe,EAAId,EAAYY,EAAI,CAAC,EAClDP,EAAsBS,CAAe,EAAIX,EAAoBS,EAAI,CAAC,GAEpEF,GAAiB,KAAKI,CAAe,EACjCE,KAAwB,SAC1BV,EAAqBQ,CAAe,EAAIE,IAE1CP,EAAoB,KAAKI,EAAW,CACtC,CACA,IAAMK,GAAYX,EAAS,UAAYtB,GAAa0B,EAAeJ,EAAS,SAAW,EAAE,EACnFY,GAAYZ,EAAS,UAAYA,EAAS,UAAU,OAAOa,GAAMA,IAAOF,EAAS,EAAI,CAAC,EAC5F,MAAO,CACL,GAAIA,GACJ,UAAAC,GACA,cAAAf,EACA,sBAAAC,EACA,KAAMM,EACN,SAAUJ,EAAS,SACnB,QAASA,EAAS,SAAW,GAC7B,YAAaA,EAAS,aAAe,GACrC,aAAcE,EACd,qBAAAP,EACA,iBAAAQ,GACA,qBAAAJ,EACA,SAAAL,CACF,CACF,CA2BA,SAASO,GAAca,EAAQC,EAAK,CAClC,GAAM,CACJ,KAAMX,EACN,MAAAY,CACF,EAAIC,GAAWH,EAAQC,CAAG,EAC1B,GAAIC,IAAU,OACZ,MAAO,CACL,KAAMZ,CACR,EACK,CACL,GAAM,CAACc,EAAkB,GAAGN,CAAS,EAAII,EAAM,MAAMG,EAAmB,EAClE,CAACC,EAAgBC,CAAQ,EAAIH,EAAiB,MAAMI,GAAc,CAAC,EACrE,CAAC1C,EAAS2C,CAAW,EAAIH,EAAe,MAAMI,GAAmB,CAAC,EACtE,OAAID,IAAgB,SAClBA,EAAc3C,EACdA,EAAU,QAER2C,IAAgB,KAClBA,EAAc,QAET,CACL,KAAMnB,EACN,QAAAxB,EACA,YAAA2C,EACA,SAAAF,EACA,UAAAT,CACF,CACF,CACF,CAqBA,SAASF,GAAiBI,EAAQC,EAAK,CACrC,GAAM,CACJ,KAAMT,EACN,MAAAU,CACF,EAAIC,GAAWH,EAAQC,CAAG,EAC1B,GAAIC,IAAU,OACZ,MAAO,CACL,YAAAV,CACF,EACK,CACL,GAAM,CAACC,EAAiBE,CAAmB,EAAIO,EAAM,MAAMM,EAAY,EACvE,MAAO,CACL,YAAAhB,EACA,gBAAAC,EACA,oBAAAE,CACF,CACF,CACF,CAqBA,SAASQ,GAAWH,EAAQC,EAAK,CAC/B,GAAIA,EAAI,OAAO,CAAC,IAAMU,EACpB,MAAO,CACL,KAAMX,CACR,EACK,CACL,IAAMY,EAAaC,GAAeb,EAAQC,CAAG,EAC7C,MAAO,CACL,MAAOD,EAAO,UAAU,EAAGY,CAAU,EACrC,KAAMZ,EAAO,UAAUY,EAAa,CAAC,CACvC,CACF,CACF,CACA,SAASlB,GAAuBtB,EAAO,CACrC,OAAOA,IAAU,EAAI,KAAO,MAAMA,EAAQ,CAAC,EAC7C,CAUA,SAASyC,GAAeb,EAAQC,EAAK,CACnC,QAASa,EAAc,EAAGC,EAAW,EAAGD,EAAcd,EAAO,OAAQc,IAAeC,IAClF,GAAId,EAAIc,CAAQ,IAAM,KACpBA,YACSf,EAAOc,CAAW,IAAMH,EACjC,OAAOG,EAGX,MAAM,IAAI,MAAM,6CAA6Cb,CAAG,IAAI,CACtE,CA2BA,SAASe,GAAYC,EAAcvC,EAAcK,EAAe,CAC9D,IAAMmC,EAAUzC,GAAaC,EAAcK,CAAa,EAEpDoC,EAAcF,EAAaC,EAAQ,EAAE,EAEzC,GAAIA,EAAQ,YAAc,OACxB,QAAS3B,EAAI,EAAGA,EAAI2B,EAAQ,UAAU,QAAUC,IAAgB,OAAW5B,IACzE4B,EAAcF,EAAaC,EAAQ,UAAU3B,CAAC,CAAC,EAGnD,GAAI4B,IAAgB,OAClB,MAAM,IAAIC,EAAwBF,CAAO,EAE3C,MAAO,CAACC,EAAY,aAAcA,EAAY,iBAAiB,IAAIE,GAAe,CAChF,GAAIH,EAAQ,cAAc,eAAeG,CAAW,EAClD,OAAOH,EAAQ,cAAcG,CAAW,EAExC,MAAM,IAAI,MAAM,sFAAsFC,GAAgBJ,CAAO,CAAC;AAAA,mDAA4DG,CAAW,wCAAwC,CAEjP,CAAC,CAAC,CACJ,CASA,SAASE,GAAiBjC,EAAe,CACvC,IAAMkC,EAAQlC,EAAc,MAAM,aAAa,EACzCZ,EAAe,CAAC8C,EAAM,CAAC,CAAC,EACxBnC,EAAmB,CAAC,EAC1B,QAASE,EAAI,EAAGA,EAAIiC,EAAM,OAAS,EAAGjC,GAAK,EACzCF,EAAiB,KAAKmC,EAAMjC,CAAC,CAAC,EAC9Bb,EAAa,KAAK,GAAG8C,EAAMjC,EAAI,CAAC,CAAC,EAAE,EAErC,IAAMkC,EAAkB/C,EAAa,IAAIgD,GAAQA,EAAK,OAAO,CAAC,IAAMf,EAAiB,KAAOe,EAAOA,CAAI,EACvG,MAAO,CACL,KAAMpC,EACN,aAAcqC,GAAmBjD,EAAc+C,CAAe,EAC9D,iBAAApC,CACF,CACF,CAwBA,SAASsC,GAAmB3B,EAAQC,EAAK,CACvC,cAAO,eAAeD,EAAQ,MAAO,CACnC,MAAOC,CACT,CAAC,EACMD,CACT,CACA,SAASsB,GAAgBJ,EAAS,CAChC,IAAMU,EAAgBV,EAAQ,SAAW,OAAOA,EAAQ,OAAO,IACzDW,EAASX,EAAQ,WAAaA,EAAQ,UAAU,OAAS,EAAI,KAAKA,EAAQ,UAAU,IAAIY,GAAK,IAAIA,CAAC,GAAG,EAAE,KAAK,IAAI,CAAC,IAAM,GAC7H,MAAO,IAAIZ,EAAQ,EAAE,IAAIW,CAAM,MAAMX,EAAQ,IAAI,IAAIU,CAAa,GACpE,CAyCA,SAASG,GAAiBd,EAAc,CAEjC,UAAU,YACb,UAAU,UAAYe,IAEnB,UAAU,eACb,UAAU,aAAe,CAAC,GAE5B,OAAO,KAAKf,CAAY,EAAE,QAAQgB,GAAO,CACvC,UAAU,aAAaA,CAAG,EAAIV,GAAiBN,EAAagB,CAAG,CAAC,CAClE,CAAC,CACH,CAoBA,SAASD,GAAUtD,EAAcK,EAAe,CAC9C,GAAI,CACF,OAAOiC,GAAY,UAAU,aAActC,EAAcK,CAAa,CACxE,OAASmD,EAAG,CACV,eAAQ,KAAKA,EAAE,OAAO,EACf,CAACxD,EAAcK,CAAa,CACrC,CACF,CA4HA,SAASoD,GAAW3C,EAAa4C,EAAgB,CAC/C,OAAOA,EAAe,OAAO,CAAC,IAAMC,GAAe7C,EAAY,UAAUqB,GAAerB,EAAa4C,CAAc,EAAI,CAAC,EAAI5C,CAC9H,CA72BA,IAkBMmB,EAWAD,GAUAF,GAgBAH,GAKF/C,GA6fE8D,EAuRAkB,EAaAD,GA71BNE,GAAAC,EAAA,KAkBM7B,EAAiB,IAWjBD,GAAoB,IAUpBF,GAAe,KAgBfH,GAAsB,SAkgBtBe,EAAN,cAAsC,KAAM,CAC1C,YAAYqB,EAAe,CACzB,MAAM,4BAA4BnB,GAAgBmB,CAAa,CAAC,GAAG,EACnE,KAAK,cAAgBA,EACrB,KAAK,KAAO,yBACd,CACF,EAiRMH,EAAc,SAAU5D,KAAiBC,EAAa,CAC1D,GAAI2D,EAAY,UAAW,CAEzB,IAAMnB,EAAcmB,EAAY,UAAU5D,EAAcC,CAAW,EACnED,EAAeyC,EAAY,CAAC,EAC5BxC,EAAcwC,EAAY,CAAC,CAC7B,CACA,IAAID,EAAUiB,GAAWzD,EAAa,CAAC,EAAGA,EAAa,IAAI,CAAC,CAAC,EAC7D,QAAS,EAAI,EAAG,EAAIA,EAAa,OAAQ,IACvCwC,GAAWvC,EAAY,EAAI,CAAC,EAAIwD,GAAWzD,EAAa,CAAC,EAAGA,EAAa,IAAI,CAAC,CAAC,EAEjF,OAAOwC,CACT,EACMmB,GAAe,MC71BrB,IAAAK,GAAAC,EAAA,KAMAC,KAIA,WAAW,UAAYC,ICVvB,IAKMC,GACAC,GAOFC,GAsBEC,EAoBAC,EAuBAC,EA0BAC,EAoBAC,EA0BAC,EAoBAC,EA0BAC,EA6BAC,EA6DFC,EA9RJC,EAAAC,EAAA,KAAAC,IAEAC,KACAA,KACAC,KACMjB,IAAe,OAAS,OAAO,YAAiB,SAAW,OAC3DC,GAAU,CACd,MAAS,iCACT,KAAQ,GACR,KAAQ,6BACR,KAAQ,6BACR,WAAc,4BAChB,EACIC,IAA4B,IAAM,CACpC,MAAMA,CAAY,CAChB,IAAI,MAAO,CACT,OAAOD,GAAQD,GAAY,YAAY,CAAC,CAC1C,CACA,IAAI,gBAAiB,CACnB,MAAO,WAAa,KAAK,IAC3B,CACF,CACA,OAAAE,EAAY,UAAO,SAA6BgB,EAAG,CACjD,OAAO,IAAKA,GAAKhB,EACnB,EACAA,EAAY,WAA0BiB,EAAmB,CACvD,MAAOjB,EACP,QAASA,EAAY,UACrB,WAAY,MACd,CAAC,EACMA,CACT,GAAG,EAIGC,EAAN,MAAMiB,CAA6B,CACjC,OAAO,UAAUC,EAAO,CACtB,IAAIC,EAAI,IAAIF,EACZ,OAAAE,EAAI,OAAO,OAAOA,EAAGD,CAAK,EACnBC,CACT,CACA,YAAYC,EAAQ,CACbA,GAGL,OAAO,OAAO,KAAMA,CAAM,CAC5B,CACA,WAAY,CACV,IAAMC,EAAW,CAAC,EAClB,OAAI,OAAO,KAAK,cAAkB,MAChCA,EAAS,cAAmB,KAAK,eAE5BA,CACT,CACF,EACMpB,EAAN,MAAMqB,CAA8B,CAClC,OAAO,UAAUJ,EAAO,CACtB,IAAIC,EAAI,IAAIG,EACZ,OAAAH,EAAI,OAAO,OAAOA,EAAGD,CAAK,EACtBA,EAAM,YACRC,EAAE,UAAYD,EAAM,UAAU,IAAIX,EAAS,SAAS,GAE/CY,CACT,CACA,YAAYC,EAAQ,CACbA,GAGL,OAAO,OAAO,KAAMA,CAAM,CAC5B,CACA,WAAY,CACV,IAAMC,EAAW,CAAC,EAClB,OAAI,OAAO,KAAK,UAAc,KAAe,KAAK,YAAc,OAC9DA,EAAS,UAAe,cAAe,KAAK,UAAY,KAAK,UAAU,UAAU,EAAI,KAAK,WAErFA,CACT,CACF,EACMnB,EAAN,MAAMqB,CAAsB,CAC1B,OAAO,UAAUL,EAAO,CACtB,IAAIC,EAAI,IAAII,EACZ,OAAAJ,EAAI,OAAO,OAAOA,EAAGD,CAAK,EACnBC,CACT,CACA,YAAYC,EAAQ,CACbA,GAGL,OAAO,OAAO,KAAMA,CAAM,CAC5B,CACA,WAAY,CACV,IAAMC,EAAW,CAAC,EAClB,OAAI,OAAO,KAAK,cAAkB,MAChCA,EAAS,cAAmB,KAAK,eAE/B,OAAO,KAAK,UAAc,MAC5BA,EAAS,UAAe,KAAK,WAE3B,OAAO,KAAK,aAAiB,MAC/BA,EAAS,aAAkB,KAAK,cAE3BA,CACT,CACF,EACMlB,EAAN,MAAMqB,CAAuB,CAC3B,OAAO,UAAUN,EAAO,CACtB,IAAIC,EAAI,IAAIK,EACZ,OAAAL,EAAI,OAAO,OAAOA,EAAGD,CAAK,EACnBC,CACT,CACA,YAAYC,EAAQ,CACbA,GAGL,OAAO,OAAO,KAAMA,CAAM,CAC5B,CACA,WAAY,CACV,IAAMC,EAAW,CAAC,EAClB,OAAI,OAAO,KAAK,aAAiB,MAC/BA,EAAS,aAAkB,KAAK,cAE3BA,CACT,CACF,EACMjB,EAAN,MAAMqB,CAAuB,CAC3B,OAAO,UAAUP,EAAO,CACtB,IAAIC,EAAI,IAAIM,EACZ,OAAAN,EAAI,OAAO,OAAOA,EAAGD,CAAK,EACnBC,CACT,CACA,YAAYC,EAAQ,CACbA,GAGL,OAAO,OAAO,KAAMA,CAAM,CAC5B,CACA,WAAY,CACV,IAAMC,EAAW,CAAC,EAClB,OAAI,OAAO,KAAK,eAAmB,MACjCA,EAAS,eAAoB,KAAK,gBAEhC,OAAO,KAAK,UAAc,MAC5BA,EAAS,UAAe,KAAK,WAE3B,OAAO,KAAK,aAAiB,MAC/BA,EAAS,aAAkB,KAAK,cAE3BA,CACT,CACF,EACMhB,EAAN,MAAMqB,CAAwB,CAC5B,OAAO,UAAUR,EAAO,CACtB,IAAIC,EAAI,IAAIO,EACZ,OAAAP,EAAI,OAAO,OAAOA,EAAGD,CAAK,EACnBC,CACT,CACA,YAAYC,EAAQ,CACbA,GAGL,OAAO,OAAO,KAAMA,CAAM,CAC5B,CACA,WAAY,CACV,IAAMC,EAAW,CAAC,EAClB,OAAI,OAAO,KAAK,aAAiB,MAC/BA,EAAS,aAAkB,KAAK,cAE3BA,CACT,CACF,EACMf,EAAN,MAAMqB,CAAuB,CAC3B,OAAO,UAAUT,EAAO,CACtB,IAAIC,EAAI,IAAIQ,EACZ,OAAAR,EAAI,OAAO,OAAOA,EAAGD,CAAK,EACnBC,CACT,CACA,YAAYC,EAAQ,CACbA,GAGL,OAAO,OAAO,KAAMA,CAAM,CAC5B,CACA,WAAY,CACV,IAAMC,EAAW,CAAC,EAClB,OAAI,OAAO,KAAK,cAAkB,MAChCA,EAAS,cAAmB,KAAK,eAE/B,OAAO,KAAK,UAAc,MAC5BA,EAAS,UAAe,KAAK,WAE3B,OAAO,KAAK,aAAiB,MAC/BA,EAAS,aAAkB,KAAK,cAE3BA,CACT,CACF,EACMd,EAAN,MAAMqB,CAAS,CACb,OAAO,UAAUV,EAAO,CACtB,IAAIC,EAAI,IAAIS,EACZ,OAAAT,EAAI,OAAO,OAAOA,EAAGD,CAAK,EACtBA,EAAM,qBACRC,EAAE,mBAAqBX,EAAW,UAAUU,EAAM,kBAAkB,GAE/DC,CACT,CACA,YAAYC,EAAQ,CACbA,GAGL,OAAO,OAAO,KAAMA,CAAM,CAC5B,CACA,WAAY,CACV,IAAMC,EAAW,CAAC,EAClB,OAAI,OAAO,KAAK,aAAiB,MAC/BA,EAAS,aAAkB,KAAK,cAE9B,OAAO,KAAK,aAAiB,MAC/BA,EAAS,aAAkB,KAAK,cAE9B,OAAO,KAAK,mBAAuB,KAAe,KAAK,qBAAuB,OAChFA,EAAS,mBAAwB,cAAe,KAAK,mBAAqB,KAAK,mBAAmB,UAAU,EAAI,KAAK,oBAEhHA,CACT,CACF,EACMb,EAAN,MAAMqB,CAAW,CACf,OAAO,UAAUX,EAAO,CACtB,IAAIC,EAAI,IAAIU,EACZ,OAAAV,EAAI,OAAO,OAAOA,EAAGD,CAAK,EACtBA,EAAM,QACRC,EAAE,MAAQ,SAASD,EAAM,MAAO,EAAE,GAEhCA,EAAM,aACRC,EAAE,WAAa,SAASD,EAAM,WAAY,EAAE,GAE1CA,EAAM,aACRC,EAAE,WAAa,SAASD,EAAM,WAAY,EAAE,GAE1CA,EAAM,kBACRC,EAAE,gBAAkB,SAASD,EAAM,gBAAiB,EAAE,GAEpDA,EAAM,UACRC,EAAE,QAAU,SAASD,EAAM,QAAS,EAAE,GAEjCC,CACT,CACA,YAAYC,EAAQ,CACbA,GAGL,OAAO,OAAO,KAAMA,CAAM,CAC5B,CACA,WAAY,CACV,IAAMC,EAAW,CAAC,EAClB,OAAI,OAAO,KAAK,MAAU,MACxBA,EAAS,MAAW,KAAK,OAEvB,OAAO,KAAK,WAAe,MAC7BA,EAAS,WAAgB,KAAK,YAE5B,OAAO,KAAK,WAAe,MAC7BA,EAAS,WAAgB,KAAK,YAE5B,OAAO,KAAK,gBAAoB,MAClCA,EAAS,gBAAqB,KAAK,iBAEjC,OAAO,KAAK,QAAY,MAC1BA,EAAS,QAAa,KAAK,SAEtBA,CACT,CACF,EAeIZ,GAAkC,IAAM,CAC1C,MAAMA,CAAkB,CACtB,YAAYqB,EAAMC,EAAa,CAC7B,KAAK,KAAOD,EACZ,KAAK,YAAcC,EACnB,KAAK,MAAQ,KAAK,YAAY,cAChC,CACA,YAAa,CACX,MAAO,CACL,QAAS,IAAIC,GAAY,CACvB,eAAgB,kBAClB,CAAC,EACD,gBAAiB,EACnB,CACF,CACA,eAAeC,EAAG,CAChB,IAAMC,EAAUD,EAAE,UAAYA,EAAI,IAAI/B,EAAsB+B,CAAC,EAC7D,OAAO,KAAK,KAAK,KAAK,KAAK,MAAQ,qCAAsCC,EAAQ,UAAU,EAAG,KAAK,WAAW,CAAC,EAAE,KAAKC,EAAIC,GAAQjC,EAAuB,UAAUiC,CAAI,CAAC,CAAC,CAC3K,CACA,gBAAgBH,EAAG,CACjB,IAAMC,EAAUD,EAAE,UAAYA,EAAI,IAAI7B,EAAuB6B,CAAC,EAC9D,OAAO,KAAK,KAAK,KAAK,KAAK,MAAQ,sCAAuCC,EAAQ,UAAU,EAAG,KAAK,WAAW,CAAC,EAAE,KAAKC,EAAIC,GAAQ/B,EAAwB,UAAU+B,CAAI,CAAC,CAAC,CAC7K,CACA,gBAAgBH,EAAG,CACjB,IAAMC,EAAUD,EAAE,UAAYA,EAAI,IAAI3B,EAAuB2B,CAAC,EAC9D,OAAO,KAAK,KAAK,KAAK,KAAK,MAAQ,sCAAuCC,EAAQ,UAAU,EAAGG,GAAAC,GAAA,GAC1F,KAAK,WAAW,GAD0E,CAE7F,QAAS,UACX,EAAC,CACH,CACA,sBAAsBL,EAAG,CACvB,IAAMC,EAAUD,EAAE,UAAYA,EAAI,IAAIjC,EAA6BiC,CAAC,EACpE,OAAO,KAAK,KAAK,KAAK,KAAK,MAAQ,4CAA6CC,EAAQ,UAAU,EAAG,KAAK,WAAW,CAAC,EAAE,KAAKC,EAAIC,GAAQnC,EAA8B,UAAUmC,CAAI,CAAC,CAAC,CACzL,CACF,CACA,OAAA3B,EAAkB,UAAO,SAAmCM,EAAG,CAC7D,OAAO,IAAKA,GAAKN,GAAsB8B,EAAYC,EAAU,EAAMD,EAASxC,EAAW,CAAC,CAC1F,EACAU,EAAkB,WAA0BO,EAAmB,CAC7D,MAAOP,EACP,QAASA,EAAkB,UAC3B,WAAY,MACd,CAAC,EACMA,CACT,GAAG,ICxUH,IAAagC,GAQAC,GARbC,GAAAC,EAAA,KAAaH,GAAqBI,GAA2E,CAC3G,IAAMC,EAAoC,CAAA,EAC1CC,cAAOC,QAAQH,CAAoB,EAAEI,QAAQ,CAAC,CAACC,EAAKC,CAAK,IAAK,CAC5DL,EAAOI,CAAG,EAAIC,EAAMC,IACtB,CAAC,EACMN,CACT,EAEaJ,GAAuBG,GAA2E,CAC7G,IAAMC,EAAuB,CAAA,EAE7B,QAAWO,KAAcR,EAAsB,CAC7C,IAAMS,EAAQD,EAAWE,MAAM,GAAG,EAE9BC,EAASV,EACb,KAAOQ,EAAMG,OAAS,GAAG,CACvB,IAAMC,EAAOJ,EAAMK,MAAK,EACxBH,EAASA,EAAOE,CAAI,EAAKF,EAAOE,CAAI,GAAsB,CAAA,CAC5D,CAEAF,EAAOF,EAAM,CAAC,CAAC,EAAIT,EAAqBQ,CAAU,EAAED,IACtD,CAEA,OAAON,CACT,ICxBA,IAAMc,GAIOC,EAJbC,GAAAC,EAAA,KAAMH,GAAYI,GACTA,IAASC,OAAOD,CAAI,GAAK,CAACE,MAAMC,QAAQH,CAAI,EAGxCH,EAAYA,CAACO,EAAsBC,KACzCH,MAAMC,QAAQE,CAAO,IACxBA,EAAU,CAACA,CAAO,GAEpBA,EACGC,OAAQC,GAAWX,GAASW,CAAM,CAAC,EACnCC,QAASD,GAAU,CAClBN,OAAOQ,QAAQF,CAAM,EAAEC,QAAQ,CAAC,CAACE,EAAKC,CAAK,IAAK,CAC1C,OAAOA,GAAU,SACnBP,EAAOM,CAAG,EAAIC,EAEV,OAAOA,GAAU,YACf,CAACP,EAAOM,CAAG,GAAO,OAAON,EAAOM,CAAG,GAAM,YAC3CN,EAAOM,CAAG,EAAI,CAAA,GAEhBb,EAAUO,EAAOM,CAAG,EAAmBC,CAAK,EAGlD,CAAC,CACH,CAAC,EACIP,KC1BT,IA0BaQ,EA1BbC,EAAAC,EAAA,KACAC,KAEAC,IACAC,KACAC,KACAC,KACAC,IAQAC,KACAC,aAUaV,GAAa,IAAA,CAApB,IAAOA,EAAP,MAAOA,CAAa,CAIxBW,YAC0CC,EACEC,EACLC,EACAC,EACqBC,EAClDC,EACwBC,EAAsB,CANd,KAAAN,eAAAA,EACE,KAAAC,iBAAAA,EACL,KAAAC,WAAAA,EACA,KAAAC,iBAAAA,EACqB,KAAAC,eAAAA,EAClD,KAAAC,kBAAAA,EACwB,KAAAC,OAAAA,EAV1B,KAAAC,cAA8D,CAAA,EAYpE,KAAKC,WAAc,KAAKJ,eAEpB,KAAKA,eACFK,aAAY,EACZC,KACCC,GAAa,GAAI,EACjBC,GAAU,OAAOC,OAAW,KAAeA,OAAOC,UAAYD,OAAOC,UAAY,EAAE,CAAC,EALxFC,EAAG,EAAE,CAOX,CAEAC,eAAeC,EAAY,CACzB,GAAI,KAAKV,cAAcU,CAAI,EACzB,OAAO,KAAKV,cAAcU,CAAI,EAGhC,IAAIC,EACJ,OAAI,KAAKhB,WACPgB,EAAgBH,EAAGI,EAAU,CAAA,EAAI,KAAKlB,gBAAgB,CAAC,EAEvDiB,EAAgB,KAAKV,WAAWE,KAC9BU,GAAWN,GAAqB,CAC9B,IAAMd,EAAiB,KAAKqB,8BAA6B,EACzD,OAAIrB,EAAesB,SAAW,EACrBP,EAAG,IAAIQ,EAAwB,CAAEC,aAAc,CAAA,CAAE,CAAE,CAAC,EAEtD,KAAKnB,kBAAkBoB,gBAAgB,CAC5CzB,eAAgBA,EAChB0B,aAAcT,EACdH,UAAWA,EACZ,CACH,CAAC,EACDa,EAAKC,GAAsCA,EAASJ,cAAgB,CAAA,CAAE,CAAC,EAIvE,KAAKlB,SACPY,EAAgBW,GAAc,CAAC,KAAKvB,OAAOU,eAAeC,CAAI,EAAGC,CAAa,CAAC,EAAER,KAC/EiB,EAAI,CAAC,CAACrB,EAAQwB,CAAK,IAAMX,EAAUb,EAAQ,CAACwB,CAAK,CAAC,CAAC,CAAC,GAKxDZ,EAAgBA,EAAcR,KAC5BiB,EAAKH,GAAiB,KAAKO,uCAAuCP,CAAY,CAAC,EAC/EQ,GAAY,CAAC,CAAC,EAGhB,KAAKzB,cAAcU,CAAI,EAAIC,EACpBA,CACT,CAEQG,+BAA6B,CACnC,IAAIY,EAAaC,MAAMC,KAAK,IAAIC,IAAI,KAAKpC,gBAAkB,CAAA,CAAE,CAAC,EAC9D,GAAI,KAAKM,QAAQN,eAAgB,CAC/B,IAAMqC,EAAI,KAAK/B,QAAQN,eACvBiC,EAAaA,EAAWK,OAAQC,GAAMF,EAAEG,QAAQD,CAAC,EAAI,CAAC,CACxD,CACA,OAAON,EAAWK,OAAQC,GAAM,CAAC,CAACA,CAAC,CACrC,CAEAR,uCAAuCP,EAA0B,CAC/D,GAAI,CAACiB,WAAa,CAACA,UAAUC,aAC3B,OAAOlB,EAET,OAAQ,KAAKrB,iBAAgB,CAC3B,KAAKwC,EAA2BC,OAE9B,OAAOpB,EACT,KAAKmB,EAA2BE,UAAW,CACzC,IAAMC,EAAWC,GAAkBN,UAAUC,YAAY,EACzD,OAAOvB,EAAUK,EAAc,CAACsB,CAAQ,CAAC,CAC3C,CACA,KAAKH,EAA2BK,YAAa,CAC3C,IAAMC,EAAaC,GAAoBT,UAAUC,YAAY,EAC7D,OAAOvB,EAAUK,EAAc,CAACyB,CAAU,CAAC,CAC7C,CACA,QACE,OAAOzB,CACX,CACF,yCA5FWpC,GAAa+D,EAKdC,CAAsB,EAAAD,EACtBE,CAAwB,EAAAF,EACxBG,CAAmB,EAAAH,EACnBI,CAAmB,EAAAJ,EACPK,GAA4B,CAAA,EAAAL,EAAAM,CAAA,EAAAN,EAAA/D,EAAA,EAAA,CAAA,CAAA,wBATvCA,EAAasE,QAAbtE,EAAauE,SAAA,CAAA,EAApB,IAAOvE,EAAPwE,SAAOxE,CAAa,GAAA,IC1B1B,IASayE,EATbC,GAAAC,EAAA,KAEAC,QAOaH,GAAgC,IAAA,CAAvC,IAAOA,EAAP,MAAOA,CAAgC,CAC3CI,YAAsDC,EAAuB,CAAvB,KAAAA,iBAAAA,CAA0B,CAEhFC,OAAOC,EAAuC,CAC5C,QAASC,KAAmB,KAAKH,iBAAkB,CAC7CI,OAAOC,UAAUC,eAAeC,KAAKJ,EAAiBD,EAAOM,GAAG,IAClEL,EAAkBA,EAAgBD,EAAOM,GAAG,GAE9C,IAAMC,EAAQP,EAAOM,IAAIE,MAAM,IAAK,EAAE,EACtC,QAAWC,KAAQF,EACbL,OAAOC,UAAUC,eAAeC,KAAKJ,EAAiBQ,CAAI,IAC5DR,EAAkBA,EAAgBQ,CAAI,GAG1C,GAAI,OAAOR,GAAoB,SAAU,CACvC,GAAI,OAAOD,EAAOU,mBAAsB,UAClC,KAAKC,oBAAoBX,EAAOU,iBAAiB,EACnD,OAAW,CAACE,EAAOC,CAAK,IAAKX,OAAOY,QAAgBd,EAAOU,iBAAiB,EAC1ET,EAAkBA,EAAgBc,QAAQ,IAAIC,OAAO,OAAOJ,CAAK,OAAQ,GAAG,EAAGC,CAAK,EAI1F,OAAOZ,CACT,CACF,CACA,OAAOD,EAAOM,GAChB,CAGAK,oBAAoBM,EAAW,CAC7B,OAAOf,OAAOgB,OAAOD,CAAG,EAAEE,MAAON,GAAU,OAAOA,GAAU,UAAY,OAAOA,GAAU,QAAQ,CACnG,yCA/BWpB,GAAgC2B,EACvBC,CAAwB,CAAA,CAAA,wBADjC5B,EAAgC6B,QAAhC7B,EAAgC8B,SAAA,CAAA,EAAvC,IAAO9B,EAAP+B,SAAO/B,CAAgC,GAAA,ICT7C,IAkDagC,GAlDbC,GAAAC,EAAA,KAOAC,KAgBAC,IASAC,IACAC,SAiBaN,IAAa,IAAA,CAApB,IAAOA,EAAP,MAAOA,CAAa,CACjB,OAAOO,QAAQC,EAA8B,CAAA,EAAE,CACpD,MAAO,CACLC,SAAUT,EACVU,UAAW,CACTF,EAAOG,QAAU,CACfC,QAASC,EACTC,SAAUC,GAEZ,CAAEH,QAASG,EAAeC,YAAaH,CAAe,EACtDL,EAAOS,2BAA6B,CAClCL,QAASM,EACTJ,SAAUK,GAEZX,EAAOY,UAAY,CAAER,QAASS,EAAmBP,SAAUQ,CAAqB,EAChFd,EAAOe,QAAU,CAAEX,QAASY,EAAiBV,SAAUW,CAAsB,EAC7EC,GACA,CAAEd,QAASe,GAAWC,SAAU,EAAI,EACpC,CAAEhB,QAASiB,GAAkBD,SAAU,EAAI,EAC3C,CAAEhB,QAASkB,GAAYF,SAAU,EAAK,EACtC,CAAEhB,QAASmB,EAAkBH,SAAUpB,EAAOwB,iBAAmB,IAAI,EACrE,CAAEpB,QAASqB,GAAwBL,SAAUpB,EAAO0B,eAAiB,EAAE,EACvE,CAAEtB,QAASuB,EAAwBP,SAAUpB,EAAO0B,eAAiB,GAAIE,MAAO,EAAI,EACpF,CAAExB,QAASyB,EAA0BT,SAAUpB,EAAO8B,iBAAmB,CAAA,EAAIF,MAAO,EAAI,EACxF,CAAExB,QAAS2B,GAAoBX,SAAU,EAAE,EAC3C,CACEhB,QAAS4B,EACTZ,SAAUpB,EAAOiC,aAAe,KAAU,OAAOC,OAAW,KAAeA,OAAOC,aAAeC,SAEnG,CAAEhC,QAASiC,EAAqBjB,SAAUpB,EAAOsC,YAAcC,EAA2BC,WAAW,EACrGC,CAAgB,EAGtB,CAEO,OAAOC,SAAS1C,EAA8B,CAAA,EAAE,CACrD,MAAO,CACLC,SAAUT,EACVU,UAAW,CACTF,EAAOG,QAAU,CACfC,QAASC,EACTC,SAAUC,GAEZ,CAAEH,QAASG,EAAeC,YAAaH,CAAe,EACtDL,EAAOS,2BAA6B,CAClCL,QAASM,EACTJ,SAAUK,GAEZX,EAAOY,UAAY,CAAER,QAASS,EAAmBP,SAAUQ,CAAqB,EAChFd,EAAOe,QAAU,CAAEX,QAASY,EAAiBV,SAAUW,CAAsB,EAC7E,CAAEb,QAASuB,EAAwBP,SAAUpB,EAAO0B,eAAiB,GAAIE,MAAO,EAAI,EACpF,CAAExB,QAASyB,EAA0BT,SAAUpB,EAAO8B,iBAAmB,CAAA,EAAIF,MAAO,EAAI,EACxFa,CAAgB,EAGtB,yCAvDWjD,EAAa,uBAAbA,CAAa,CAAA,2BAHdmD,EACAA,CAAe,CAAA,CAAA,EAErB,IAAOnD,EAAPoD,SAAOpD,CAAa,GAAA,IClD1B,IAAAqD,GAAAC,EAAA,KAAAC,KACAC,IACAC,KACAC,IACAC,IACAC,OCLA,IAAAC,GAAAC,EAAA,KAAAC","names":["LEXICON_FILE_FORMAT_OPTION","LEXICON_TRANSLATE_PORTAL_URL","LEXICON_COMPONENT_NAME","LEXICON_PARTNER_ID","LEXICON_DISABLE_OTW","LEXICON_BASE_TRANSLATION","LEXICON_ROOT_COMPONENT","LEXICON_FILE_FORMAT","init_constants","__esmMin","init_core","InjectionToken","fingerprint","str","textEncoder","utf8","view","hi","hash32","lo","computeMsgId","msg","meaning","msgFingerprint","length","c","a","b","index","end","res","mix","remainder","parseMessage","messageParts","expressions","location","messagePartLocations","expressionLocations","substitutions","substitutionLocations","associatedMessageIds","metadata","parseMetadata","cleanedMessageParts","placeholderNames","messageString","i","messagePart","placeholderName","computePlaceholderName","associatedMessageId","parsePlaceholder","messageId","legacyIds","id","cooked","raw","block","splitBlock","meaningDescAndId","LEGACY_ID_INDICATOR","meaningAndDesc","customId","ID_SEPARATOR","description","MEANING_SEPARATOR","BLOCK_MARKER$1","endOfBlock","findEndOfBlock","cookedIndex","rawIndex","translate$1","translations","message","translation","MissingTranslationError","placeholder","describeMessage","parseTranslation","parts","rawMessageParts","part","makeTemplateObject","meaningString","legacy","l","loadTranslations","translate","key","e","stripBlock","rawMessagePart","BLOCK_MARKER","$localize$1","init_localize","__esmMin","parsedMessage","init_init","__esmMin","init_localize","$localize$1","environment","hostMap","HostService","GetSupportedLanguagesRequest","GetSupportedLanguagesResponse","GetTranslationRequest","GetTranslationResponse","GetTranslationsRequest","GetTranslationsResponse","InvalidateCacheRequest","Language","Statistics","LexiconApiService","init_vendasta_lexicon","__esmMin","init_core","init_http","init_operators","t","ɵɵdefineInjectable","_GetSupportedLanguagesRequest","proto","m","kwargs","toReturn","_GetSupportedLanguagesResponse","_GetTranslationRequest","_GetTranslationResponse","_GetTranslationsRequest","_GetTranslationsResponse","_InvalidateCacheRequest","_Language","_Statistics","http","hostService","HttpHeaders","r","request","map","resp","__spreadProps","__spreadValues","ɵɵinject","HttpClient","convertToFlatJson","convertToNestedJson","init_converters","__esmMin","localizeTranslations","result","Object","entries","forEach","key","value","text","objectPath","parts","split","target","length","part","shift","isObject","deepMerge","init_merge","__esmMin","item","Object","Array","isArray","target","sources","filter","source","forEach","entries","key","value","LexiconLoader","init_lexicon_loader","__esmMin","init_init","init_vendasta_lexicon","init_src","init_esm","init_operators","init_constants","init_converters","init_merge","constructor","componentNames","baseTranslations","disableOtw","targetFileFormat","partnerService","lexiconApiService","parent","_translations","partnerId$","getPartnerId","pipe","debounceTime","startWith","window","partnerId","of","getTranslation","lang","translations$","deepMerge","switchMap","removeDuplicateComponentNames","length","GetTranslationsResponse","translations","getTranslations","languageCode","map","response","combineLatest","child","augmentWithAngularLocalizeTranslations","shareReplay","components","Array","from","Set","p","filter","c","indexOf","$localize","TRANSLATIONS","LEXICON_FILE_FORMAT_OPTION","XLIFF1","FLAT_JSON","flatJson","convertToFlatJson","NESTED_JSON","nestedJson","convertToNestedJson","ɵɵinject","LEXICON_COMPONENT_NAME","LEXICON_BASE_TRANSLATION","LEXICON_DISABLE_OTW","LEXICON_FILE_FORMAT","PartnerServiceInterfaceToken","LexiconApiService","factory","ɵfac","_LexiconLoader","LexiconMissingTranslationHandler","init_lexicon_missing_translation_handler","__esmMin","init_constants","constructor","baseTranslations","handle","params","baseTranslation","Object","prototype","hasOwnProperty","call","key","parts","split","part","interpolateParams","isInterpolateParams","param","value","entries","replace","RegExp","obj","values","every","ɵɵinject","LEXICON_BASE_TRANSLATION","factory","ɵfac","_LexiconMissingTranslationHandler","LexiconModule","init_lexicon_module","__esmMin","init_ngx_translate_core","init_constants","init_lexicon_loader","init_lexicon_missing_translation_handler","forRoot","config","ngModule","providers","loader","provide","TranslateLoader","useClass","LexiconLoader","useExisting","missingTranslationHandler","MissingTranslationHandler","LexiconMissingTranslationHandler","compiler","TranslateCompiler","TranslateFakeCompiler","parser","TranslateParser","TranslateDefaultParser","TranslateStore","USE_STORE","useValue","USE_DEFAULT_LANG","USE_EXTEND","DEFAULT_LANGUAGE","defaultLanguage","LEXICON_ROOT_COMPONENT","componentName","LEXICON_COMPONENT_NAME","multi","LEXICON_BASE_TRANSLATION","baseTranslation","LEXICON_PARTNER_ID","LEXICON_DISABLE_OTW","disableOtw","window","deployment","undefined","LEXICON_FILE_FORMAT","fileFormat","LEXICON_FILE_FORMAT_OPTION","NESTED_JSON","TranslateService","forChild","TranslateModule","_LexiconModule","init_lib","__esmMin","init_lexicon_module","init_lexicon_loader","init_lexicon_missing_translation_handler","init_vendasta_lexicon","init_constants","init_ngx_translate_core","init_src","__esmMin","init_lib"],"x_google_ignoreList":[1,2,3]}