{"version":3,"sources":["jsdelivr-header.js","/npm/geostyler-sld-parser@8.3.0/src/SldStyleParser.ts"],"names":[],"mappings":"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","file":"/npm/geostyler-sld-parser@8.3.0/dist/SldStyleParser.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/geostyler-sld-parser@8.3.0/dist/SldStyleParser.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","import {\n  Channel,\n  ChannelSelection,\n  ColorMap,\n  ColorMapEntry,\n  ColorMapType,\n  CombinationOperator,\n  ComparisonFilter,\n  ComparisonOperator,\n  ContrastEnhancement,\n  Expression,\n  FillSymbolizer,\n  Filter,\n  FunctionCall,\n  GeoStylerFunction,\n  GeoStylerStringFunction,\n  IconSymbolizer,\n  isCombinationFilter,\n  isComparisonFilter,\n  isGeoStylerFunction,\n  isGeoStylerNumberFunction,\n  isNegationFilter,\n  LineSymbolizer,\n  MarkSymbolizer,\n  PointSymbolizer,\n  RangeFilter,\n  RasterSymbolizer,\n  ReadStyleResult,\n  Rule,\n  ScaleDenominator,\n  Style,\n  StyleParser,\n  Symbolizer,\n  TextSymbolizer,\n  UnsupportedProperties,\n  WellKnownName,\n  WriteStyleResult,\n  DistanceUnit\n} from 'geostyler-style';\nimport {\n  X2jOptions,\n  XMLBuilder,\n  XmlBuilderOptions,\n  XMLParser\n} from 'fast-xml-parser';\n\nimport { isNumber, isString, merge } from 'lodash';\n\nimport {\n  Base64ImageObject,\n  geoStylerFunctionToSldFunction,\n  get,\n  getAttribute, getBase64Object,\n  getChildren,\n  getParameterValue,\n  getVendorOptionValue,\n  isSymbolizer,\n  keysByValue,\n  numberExpression\n} from './Util/SldUtil';\n\nconst SLD_VERSIONS = ['1.0.0', '1.1.0'] as const;\n\nexport type SldVersion = (typeof SLD_VERSIONS)[number];\n\n/** GeoServer allows VendorOptions and mix some SLD versions */\nexport const sldEnvGeoServer = 'GeoServer';\nconst SLD_ENVIRONMENTS = [sldEnvGeoServer] as const;\n/** Environment Configuration for the SLD parser/writer. */\nexport type SldEnvironment = (typeof SLD_ENVIRONMENTS)[number];\n\nexport type ParserOptions = Omit<X2jOptions,\n'ignoreDeclaration' |\n'removeNSPrefix' |\n'ignoreAttributes' |\n'preserveOrder' |\n'trimValues'\n>;\n\nexport type BuilderOptions = Omit<XmlBuilderOptions,\n'cdataPropName' |\n'ignoreAttributes' |\n'suppressEmptyNode' |\n'preserveOrder'\n>;\n\nexport type ConstructorParams = {\n  numericFilterFields?: string[];\n  boolFilterFields?: string[];\n  /* optional for reading style (it will be guessed from sld style) and mandatory for writing */\n  sldVersion?: SldVersion;\n  sldEnvironment?: SldEnvironment;\n  symbolizerUnits?: string;\n  parserOptions?: ParserOptions;\n  builderOptions?: XmlBuilderOptions;\n  translations?: SldStyleParserTranslations;\n  locale?: string;\n};\n\nconst WELLKNOWNNAME_TTF_REGEXP = /^ttf:\\/\\/(.+)#(.+)$/;\n\nconst COMPARISON_MAP = {\n  PropertyIsEqualTo: '==',\n  PropertyIsNotEqualTo: '!=',\n  PropertyIsLike: '*=',\n  PropertyIsLessThan: '<',\n  PropertyIsLessThanOrEqualTo: '<=',\n  PropertyIsGreaterThan: '>',\n  PropertyIsGreaterThanOrEqualTo: '>=',\n  PropertyIsNull: '==',\n  PropertyIsBetween: '<=x<='\n};\n\ntype ComparisonType = keyof typeof COMPARISON_MAP;\n\nconst NEGATION_OPERATOR_MAP = {\n  Not: '!'\n};\n\nconst COMBINATION_MAP = {\n  And: '&&',\n  Or: '||',\n  PropertyIsBetween: '&&'\n};\n\ntype CombinationType = keyof typeof COMBINATION_MAP;\n\nconst unitSldMetre: string = 'http://www.opengeospatial.org/se/units/metre';\nconst unitSldPixel: string = 'http://www.opengeospatial.org/se/units/pixel';\n\nconst ARITHMETIC_OPERATORS = [\n  'add',\n  'sub',\n  'mul',\n  'div',\n] as const;\n\ntype ArithmeticType = typeof ARITHMETIC_OPERATORS[number];\n\nexport type SldStyleParserTranslationKeys = {\n  marksymbolizerParseFailedUnknownWellknownName?: (params: {wellKnownName: string}) => string;\n  noFilterDetected?: string;\n  symbolizerKindParseFailed?: (params: {sldSymbolizerName: string}) => string;\n  colorMapEntriesParseFailedColorUndefined?: string;\n  contrastEnhancParseFailedHistoAndNormalizeMutuallyExclusive?: string;\n  channelSelectionParseFailedRGBAndGrayscaleMutuallyExclusive?: string;\n  channelSelectionParseFailedRGBChannelsUndefined?: string;\n};\n\nexport type SldStyleParserTranslations = Record<string, SldStyleParserTranslationKeys>;\n\nexport const defaultTranslations: SldStyleParserTranslations = {\n  en: {\n    marksymbolizerParseFailedUnknownWellknownName: ({wellKnownName}) =>\n      `MarkSymbolizer cannot be parsed. WellKnownName ${wellKnownName} is not supported.`,\n    noFilterDetected: 'No Filter detected.',\n    symbolizerKindParseFailed: ({sldSymbolizerName}) =>\n      `Failed to parse SymbolizerKind ${sldSymbolizerName} from SldRule.`,\n    colorMapEntriesParseFailedColorUndefined: 'Cannot parse ColorMapEntries. color is undefined.',\n    contrastEnhancParseFailedHistoAndNormalizeMutuallyExclusive:\n      'Cannot parse ContrastEnhancement. Histogram and Normalize are mutually exclusive.',\n    channelSelectionParseFailedRGBAndGrayscaleMutuallyExclusive:\n      'Cannot parse ChannelSelection. RGB and Grayscale are mutually exclusive.',\n    channelSelectionParseFailedRGBChannelsUndefined:\n      'Cannot parse ChannelSelection. Red, Green and Blue channels must be defined.'\n  },\n  de: {},\n  fr: {\n    marksymbolizerParseFailedUnknownWellknownName: ({wellKnownName}) =>\n      `Échec de lecture du symbole de type MarkSymbolizer. Le WellKnownName ${wellKnownName} n'est pas supporté.`,\n    noFilterDetected: 'Aucun filtre détecté.',\n    symbolizerKindParseFailed: ({sldSymbolizerName}) =>\n      `Échec de lecture du type de symbole ${sldSymbolizerName} à partir de SldRule.`,\n    colorMapEntriesParseFailedColorUndefined: 'Lecture de ColorMapEntries échoué. color n\\'est pas défini.',\n    contrastEnhancParseFailedHistoAndNormalizeMutuallyExclusive:\n      'Échec de lecture des propriétés de contraste ContrastEnhancement échoué. '\n      +'Histogram et Normalize sont mutuellement exclusifs.',\n    channelSelectionParseFailedRGBAndGrayscaleMutuallyExclusive:\n      'Échec de lecture de la sélection de canaux ChannelSelection. '\n      +'RGB et Grayscale sont mutuellement exclusifs.',\n    channelSelectionParseFailedRGBChannelsUndefined:\n      'Échec de lecture de la sélection de canaux ChannelSelection. '\n      +'Les canaux Rouge, Vert et Bleu doivent être définis.',\n\n  },\n} as const;\n\n/**\n * @returns true if the provided value is null or undefined. Returns false otherwise.\n */\nconst isNil = (val: unknown): boolean => val === undefined || val === null;\n\n/**\n * This parser can be used with the GeoStyler.\n * It implements the geostyler-style StyleParser interface.\n *\n * @class SldStyleParser\n * @implements StyleParser\n */\nexport class SldStyleParser implements StyleParser<string> {\n\n  /**\n   * The name of the SLD Style Parser.\n   */\n  public static title = 'SLD Style Parser';\n\n  title = 'SLD Style Parser';\n\n  unsupportedProperties: UnsupportedProperties = {\n    Symbolizer: {\n      MarkSymbolizer: {\n        avoidEdges: 'none',\n        blur: 'none',\n        offset: {\n          support: 'partial',\n          info: 'Only supported for SLD Version 1.1.0'\n        },\n        offsetAnchor: 'none',\n        pitchAlignment: 'none',\n        pitchScale: 'none',\n        visibility: 'none'\n      },\n      FillSymbolizer: {\n        antialias: 'none',\n        opacity: {\n          support: 'none',\n          info: 'General opacity is not supported. Use fillOpacity and strokeOpacity instead.'\n        },\n        visibility: 'none'\n      },\n      IconSymbolizer: {\n        allowOverlap: 'none',\n        anchor: 'none',\n        avoidEdges: 'none',\n        color: 'none',\n        haloBlur: 'none',\n        haloColor: 'none',\n        haloOpacity: 'none',\n        haloWidth: 'none',\n        keepUpright: 'none',\n        offset: {\n          support: 'partial',\n          info: 'Only supported for SLD Version 1.1.0'\n        },\n        offsetAnchor: 'none',\n        optional: 'none',\n        padding: 'none',\n        pitchAlignment: 'none',\n        rotationAlignment: 'none',\n        textFit: 'none',\n        image: {\n          support: 'partial',\n          info: 'Sprites are not supported'\n        },\n        textFitPadding: 'none',\n        visibility: 'none'\n      },\n      LineSymbolizer: {\n        blur: 'none',\n        gapWidth: 'none',\n        gradient: 'none',\n        miterLimit: 'none',\n        roundLimit: 'none',\n        spacing: 'none',\n        visibility: 'none'\n      },\n      RasterSymbolizer: {\n        brightnessMax: 'none',\n        brightnessMin: 'none',\n        contrast: 'none',\n        fadeDuration: 'none',\n        hueRotate: 'none',\n        resampling: 'none',\n        saturation: 'none',\n        visibility: 'none'\n      },\n      TextSymbolizer: {\n        placement: {\n          support: 'partial',\n          info: 'Only \"line\" and \"point\" are currently supported'\n        }\n      }\n    }\n  };\n\n  translations: SldStyleParserTranslations = defaultTranslations;\n\n  locale: string = 'en';\n\n  constructor(opts?: ConstructorParams) {\n    this.parser = new XMLParser({\n      ...opts?.parserOptions,\n      // Fixed attributes\n      ignoreDeclaration: true,\n      removeNSPrefix: true,\n      ignoreAttributes: false,\n      preserveOrder: true,\n      trimValues: true\n    });\n\n    this.builder = new XMLBuilder({\n      ...opts?.builderOptions,\n      // Fixed attributes\n      cdataPropName: '#cdata',\n      ignoreAttributes: false,\n      suppressEmptyNode: true,\n      preserveOrder: true\n    });\n\n    if (opts?.sldVersion) {\n      this.sldVersion = opts?.sldVersion;\n    }\n\n    if (opts?.sldEnvironment !== undefined) {\n      this.sldEnvironment = opts.sldEnvironment;\n    }\n\n    if (opts?.locale) {\n      this.locale = opts.locale;\n    }\n\n    if (opts?.translations){\n      this.translations = merge(this.translations, opts.translations);\n    }\n\n    Object.assign(this, opts);\n  }\n\n  translate(key: keyof SldStyleParserTranslationKeys, params?: any): string {\n    const trans = this.translations?.[this.locale]?.[key] ?? key;\n\n    if (typeof trans === 'function') {\n      return trans(params);\n    }\n\n    return trans;\n  }\n\n  private _parser: XMLParser;\n  get parser(): XMLParser {\n    return this._parser;\n  }\n  set parser(parser: XMLParser) {\n    this._parser = parser;\n  }\n\n  private _builder: XMLBuilder;\n  get builder(): XMLBuilder {\n    return this._builder;\n  }\n  set builder(builder: XMLBuilder) {\n    this._builder = builder;\n  }\n\n  /**\n   * Array of field / property names in a filter, which are casted to numerics\n   * while parsing a SLD.\n   */\n  private _numericFilterFields: string[] = [];\n  /**\n   * Getter for _numericFilterFields\n   * @return The numericFilterFields\n   */\n  get numericFilterFields(): string[] {\n    return this._numericFilterFields;\n  }\n  /**\n   * Setter for _numericFilterFields\n   * @param numericFilterFields The numericFilterFields to set\n   */\n  set numericFilterFields(numericFilterFields: string[]) {\n    this._numericFilterFields = numericFilterFields;\n  }\n\n  /**\n   * Array of field / property names in a filter, which are casted to boolean\n   * while parsing a SLD.\n   */\n  private _boolFilterFields: string[] = [];\n  /**\n   * Getter for _boolFilterFields\n   * @return The boolFilterFields\n   */\n  get boolFilterFields(): string[] {\n    return this._boolFilterFields;\n  }\n  /**\n   * Setter for _boolFilterFields\n   * @param boolFilterFields The boolFilterFields to set\n   */\n  set boolFilterFields(boolFilterFields: string[]) {\n    this._boolFilterFields = boolFilterFields;\n  }\n\n  /**\n   * String indicating the SLD version to use. 1.1.0 will make use of\n   * Symbology Encoding.\n   */\n  private _sldVersion: SldVersion = '1.0.0';\n\n  /**\n   * Getter for _sldVersion\n   * @return\n   */\n  get sldVersion(): SldVersion {\n    return this._sldVersion;\n  }\n\n  /**\n   * Setter for _sldVersion\n   * @param sldVersion The _sldVersion value to set\n   */\n  set sldVersion(sldVersion: SldVersion) {\n    this._sldVersion = sldVersion;\n  }\n\n  /**\n   * Indicate the sld environment to parse the SLD or write the SLD.\n   * This allows or restrict some SLD tags.\n   * @private\n   */\n  private _sldEnvironment: SldEnvironment | null = null;\n\n  /**\n   * Getter for _sldEnvironment\n   * @return SldEnvironment or null.\n   */\n  get sldEnvironment(): SldEnvironment | null {\n    return this._sldEnvironment;\n  }\n\n  /**\n   * Setter for _sldEnvironment\n   * @param a SldEnvironment or null.\n   */\n  set sldEnvironment(env: SldEnvironment | null) {\n    this._sldEnvironment = env;\n  }\n\n  /**\n   * Check if the given SldEnvironment match the current environment.\n   * @param env the SldEnvironment to check.\n   * @private\n   */\n  private isSldEnv(env: SldEnvironment): boolean {\n    return this.sldEnvironment === env;\n  }\n\n  /**\n   * String indicating the SLD version used in reading mode\n   */\n  private _readingSldVersion: SldVersion = '1.0.0';\n\n  /**\n   * Getter for _readingSldVersion\n   * @return\n   */\n  get readingSldVersion(): SldVersion {\n    return this._readingSldVersion;\n  }\n\n  /**\n   * Setter for _readingSldVersion\n   * @param sldVersion The _readingSldVersion value to set\n   */\n  set readingSldVersion(sldVersion: SldVersion) {\n    this._readingSldVersion = sldVersion;\n  }\n\n  /**\n   * Used to add a `uom` attribute to the symbolizer tag. Can be one of\n   * `metre`, `foot` or `pixel`. Defaults to pixel.\n   */\n  private _symbolizerUnits: string = 'pixel';\n\n  /**\n   * Getter for _symbolizerUnits\n   * @return {string}\n   */\n  get symbolizerUnits(): string {\n    return this._symbolizerUnits;\n  }\n\n  /**\n   * Setter for _symbolizerUnits\n   * @param {string} symbolizerUnits The _symbolizerUnits value to set\n   */\n  set symbolizerUnits(symbolizerUnits: string) {\n    this._symbolizerUnits = symbolizerUnits;\n  }\n\n  /**\n   * The readStyle implementation of the geostyler-style StyleParser interface.\n   * It reads a SLD as a string and returns a Promise.\n   * The Promise itself resolves with an object containing the geostyler-style.\n   *\n   * @param sldString A SLD as a string.\n   * @return The Promise resolving with an object containing the geostyler-style.\n   */\n  readStyle(sldString: string): Promise<ReadStyleResult> {\n    return new Promise<ReadStyleResult>((resolve) => {\n      try {\n        const sldObject = this.parser.parse(sldString);\n\n        const version = getAttribute(sldObject[0], 'version');\n        if (!SLD_VERSIONS.includes(version)) {\n          throw new Error(`SLD version must be ${SLD_VERSIONS.toString()}`);\n        }\n        this._readingSldVersion = version;\n\n        const geoStylerStyle: Style = this.sldObjectToGeoStylerStyle(sldObject);\n        resolve({\n          output: geoStylerStyle\n        });\n      } catch (error) {\n        resolve({\n          errors: [error]\n        });\n      }\n    });\n  }\n\n  /**\n   * Get the geostyler-style from a SLD Object (created with fast-xml-parser).\n   *\n   * @param sldObject The SLD object representation (created with fast-xml-parser)\n   * @return The geostyler-style\n   */\n  sldObjectToGeoStylerStyle(sldObject: any): Style {\n    const rules = this.getRulesFromSldObject(sldObject);\n    const name = this.getStyleNameFromSldObject(sldObject);\n    return {\n      name,\n      rules\n    };\n  }\n\n  /**\n   * Get the geostyler-style rules from a SLD Object (created with fast-xml-parser).\n   *\n   * @param sldObject The SLD object representation (created with fast-xml-parser)\n   * @return The geostyler-style rules\n   */\n  getRulesFromSldObject(sldObject: any): Rule[] {\n    const layers = getChildren(sldObject[0].StyledLayerDescriptor, 'NamedLayer');\n    const rules: Rule[] = [];\n    layers.forEach(({ NamedLayer: layer }: any) => {\n      getChildren(layer, 'UserStyle').forEach(({ UserStyle: userStyle }: any) => {\n        getChildren(userStyle, 'FeatureTypeStyle').forEach(({ FeatureTypeStyle: featureTypeStyle }: any) => {\n          getChildren(featureTypeStyle, 'Rule').forEach(({ Rule: sldRule }: any) => {\n            const filter: Filter | undefined = this.getFilterFromRule(sldRule);\n            const scaleDenominator: ScaleDenominator | undefined = this.getScaleDenominatorFromRule(sldRule);\n            const symbolizers: Symbolizer[] = this.getSymbolizersFromRule(sldRule);\n            const ruleTitle = get(sldRule, 'Title.#text');\n            const ruleName = get(sldRule, 'Name.#text');\n            const name = ruleTitle !== undefined\n              ? ruleTitle\n              : (ruleName !== undefined ? ruleName : '');\n            const rule: Rule = <Rule>{\n              name\n            };\n            if (filter) {\n              rule.filter = filter;\n            }\n            if (scaleDenominator) {\n              rule.scaleDenominator = scaleDenominator;\n            }\n            if (symbolizers) {\n              rule.symbolizers = symbolizers;\n            }\n            rules.push(rule);\n          });\n        });\n      });\n    });\n    return rules;\n  }\n\n  /**\n   * Get the name for the Style from the SLD Object. Returns the Title of the UserStyle\n   * if defined or the Name of the NamedLayer if defined or an empty string.\n   *\n   * @param sldObject The SLD object representation (created with fast-xml-parser)\n   * @return The name to be used for the GeoStyler Style Style\n   */\n  getStyleNameFromSldObject(sldObject: any): string {\n    const userStyleTitle = get(sldObject, 'StyledLayerDescriptor.NamedLayer[0].UserStyle.Name.#text');\n    const namedLayerName = get(sldObject, 'StyledLayerDescriptor.NamedLayer.Name.#text');\n    return userStyleTitle ? userStyleTitle\n      : namedLayerName ? namedLayerName : '';\n  }\n\n  /**\n   * Get the geostyler-style Filter from a SLD Rule.\n   *\n   * Currently only supports one Filter per Rule.\n   *\n   * @param sldRule The SLD Rule\n   * @return The geostyler-style Filter\n   */\n  getFilterFromRule(sldRule: any[]): Filter | undefined {\n    const sldFilter = get(sldRule, 'Filter');\n    if (!sldFilter || sldFilter.length === 0) {\n      return;\n    }\n    const operator = Object.keys(sldFilter[0])?.[0];\n    if (!operator) {\n      return;\n    }\n    const filter = this.getFilterFromOperatorAndComparison(operator as ComparisonType, sldFilter);\n    return filter;\n  }\n\n  /**\n   * Get the geostyler-style ScaleDenominator from a SLD Rule.\n   *\n   * @param sldRule The SLD Rule\n   * @return The geostyler-style ScaleDenominator\n   */\n  getScaleDenominatorFromRule(sldRule: any[]): ScaleDenominator | undefined {\n    const scaleDenominator: ScaleDenominator = <ScaleDenominator>{};\n    const min = get(sldRule, 'MinScaleDenominator.#text');\n    if (min) {\n      scaleDenominator.min = Number(min);\n    }\n    const max = get(sldRule, 'MaxScaleDenominator.#text');\n    if (max) {\n      scaleDenominator.max = Number(max);\n    }\n\n    return (Number.isFinite(scaleDenominator.min) || Number.isFinite(scaleDenominator.max))\n      ? scaleDenominator\n      : undefined;\n  }\n\n  /**\n   * Get the geostyler-style Symbolizers from a SLD Rule.\n   *\n   * @param sldRule The SLD Rule\n   * @return The geostyler-style Symbolizer array\n   */\n  getSymbolizersFromRule(sldRule: any[]): Symbolizer[] {\n    const symbolizers: Symbolizer[] = sldRule\n      .filter(isSymbolizer)\n      .map((sldSymbolizer: any) => {\n        const sldSymbolizerName: string = Object.keys(sldSymbolizer)[0];\n        switch (sldSymbolizerName) {\n          case 'PointSymbolizer':\n            return this.getPointSymbolizerFromSldSymbolizer(sldSymbolizer);\n          case 'LineSymbolizer':\n            return this.getLineSymbolizerFromSldSymbolizer(sldSymbolizer);\n          case 'TextSymbolizer':\n            return this.getTextSymbolizerFromSldSymbolizer(sldSymbolizer);\n          case 'PolygonSymbolizer':\n            return this.getFillSymbolizerFromSldSymbolizer(sldSymbolizer);\n          case 'RasterSymbolizer':\n            return this.getRasterSymbolizerFromSldSymbolizer(sldSymbolizer);\n          default:\n            throw new Error(this.translate('symbolizerKindParseFailed', { sldSymbolizerName: sldSymbolizerName }));\n        }\n      });\n\n    return symbolizers;\n  }\n\n  /**\n   * Creates a geostyler-style Filter from a given operator name and the js\n   * SLD object representation (created with fast-xml-parser) of the SLD Filter.\n   *\n   * @param sldOperatorName The Name of the SLD Filter Operator\n   * @param sldFilter The SLD Filter\n   * @return The geostyler-style Filter\n   */\n  getFilterFromOperatorAndComparison(\n    sldOperatorName: ComparisonType | 'Function',\n    sldFilter: any\n  ): Filter {\n    let filter: Filter;\n\n    if (sldOperatorName === 'Function') {\n      const functionName = Array.isArray(sldFilter) ? sldFilter[0][':@']['@_name'] : sldFilter[':@']['@_name'];\n      const tempFunctionName = functionName.charAt(0).toUpperCase() + functionName.slice(1);\n      sldOperatorName = `PropertyIs${tempFunctionName}` as ComparisonType;\n    }\n\n    // we have to first check for PropertyIsBetween,\n    // since it is also a comparisonOperator. But it\n    // needs to be treated differently.\n    if (sldOperatorName === 'PropertyIsBetween') {\n      // TODO: PropertyIsBetween spec allows more than just a PropertyName as its first argument.\n      const propertyName = get(sldFilter, 'PropertyIsBetween.PropertyName.#text');\n      const lower = Number(get(sldFilter, 'PropertyIsBetween.LowerBoundary.Literal.#text'));\n      const upper = Number(get(sldFilter, 'PropertyIsBetween.UpperBoundary.Literal.#text'));\n\n      filter = ['<=x<=', propertyName, lower, upper];\n    } else if (Object.keys(COMPARISON_MAP).includes(sldOperatorName)) {\n\n      filter = this.getFilterFromComparisonOperator(sldOperatorName, sldFilter);\n\n    } else if (Object.keys(COMBINATION_MAP).includes(sldOperatorName)) {\n      const combinationOperator: CombinationOperator = COMBINATION_MAP[\n        sldOperatorName as CombinationType] as CombinationOperator;\n      const filters: Filter[] = get(sldFilter, sldOperatorName)?.map((op: any) => {\n        const operatorName = Object.keys(op)?.[0];\n        return this.getFilterFromOperatorAndComparison(operatorName as any, op);\n      });\n      filter = [\n        combinationOperator,\n        ...filters\n      ];\n    } else if (Object.keys(NEGATION_OPERATOR_MAP).includes(sldOperatorName)) {\n      const negationOperator = NEGATION_OPERATOR_MAP[sldOperatorName as 'Not'];\n      const negatedOperator = Object.keys(sldFilter[sldOperatorName][0])[0];\n      const negatedComparison = sldFilter[sldOperatorName][0];\n      const negatedFilter: Filter = this.getFilterFromOperatorAndComparison(\n        negatedOperator as any,\n        negatedComparison\n      );\n      filter = [\n        negationOperator as any,\n        negatedFilter\n      ];\n    } else {\n      throw new Error(this.translate('noFilterDetected'));\n    }\n    return filter;\n  }\n\n  getFilterFromComparisonOperator(\n    sldOperatorName: ComparisonType | 'Function',\n    sldFilter: any\n  ): Filter {\n    if (sldOperatorName === 'Function') {\n      const functionName = Array.isArray(sldFilter) ? sldFilter[0][':@']['@_name'] : sldFilter[':@']['@_name'];\n      const tempFunctionName = functionName.charAt(0).toUpperCase() + functionName.slice(1);\n      sldOperatorName = `PropertyIs${tempFunctionName}` as ComparisonType;\n    }\n\n    const comparisonOperator: ComparisonOperator = COMPARISON_MAP[sldOperatorName] as ComparisonOperator;\n    const filterIsFunction = !!get(sldFilter, 'Function');\n    let args: (FunctionCall<unknown>|null)[] = [];\n\n    const children = get(sldFilter, filterIsFunction ? 'Function' : sldOperatorName) || [];\n    args = children.map((child: any, index: number) => {\n      const operatorName = Object.keys(child)?.[0];\n\n      if (ARITHMETIC_OPERATORS.includes(operatorName.toLowerCase() as ArithmeticType)) {\n        const arithmeticOperator = child[operatorName];\n        return this.getFilterArgsFromArithmeticOperators(operatorName as ArithmeticType, arithmeticOperator);\n      }\n\n      return this.getFilterArgsFromPropertyName(child, children, index);\n    });\n\n    if (sldOperatorName === 'PropertyIsNull') {\n      args[1] = null;\n    }\n\n    return [\n      comparisonOperator,\n      ...args\n    ] as ComparisonFilter;\n  }\n\n  /**\n   * Creates a FunctionCall from arithmetic operators in SLD filters.\n   * Handles nested arithmetic operations recursively.\n   */\n  getFilterArgsFromArithmeticOperators(\n    arithmeticOperatorName: ArithmeticType,\n    arithmeticOperator: any\n  ): FunctionCall<number> {\n    const [leftSide, rightSide] = arithmeticOperator;\n    return {\n      name: arithmeticOperatorName.toLowerCase() as FunctionCall<number>['name'],\n      args: [\n        this.processArithmeticOperand(leftSide, arithmeticOperator),\n        this.processArithmeticOperand(rightSide, arithmeticOperator)\n      ]\n    };\n  }\n\n  /**\n   * Processes a single operand in an arithmetic operation.\n   * If the operand is itself an arithmetic operator, processes it recursively.\n   */\n  private processArithmeticOperand(operand: any, parentOperator: any): any {\n    const operatorName = Object.keys(operand)?.[0];\n\n    if (operatorName && ARITHMETIC_OPERATORS.includes(operatorName.toLowerCase() as ArithmeticType)) {\n      return this.getFilterArgsFromArithmeticOperators(operatorName as ArithmeticType, operand[operatorName]);\n    }\n\n    return this.getFilterArgsFromPropertyName(operand, parentOperator, 0);\n  }\n\n  getFilterArgsFromPropertyName(\n    child: any,\n    children?: any,\n    index?: number\n  ): FunctionCall<unknown> {\n    const propName = get([child], 'PropertyName.#text');\n    if (propName !== undefined) {\n      const isSingleArgOperator = children.length === 1;\n      // Return property name for the first argument in case second argument is literal\n      // or isSingleArgOperator eg (PropertyIsNull)\n      if (isSingleArgOperator || (index === 0 && get([children[1]], 'PropertyName.#text') === undefined)) {\n        return propName;\n      }\n      // ..otherwise + (second argument) return as property function\n      return {\n        name: 'property',\n        args: [propName]\n      };\n    } else {\n      return get([child], '#text');\n    }\n  }\n\n  /**\n   * Get the geostyler-style PointSymbolizer from a SLD Symbolizer.\n   *\n   * The opacity of the Symbolizer is taken from the <Graphic>.\n   *\n   * @param sldSymbolizer The SLD Symbolizer\n   * @return The geostyler-style PointSymbolizer\n   */\n  getPointSymbolizerFromSldSymbolizer(\n    sldSymbolizer: any,\n    distanceUnit: DistanceUnit | undefined = undefined\n  ): PointSymbolizer {\n    const sldPointSymbolizer = sldSymbolizer.PointSymbolizer;\n    let pointSymbolizer: PointSymbolizer;\n    const wellKnownName: string = get(sldPointSymbolizer, 'Graphic.Mark.WellKnownName.#text');\n    const externalGraphic: any = get(sldPointSymbolizer, 'Graphic.ExternalGraphic');\n    if (externalGraphic) {\n      pointSymbolizer = this.getIconSymbolizerFromSldSymbolizer(sldSymbolizer);\n    } else {\n      // geoserver does not set a wellKnownName for square explicitly since it is the default value.\n      // Therefore, we have to set the wellKnownName to square if no wellKownName is given.\n      if (!wellKnownName) {\n        // TODO: Fix this. Idealy without lodash\n        // _set(sldSymbolizer, 'Graphic[0].Mark[0].WellKnownName[0]._', 'square');\n      }\n      pointSymbolizer = this.getMarkSymbolizerFromSldSymbolizer(sldSymbolizer);\n    }\n    return pointSymbolizer;\n  }\n\n  /**\n   * Get the geostyler-style LineSymbolizer from a SLD Symbolizer.\n   *\n   * Currently only the CssParameters are available.\n   *\n   * @param sldSymbolizer The SLD Symbolizer\n   * @return The geostyler-style LineSymbolizer\n   */\n  getLineSymbolizerFromSldSymbolizer(sldSymbolizer: any): LineSymbolizer {\n    const sldLineSymbolizer = sldSymbolizer.LineSymbolizer;\n    const distanceUnit: DistanceUnit | undefined = this.getDistanceUnit(sldSymbolizer);\n    const lineSymbolizer: LineSymbolizer = {\n      kind: 'Line'\n    };\n    const strokeEl = get(sldLineSymbolizer, 'Stroke', this.readingSldVersion);\n    const color = getParameterValue(strokeEl, 'stroke', this.readingSldVersion);\n    const width = getParameterValue(strokeEl, 'stroke-width', this.readingSldVersion);\n    const opacity = getParameterValue(strokeEl, 'stroke-opacity', this.readingSldVersion);\n    const lineJoin = getParameterValue(strokeEl, 'stroke-linejoin', this.readingSldVersion);\n    const lineCap = getParameterValue(strokeEl, 'stroke-linecap', this.readingSldVersion);\n    const dashArray = getParameterValue(strokeEl, 'stroke-dasharray', this.readingSldVersion);\n    const dashOffset = getParameterValue(strokeEl, 'stroke-dashoffset', this.readingSldVersion);\n\n    if (!isNil(color)) {\n      lineSymbolizer.color = color;\n    }\n    if (!isNil(width)) {\n      lineSymbolizer.width = numberExpression(width);\n    }\n    if (!isNil(distanceUnit)) {\n      lineSymbolizer.widthUnit = distanceUnit;\n    }\n    if (!isNil(opacity)) {\n      lineSymbolizer.opacity = numberExpression(opacity);\n    }\n    if (!isNil(lineJoin)) {\n      // geostyler-style and ol use 'miter' whereas sld uses 'mitre'\n      if (lineJoin === 'mitre') {\n        lineSymbolizer.join = 'miter';\n      } else {\n        lineSymbolizer.join = lineJoin as 'bevel' | 'miter' | 'round' | undefined;\n      }\n    }\n    if (!isNil(lineCap)) {\n      lineSymbolizer.cap = lineCap as 'round' | 'butt' | 'square' | undefined;\n    }\n\n    if (!isNil(dashArray)) {\n      const dashStringAsArray = dashArray.split(' ').map(numberExpression);\n      lineSymbolizer.dasharray = dashStringAsArray;\n    }\n    if (!isNil(dashOffset)) {\n      lineSymbolizer.dashOffset = numberExpression(dashOffset);\n    }\n\n    const graphicStroke = get(strokeEl, 'GraphicStroke');\n    if (!isNil(graphicStroke)) {\n      lineSymbolizer.graphicStroke = this.getPointSymbolizerFromSldSymbolizer(\n        {\n          PointSymbolizer: graphicStroke\n        }, distanceUnit);\n    }\n\n    const graphicFill = get(strokeEl, 'GraphicFill');\n    if (!isNil(graphicFill)) {\n      lineSymbolizer.graphicFill = this.getPointSymbolizerFromSldSymbolizer(\n        {\n          PointSymbolizer: graphicFill\n        }, distanceUnit);\n    }\n\n    const perpendicularOffset = get(sldLineSymbolizer, 'PerpendicularOffset.#text');\n    if (!isNil(perpendicularOffset)) {\n      lineSymbolizer.perpendicularOffset = numberExpression(perpendicularOffset);\n    }\n\n    return lineSymbolizer;\n  }\n\n  /**\n   * Get the geostyler-style TextSymbolizer from a SLD Symbolizer.\n   *\n   * @param sldSymbolizer The SLD Symbolizer\n   * @return The geostyler-style TextSymbolizer\n   */\n  getTextSymbolizerFromSldSymbolizer(sldSymbolizer: any): TextSymbolizer {\n    const sldTextSymbolizer = sldSymbolizer.TextSymbolizer;\n    const distanceUnit: DistanceUnit | undefined = this.getDistanceUnit(sldSymbolizer);\n    const textSymbolizer: TextSymbolizer = {\n      kind: 'Text'\n    };\n    const fontEl = get(sldTextSymbolizer, 'Font');\n    const fillEl = get(sldTextSymbolizer, 'Fill');\n    const labelEl = get(sldTextSymbolizer, 'Label');\n    const haloEl = get(sldTextSymbolizer, 'Halo');\n    const haloFillEl = get(haloEl, 'Fill');\n\n    const color = getParameterValue(fillEl, 'fill', this.readingSldVersion);\n    const opacity = getParameterValue(fillEl, 'fill-opacity', this.readingSldVersion);\n\n    const fontFamily = getParameterValue(fontEl, 'font-family', this.readingSldVersion);\n    const fontStyle = getParameterValue(fontEl, 'font-style', this.readingSldVersion);\n    const fontSize = getParameterValue(fontEl, 'font-size', this.readingSldVersion);\n    const fontWeight = getParameterValue(fontEl, 'font-weight', this.readingSldVersion);\n\n    const haloColor = getParameterValue(haloFillEl, 'fill', this.readingSldVersion);\n\n    if (!isNil(labelEl)) {\n      textSymbolizer.label = this.getTextSymbolizerLabelFromSldSymbolizer(labelEl);\n    }\n\n    textSymbolizer.color = color ? color : '#000000';\n\n    if (!isNil(opacity)) {\n      textSymbolizer.opacity = numberExpression(opacity);\n    }\n\n    const haloRadius = get(sldTextSymbolizer, 'Halo.Radius.#text');\n    if (!isNil(haloRadius)) {\n      textSymbolizer.haloWidth = numberExpression(haloRadius);\n    }\n    if (!isNil(distanceUnit)) {\n      textSymbolizer.haloWidthUnit = distanceUnit;\n    }\n    const haloOpacity = getParameterValue(haloFillEl, 'fill-opacity', this.readingSldVersion);\n    if (!isNil(haloOpacity)) {\n      textSymbolizer.haloOpacity = numberExpression(haloOpacity);\n    }\n    if (!isNil(haloColor)) {\n      textSymbolizer.haloColor = haloColor;\n    }\n    const placement = get(sldTextSymbolizer, 'LabelPlacement');\n    if (!isNil(placement)) {\n      const pointPlacement = get(placement, 'PointPlacement');\n      const linePlacement = get(placement, 'LinePlacement');\n      if (!isNil(pointPlacement)) {\n        textSymbolizer.placement = 'point';\n        const anchorPoint = get(pointPlacement, 'AnchorPoint');\n        if (!isNil(anchorPoint)) {\n          const anchorX = get(anchorPoint, 'AnchorPointX.#text');\n          const anchorY = get(anchorPoint, 'AnchorPointY.#text');\n          textSymbolizer.anchor = this.getAnchorFromSldAnchorPoint(anchorX, anchorY);\n        }\n        const displacement = get(pointPlacement, 'Displacement');\n        if (!isNil(displacement)) {\n          const x = get(displacement, 'DisplacementX.#text');\n          const y = get(displacement, 'DisplacementY.#text');\n          textSymbolizer.offset = [\n            Number.isFinite(x) ? numberExpression(x) : 0,\n            Number.isFinite(y) ? -numberExpression(y) : 0,\n          ];\n        }\n        const rotation = get(pointPlacement, 'Rotation.#text');\n        if (!isNil(rotation)) {\n          textSymbolizer.rotate = numberExpression(rotation);\n        }\n      } else if (!isNil(linePlacement)) {\n        textSymbolizer.placement = 'line';\n        if (this.readingSldVersion === '1.1.0') {\n          // According to SLD 1.1 specification, isRepeated does not\n          // support expressions, whereas Gap does.\n          const isRepeated: boolean = get(linePlacement, 'IsRepeated.#text');\n          // Only set gap when isRepeated is true\n          const gap = get(linePlacement, 'Gap.#text');\n          if (isRepeated && !isNil(gap)) {\n            textSymbolizer.repeat = numberExpression(gap);\n          }\n        }\n      }\n    }\n    if (!isNil(fontFamily)) {\n      textSymbolizer.font = [fontFamily];\n    }\n    if (!isNil(fontStyle)) {\n      textSymbolizer.fontStyle = fontStyle.toLowerCase() as 'normal' | 'italic' | 'oblique' | undefined;\n    }\n    if (!isNil(fontWeight)) {\n      textSymbolizer.fontWeight = fontWeight.toLowerCase() as 'normal' | 'bold' | undefined;\n    }\n    if (!isNil(fontSize)) {\n      textSymbolizer.size = numberExpression(fontSize);\n    }\n    if (!isNil(distanceUnit)) {\n      textSymbolizer.sizeUnit = distanceUnit;\n    }\n    return textSymbolizer;\n  }\n\n  /**\n   * Create a template string from a TextSymbolizer Label element.\n   * The ordering of the elemments inside the Label element is preserved.\n   *\n   * Examples:\n   * <Label>\n   *  <Literal>foo</Literal>\n   *  <PropertyName>bar</PropertyName>\n   * </Label>\n   * --> \"foo{{bar}}\"\n   *\n   * <Label>\n   *  <PropertyName>bar</PropertyName>\n   *  <Literal>foo</Literal>\n   * </Label>\n   * --> \"{{bar}}foo\"\n   *\n   * <Label>\n   *  <PropertyName>bar</PropertyName>\n   *  <Literal>foo</Literal>\n   *  <PropertyName>john</PropertyName>\n   * </Label>\n   * --> \"{{bar}}foo{{john}}\"\n   *\n   * <Label>\n   *  <PropertyName>bar</PropertyName>\n   *  <PropertyName>john</PropertyName>\n   *  <Literal>foo</Literal>\n   * </Label>\n   * --> \"{{bar}}{{john}}foo\"\n   *\n   * <Label>\n   *  <PropertyName>bar</PropertyName>\n   *  <PropertyName>john</PropertyName>\n   *  <Literal>foo</Literal>\n   *  <PropertyName>doe</PropertyName>\n   * </Label>\n   * --> \"{{bar}}{{john}}foo{{doe}}\"\n   *\n   * @param sldLabel\n   */\n  getTextSymbolizerLabelFromSldSymbolizer = (\n    sldLabel: any\n  ): string | Expression<string> => {\n    if (\n      Array.isArray(sldLabel) &&\n      sldLabel[0] &&\n      typeof sldLabel[0] === 'object' &&\n      (sldLabel[0].Function || sldLabel[0]['ogc:Function'])\n    ) {\n      const funcObj = sldLabel[0];\n      const funcArgs = funcObj.Function || funcObj['ogc:Function'];\n      const funcName = funcObj[':@']?.['@_name'];\n      const convertSldArgToGeoStyler = (arg: any): any => {\n        if (arg.PropertyName || arg['ogc:PropertyName']) {\n          const prop = arg.PropertyName?.[0]?.['#text'] ?? arg['ogc:PropertyName']?.[0]?.['#text'];\n          return {\n            name: 'property',\n            args: [prop]\n          };\n        }\n        if (arg.Literal || arg['ogc:Literal']) {\n          return arg.Literal?.[0]?.['#text'] !== undefined\n            ? arg.Literal[0]['#text']\n            : arg['ogc:Literal']?.[0]?.['#text'] ?? '';\n        }\n        if (arg.Function || arg['ogc:Function']) {\n          // Recursively handle nested functions\n          return this.getTextSymbolizerLabelFromSldSymbolizer([arg]);\n        }\n        return arg;\n      };\n\n      const args = funcArgs.map(convertSldArgToGeoStyler);\n      return {\n        name: funcName,\n        args\n      } as GeoStylerStringFunction;\n    }\n\n    const label: string = sldLabel\n      .map((labelEl: any) => {\n        const labelName = Object.keys(labelEl)[0];\n        switch (labelName.replace('ogc:', '')) {\n          case '#text':\n            return labelEl['#text'];\n          case 'Literal':\n            return labelEl?.[labelName]?.[0]?.['#text'] || labelEl?.[labelName]?.[0]?.['#cdata']?.[0]?.['#text'];\n          case 'PropertyName':\n            const propName = labelEl[labelName][0]['#text'];\n            return `{{${propName}}}`;\n          default:\n            return '';\n        }\n      })\n      .join('');\n    return label;\n  };\n\n  /**\n   * Get the geostyler-style FillSymbolizer from a SLD Symbolizer.\n   *\n   * PolygonSymbolizer Stroke is just partially supported.\n   *\n   * @param sldSymbolizer The SLD Symbolizer\n   * @return The geostyler-style FillSymbolizer\n   */\n  getFillSymbolizerFromSldSymbolizer(sldSymbolizer: any): FillSymbolizer {\n    const sldFillSymbolizer = sldSymbolizer.PolygonSymbolizer;\n    const distanceUnit: DistanceUnit | undefined = this.getDistanceUnit(sldSymbolizer);\n    const fillSymbolizer: FillSymbolizer = {\n      kind: 'Fill'\n    };\n    const strokeEl = get(sldFillSymbolizer, 'Stroke');\n    const fillEl = get(sldFillSymbolizer, 'Fill');\n\n    const fillOpacity = getParameterValue(fillEl, 'fill-opacity', this.readingSldVersion);\n    const color = getParameterValue(fillEl, 'fill', this.readingSldVersion);\n\n    const outlineColor = getParameterValue(strokeEl, 'stroke', this.readingSldVersion);\n    const outlineWidth = getParameterValue(strokeEl, 'stroke-width', this.readingSldVersion);\n    const outlineOpacity = getParameterValue(strokeEl, 'stroke-opacity', this.readingSldVersion);\n    const outlineDashArray = getParameterValue(strokeEl, 'stroke-dasharray', this.readingSldVersion);\n    const outlineCap = getParameterValue(strokeEl, 'stroke-linecap', this.readingSldVersion);\n    const outlineJoin = getParameterValue(strokeEl, 'stroke-linejoin', this.readingSldVersion);\n    // const outlineDashOffset = getParameterValue(strokeEl, 'stroke-dashoffset', this.readingSldVersion);\n\n    const graphicFill = get(sldFillSymbolizer, 'Fill.GraphicFill');\n    if (!isNil(graphicFill)) {\n      fillSymbolizer.graphicFill = this.getPointSymbolizerFromSldSymbolizer(\n        {PointSymbolizer: graphicFill}\n      );\n    }\n    if (this.isSldEnv(sldEnvGeoServer)) {\n      const graphicFillPadding = getVendorOptionValue(sldFillSymbolizer, 'graphic-margin');\n      if (!isNil(graphicFillPadding)) {\n        fillSymbolizer.graphicFillPadding = graphicFillPadding.split(/\\s/).map(numberExpression);\n      }\n    }\n    if (!isNil(color)) {\n      fillSymbolizer.color = color;\n    }\n    if (!isNil(fillOpacity)) {\n      fillSymbolizer.fillOpacity = numberExpression(fillOpacity);\n    }\n\n    if (!isNil(outlineColor)) {\n      fillSymbolizer.outlineColor = outlineColor;\n    }\n    if (!isNil(outlineWidth)) {\n      fillSymbolizer.outlineWidth = numberExpression(outlineWidth);\n    }\n    if (!isNil(distanceUnit)) {\n      fillSymbolizer.outlineWidthUnit = distanceUnit;\n    }\n    if (!isNil(outlineOpacity)) {\n      fillSymbolizer.outlineOpacity = numberExpression(outlineOpacity);\n    }\n    if (!isNil(outlineDashArray)) {\n      fillSymbolizer.outlineDasharray = outlineDashArray.split(' ').map(numberExpression);\n    }\n    if (!isNil(outlineCap)) {\n      fillSymbolizer.outlineCap = outlineCap;\n    }\n    if (!isNil(outlineJoin)) {\n      fillSymbolizer.outlineJoin = outlineJoin;\n    }\n    // TODO: seems like this is missing in the geostyer-stlye\n    // if (outlineDashOffset) {\n    //   fillSymbolizer.outlineDashOffset = Number(outlineDashOffset);\n    // }\n    return fillSymbolizer;\n  }\n\n  /**\n   * Get the geostyler-style RasterSymbolizer from a SLD Symbolizer.\n   *\n   * @param sldSymbolizer The SLD Symbolizer\n   */\n  getRasterSymbolizerFromSldSymbolizer(sldSymbolizer: any): RasterSymbolizer {\n    const sldRasterSymbolizer = sldSymbolizer.RasterSymbolizer;\n    const rasterSymbolizer: RasterSymbolizer = {\n      kind: 'Raster'\n    };\n    // parse Opacity\n    let opacity = get(sldRasterSymbolizer, 'Opacity.#text');\n    if (!isNil(opacity)) {\n      opacity = numberExpression(opacity);\n      rasterSymbolizer.opacity = opacity;\n    }\n    // parse ColorMap\n    const sldColorMap = get(sldRasterSymbolizer, 'ColorMap');\n    const sldColorMapType = get(sldRasterSymbolizer, 'ColorMap.@type');\n    const extended = get(sldRasterSymbolizer, 'ColorMap.@extended');\n    if (!isNil(sldColorMap)) {\n      const colormap = this.getColorMapFromSldColorMap(sldColorMap, sldColorMapType, extended);\n      rasterSymbolizer.colorMap = colormap;\n    }\n    // parse ChannelSelection\n    const sldChannelSelection = get(sldRasterSymbolizer, 'ChannelSelection');\n    if (!isNil(sldChannelSelection)) {\n      const channelSelection = this.getChannelSelectionFromSldChannelSelection(sldChannelSelection);\n      rasterSymbolizer.channelSelection = channelSelection;\n    }\n    // parse ContrastEnhancement\n    const sldContrastEnhancement = get(sldRasterSymbolizer, 'ContrastEnhancement');\n    if (!isNil(sldContrastEnhancement)) {\n      const contrastEnhancement = this.getContrastEnhancementFromSldContrastEnhancement(sldContrastEnhancement);\n      rasterSymbolizer.contrastEnhancement = contrastEnhancement;\n    }\n    return rasterSymbolizer;\n  }\n\n  /**\n   * Get the geostyler-style MarkSymbolizer from a SLD Symbolizer\n   *\n   * @param sldSymbolizer The SLD Symbolizer\n   * @return The geostyler-style MarkSymbolizer\n   */\n  getMarkSymbolizerFromSldSymbolizer(sldSymbolizer: any): MarkSymbolizer {\n    const sldMarkSymbolizer = sldSymbolizer.PointSymbolizer;\n    const distanceUnit: DistanceUnit | undefined = this.getDistanceUnit(sldSymbolizer);\n    const wellKnownName: WellKnownName = get(sldMarkSymbolizer, 'Graphic.Mark.WellKnownName.#text');\n    const strokeEl = get(sldMarkSymbolizer, 'Graphic.Mark.Stroke');\n    const fillEl = get(sldMarkSymbolizer, 'Graphic.Mark.Fill');\n\n    const opacity = get(sldMarkSymbolizer, 'Graphic.Opacity.#text');\n    const size = get(sldMarkSymbolizer, 'Graphic.Size.#text');\n    const rotation = get(sldMarkSymbolizer, 'Graphic.Rotation.#text');\n    const fillOpacity = getParameterValue(fillEl, 'fill-opacity', this.readingSldVersion);\n    const color = getParameterValue(fillEl, 'fill', this.readingSldVersion);\n    const displacement = get(sldMarkSymbolizer, 'Graphic.Displacement');\n\n    const markSymbolizer: MarkSymbolizer = {\n      kind: 'Mark',\n      wellKnownName: 'circle'\n    };\n\n    if (!isNil(opacity)) {\n      markSymbolizer.opacity = numberExpression(opacity);\n    }\n    if (!isNil(fillOpacity)) {\n      markSymbolizer.fillOpacity = numberExpression(fillOpacity);\n    }\n    if (!isNil(color)) {\n      markSymbolizer.color = color;\n    }\n    if (!isNil(rotation)) {\n      markSymbolizer.rotate = numberExpression(rotation);\n    }\n    if (!isNil(size)) {\n      // edge case where the value has to be divided by 2 which has to be considered in the function\n      markSymbolizer.radius = isGeoStylerNumberFunction(size) ? size : Number(size) / 2;\n    }\n    if (!isNil(distanceUnit)) {\n      markSymbolizer.radiusUnit = distanceUnit;\n    }\n    if (displacement) {\n      const x = get(displacement, 'DisplacementX.#text');\n      const y = get(displacement, 'DisplacementY.#text');\n      markSymbolizer.offset = [\n        Number.isFinite(x) ? numberExpression(x) : 0,\n        Number.isFinite(y) ? numberExpression(y) : 0,\n      ];\n    }\n\n    switch (wellKnownName) {\n      case 'arrow':\n      case 'arrowhead':\n      case 'asterisk_fill':\n      case 'backslash':\n      case 'circle':\n      case 'cross':\n      case 'cross2':\n      case 'cross_fill':\n      case 'decagon':\n      case 'diagonal_half_square':\n      case 'diamond':\n      case 'equilateral_triangle':\n      case 'filled_arrowhead':\n      case 'half_arc':\n      case 'half_square':\n      case 'heart':\n      case 'hexagon':\n      case 'horline':\n      case 'left_half_triangle':\n      case 'line':\n      case 'octagon':\n      case 'parallelogram_left':\n      case 'parallelogram_right':\n      case 'pentagon':\n      case 'quarter_arc':\n      case 'quarter_circle':\n      case 'quarter_square':\n      case 'right_half_triangle':\n      case 'rounded_square':\n      case 'semi_circle':\n      case 'shield':\n      case 'slash':\n      case 'square':\n      case 'square_with_corners':\n      case 'star':\n      case 'star_diamond':\n      case 'third_arc':\n      case 'third_circle':\n      case 'trapezoid':\n      case 'triangle':\n      case 'x':\n      case 'shape://vertline':\n      case 'shape://horline':\n      case 'shape://slash':\n      case 'shape://backslash':\n      case 'shape://dot':\n      case 'shape://plus':\n      case 'shape://times':\n      case 'shape://oarrow':\n      case 'shape://carrow':\n      case 'brush://dense1':\n      case 'brush://dense2':\n      case 'brush://dense3':\n      case 'brush://dense4':\n      case 'brush://dense5':\n      case 'brush://dense6':\n      case 'brush://dense7':\n        markSymbolizer.wellKnownName = wellKnownName;\n        break;\n      default:\n        if (WELLKNOWNNAME_TTF_REGEXP.test(wellKnownName)) {\n          markSymbolizer.wellKnownName = wellKnownName;\n          break;\n        }\n        throw new Error(\n          this.translate('marksymbolizerParseFailedUnknownWellknownName', { wellKnownName: wellKnownName })\n        );\n    }\n\n    const strokeColor = getParameterValue(strokeEl, 'stroke', this.readingSldVersion);\n    if (!isNil(strokeColor)) {\n      markSymbolizer.strokeColor = strokeColor;\n    }\n    const strokeWidth = getParameterValue(strokeEl, 'stroke-width', this.readingSldVersion);\n    if (!isNil(strokeWidth)) {\n      markSymbolizer.strokeWidth = numberExpression(strokeWidth);\n    }\n    if (!isNil(distanceUnit)) {\n      markSymbolizer.strokeWidthUnit = distanceUnit;\n    }\n    const strokeOpacity = getParameterValue(strokeEl, 'stroke-opacity', this.readingSldVersion);\n    if (!isNil(strokeOpacity)) {\n      markSymbolizer.strokeOpacity = numberExpression(strokeOpacity);\n    }\n    const strokeDasharray = getParameterValue(strokeEl, 'stroke-dasharray', this.readingSldVersion);\n    if (!isNil(strokeDasharray)) {\n      const dashStringAsArray = strokeDasharray.split(' ').map(numberExpression);\n      markSymbolizer.strokeDasharray = dashStringAsArray;\n    }\n\n    return markSymbolizer;\n  }\n\n  /**\n   * Get the geostyler-style IconSymbolizer from a SLD Symbolizer\n   *\n   * @param sldSymbolizer The SLD Symbolizer\n   * @return The geostyler-style IconSymbolizer\n   */\n  getIconSymbolizerFromSldSymbolizer(\n    sldSymbolizer: any,\n    forcedDistanceUnit: DistanceUnit | undefined = undefined\n  ): IconSymbolizer {\n    const sldIconSymbolizer = sldSymbolizer.PointSymbolizer;\n    const distanceUnit: DistanceUnit | undefined = forcedDistanceUnit || this.getDistanceUnit(sldSymbolizer);\n    let image = get(sldIconSymbolizer, 'Graphic.ExternalGraphic.OnlineResource.@href');\n    if (!image && this.sldVersion === '1.1.0') {\n      const encoding = get(sldIconSymbolizer, 'Graphic.ExternalGraphic.InlineContent.@encoding');\n      if (encoding === 'base64') {\n        const extension = get(sldIconSymbolizer, 'Graphic.ExternalGraphic.Format.#text');\n        const base64String = get(sldIconSymbolizer, 'Graphic.ExternalGraphic.InlineContent.#text');\n        image = `data:${extension};base64,${base64String}`;\n      }\n    }\n    const iconSymbolizer: IconSymbolizer = <IconSymbolizer>{\n      kind: 'Icon',\n      image\n    };\n    const opacity: string = get(sldIconSymbolizer, 'Graphic.Opacity.#text');\n    const size: string = get(sldIconSymbolizer, 'Graphic.Size.#text');\n    const rotation: string = get(sldIconSymbolizer, 'Graphic.Rotation.#text');\n    const displacement = get(sldIconSymbolizer, 'Graphic.Displacement');\n    if (!isNil(opacity)) {\n      iconSymbolizer.opacity = numberExpression(opacity);\n    }\n    if (!isNil(size)) {\n      iconSymbolizer.size = numberExpression(size);\n    }\n    if (!isNil(distanceUnit)) {\n      iconSymbolizer.sizeUnit = distanceUnit;\n    }\n    if (!isNil(rotation)) {\n      iconSymbolizer.rotate = numberExpression(rotation);\n    }\n    if (displacement) {\n      const x = get(displacement, 'DisplacementX.#text');\n      const y = get(displacement, 'DisplacementY.#text');\n      iconSymbolizer.offset = [\n        Number.isFinite(x) ? numberExpression(x) : 0,\n        Number.isFinite(y) ? numberExpression(y) : 0,\n      ];\n    }\n    return iconSymbolizer;\n  }\n\n  /**\n   * Get the geostyler-style ColorMap from a SLD ColorMap.\n   *\n   * @param sldColorMap The SLD ColorMap\n   */\n  getColorMapFromSldColorMap(sldColorMap: any, type: ColorMapType = 'ramp', extended?: string): ColorMap {\n    const colorMap: ColorMap = {\n      type\n    };\n\n    if (extended) {\n      if (extended === 'true') {\n        colorMap.extended = true;\n      } else {\n        colorMap.extended = false;\n      }\n    }\n\n    const colorMapEntries = getChildren(sldColorMap, 'ColorMapEntry');\n    if (Array.isArray(colorMapEntries)) {\n      const cmEntries = colorMapEntries.map((cm) => {\n        const color = getAttribute(cm, 'color');\n        if (!color) {\n          throw new Error(this.translate('colorMapEntriesParseFailedColorUndefined'));\n        }\n        let quantity = getAttribute(cm, 'quantity');\n        if (quantity) {\n          quantity = numberExpression(quantity);\n        }\n        const label = getAttribute(cm, 'label');\n        let opacity = getAttribute(cm, 'opacity');\n        if (!isNil(opacity)) {\n          opacity = numberExpression(opacity);\n        }\n        return {\n          color,\n          quantity,\n          label,\n          opacity\n        } as ColorMapEntry;\n      });\n      colorMap.colorMapEntries = cmEntries;\n    }\n\n    return colorMap;\n  }\n\n  /**\n   * Get the geostyler-style ContrastEnhancement from a SLD ContrastEnhancement.\n   *\n   * @param sldContrastEnhancement The SLD ContrastEnhancement\n   */\n  getContrastEnhancementFromSldContrastEnhancement(sldContrastEnhancement: any): ContrastEnhancement {\n    const contrastEnhancement: ContrastEnhancement = {};\n\n    // parse enhancementType\n    const hasHistogram = !!get(sldContrastEnhancement, 'Histogram');\n    const hasNormalize = !!get(sldContrastEnhancement, 'Normalize');\n    if (hasHistogram && hasNormalize) {\n      throw new Error(this.translate('contrastEnhancParseFailedHistoAndNormalizeMutuallyExclusive'));\n    } else if (hasHistogram) {\n      contrastEnhancement.enhancementType = 'histogram';\n    } else if (hasNormalize) {\n      contrastEnhancement.enhancementType = 'normalize';\n    }\n    // parse gammavalue\n    let gammaValue = get(sldContrastEnhancement, 'GammaValue.#text');\n    if (gammaValue) {\n      gammaValue = numberExpression(gammaValue);\n    }\n    contrastEnhancement.gammaValue = gammaValue;\n\n    return contrastEnhancement;\n  }\n\n  /**\n   * Get the geostyler-style Channel from a SLD Channel.\n   *\n   * @param sldChannel The SLD Channel\n   */\n  getChannelFromSldChannel(sldChannel: any): Channel {\n    const sourceChannelName = get(sldChannel, 'SourceChannelName.#text')?.toString();\n    const channel: Channel = {\n      sourceChannelName\n    };\n    const contrastEnhancement = get(sldChannel, 'ContrastEnhancement');\n    if (contrastEnhancement) {\n      channel.contrastEnhancement = this.getContrastEnhancementFromSldContrastEnhancement(contrastEnhancement);\n    }\n    return channel;\n  }\n\n  /**\n   * Get the geostyler-style ChannelSelection from a SLD ChannelSelection.\n   *\n   * @param sldChannelSelection The SLD ChannelSelection\n   */\n  getChannelSelectionFromSldChannelSelection(sldChannelSelection: any): ChannelSelection {\n    let channelSelection: ChannelSelection;\n    const red = get(sldChannelSelection, 'RedChannel');\n    const blue = get(sldChannelSelection, 'BlueChannel');\n    const green = get(sldChannelSelection, 'GreenChannel');\n    const gray = get(sldChannelSelection, 'GrayChannel');\n\n    if (gray && red && blue && green) {\n      throw new Error(this.translate('channelSelectionParseFailedRGBAndGrayscaleMutuallyExclusive'));\n    }\n    if (gray) {\n      const grayChannel = this.getChannelFromSldChannel(gray);\n      channelSelection = {\n        grayChannel\n      };\n    } else if (red && green && blue) {\n      const redChannel = this.getChannelFromSldChannel(red);\n      const blueChannel = this.getChannelFromSldChannel(blue);\n      const greenChannel = this.getChannelFromSldChannel(green);\n      channelSelection = {\n        redChannel,\n        blueChannel,\n        greenChannel\n      };\n    } else {\n      throw new Error(this.translate('channelSelectionParseFailedRGBChannelsUndefined'));\n    }\n    return channelSelection;\n  }\n\n  /**\n   * The writeStyle implementation of the geostyler-style StyleParser interface.\n   * It reads a geostyler-style and returns a Promise.\n   * The Promise itself resolves with a SLD string.\n   *\n   * @param geoStylerStyle A geostyler-style.\n   * @return The Promise resolving with the SLD as a string.\n   */\n  writeStyle(geoStylerStyle: Style): Promise<WriteStyleResult<string>> {\n    return new Promise<WriteStyleResult<string>>(resolve => {\n      const unsupportedProperties = this.checkForUnsupportedProperties(geoStylerStyle);\n      try {\n        const sldObject = this.geoStylerStyleToSldObject(geoStylerStyle);\n        const sldString = this.builder.build(sldObject);\n        resolve({\n          output: sldString,\n          unsupportedProperties,\n          warnings: unsupportedProperties && ['Your style contains unsupportedProperties!']\n        });\n      } catch (error) {\n        resolve({\n          errors: [error]\n        });\n      }\n    });\n  }\n\n  /**\n   * Get the correct tagName in dependency to the configured sldVersion.\n   *\n   * @param tagName\n   * @returns The tagName as used by the configured sldVersion\n   */\n  getTagName(tagName: string): string {\n    const ogcList = ['Filter'];\n    if (ogcList.includes(tagName)) {\n      return tagName;\n    }\n    if (tagName === 'CssParameter') {\n      return this.sldVersion === '1.1.0' ? 'se:SvgParameter' : 'CssParameter';\n    }\n    return this.sldVersion === '1.1.0' ? `se:${tagName}` : tagName;\n  }\n\n  /**\n   * Get the SLD Object (readable with fast-xml-parser) from a geostyler-style\n   *\n   * @param geoStylerStyle A geostyler-style.\n   * @return The object representation of a SLD Style (readable with fast-xml-parser)\n   */\n  geoStylerStyleToSldObject(geoStylerStyle: Style): any {\n    const rules: any[] = this.getSldRulesFromRules(geoStylerStyle.rules);\n    // add the ogc namespace to the filter element, if a filter is present\n    rules.forEach(rule => {\n      const ruleEl = get(rule, this.getTagName('Rule'));\n      const filter = getChildren(ruleEl, 'Filter').at(0);\n      if (filter) {\n        filter[':@'] = {\n          '@_xmlns': 'http://www.opengis.net/ogc'\n        };\n      }\n    });\n\n    const featureTypeStyle = [\n      ...rules\n    ];\n    const Name = this.getTagName('Name');\n    const Title = this.getTagName('Title');\n    const FeatureTypeStyle = this.getTagName('FeatureTypeStyle');\n\n    const attributes = {\n      '@_version': this.sldVersion,\n      '@_xsi:schemaLocation': 'http://www.opengis.net/sld StyledLayerDescriptor.xsd',\n      '@_xmlns': 'http://www.opengis.net/sld',\n      '@_xmlns:ogc': 'http://www.opengis.net/ogc',\n      '@_xmlns:xlink': 'http://www.w3.org/1999/xlink',\n      '@_xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',\n      '@_xmlns:se': 'http://www.opengis.net/se'\n    };\n\n    const userStyle = [];\n    userStyle.push({\n      [Name]: [{ '#text': geoStylerStyle.name || '' }]\n    });\n    if (this.sldVersion === '1.0.0') {\n      userStyle.push({\n        [Title]: [{ '#text': geoStylerStyle.name || '' }]\n      });\n    }\n    userStyle.push({\n      [FeatureTypeStyle]: featureTypeStyle\n    });\n\n    return [{\n      '?xml': [{ '#text': '' }],\n      ':@': {\n        '@_version': '1.0',\n        '@_encoding': 'UTF-8',\n        '@_standalone': 'yes'\n      },\n    }, {\n      StyledLayerDescriptor: [{\n        NamedLayer: [{\n          [Name]: [{ '#text': geoStylerStyle.name || '' }]\n        }, {\n          UserStyle: userStyle\n        }]\n      }],\n      ':@': attributes\n    }];\n  }\n\n  /**\n   * Get the SLD Object (readable with fast-xml-parser) from a geostyler-style Rule.\n   *\n   * @param rules An array of geostyler-style Rules.\n   * @return The object representation of a SLD Rule (readable with fast-xml-parser)\n   */\n  getSldRulesFromRules(rules: Rule[]): any[] {\n    const Name = this.getTagName('Name');\n    const filterTag = this.getTagName('Filter');\n    const ruleTag = this.getTagName('Rule');\n    const MinScaleDenominator = this.getTagName('MinScaleDenominator');\n    const MaxScaleDenominator = this.getTagName('MaxScaleDenominator');\n\n    return rules.map((rule: Rule) => {\n      const sldRule: any = {\n        [ruleTag]: []\n      };\n      if (rule.name) {\n        sldRule[ruleTag].push({\n          [Name]: [{\n            '#text': rule.name\n          }]\n        });\n      }\n      if (rule.filter) {\n        const filter = this.getSldFilterFromFilter(rule.filter);\n        sldRule[ruleTag].push({\n          [filterTag]: filter\n        });\n      }\n      if (rule.scaleDenominator) {\n        const { min, max } = rule.scaleDenominator;\n        if (min && Number.isFinite(min)) {\n          sldRule[ruleTag].push({\n            [MinScaleDenominator]: [{\n              '#text': min\n            }]\n          });\n        }\n        if (max && Number.isFinite(max)) {\n          sldRule[ruleTag].push({\n            [MaxScaleDenominator]: [{\n              '#text': max\n            }]\n          });\n        }\n      }\n\n      // Remove empty Symbolizers and check if there is at least 1 symbolizer\n      const symbolizers = this.getSldSymbolizersFromSymbolizers(rule.symbolizers);\n      let symbolizerKeys: string[] = [];\n      if (symbolizers.length > 0) {\n        symbolizerKeys = Object.keys(symbolizers[0]);\n      }\n      symbolizerKeys.forEach((key: string) => {\n        if (symbolizers[0][key].length === 0) {\n          delete symbolizers[0][key];\n        }\n      });\n\n      if (symbolizers.length > 0 && symbolizerKeys.length !== 0) {\n        sldRule[ruleTag] = [\n          ...sldRule[ruleTag],\n          ...symbolizers\n        ];\n      }\n      return sldRule;\n    });\n  }\n\n  /**\n   * Get the SLD Object (readable with fast-xml-parser) from a geostyler-style ComparisonFilter.\n   *\n   * @param comparisonFilter A geostyler-style ComparisonFilter.\n   * @return The object representation of a SLD Filter Expression with a\n   * comparison operator (readable with fast-xml-parser)\n   */\n  getSldComparisonFilterFromComparisonFilter(comparisonFilter: ComparisonFilter): any[] {\n    const sldComparisonFilter: any = [];\n    const operator = comparisonFilter[0];\n    const key = comparisonFilter[1];\n    const value = comparisonFilter[2];\n\n    const sldOperators: string[] = keysByValue(COMPARISON_MAP, operator);\n    const sldOperator: string = (sldOperators.length > 1 && value === null)\n      ? sldOperators[1] : sldOperators[0];\n\n    const propertyKey = 'PropertyName';\n\n    if (isGeoStylerFunction(key) || isGeoStylerFunction(value)) {\n      const tempOperator = sldOperator.replace('PropertyIs', '');\n      const sldFunctionOperator = tempOperator.charAt(0).toLowerCase() + tempOperator.slice(1);\n      const keyResult = isGeoStylerFunction(key) ? geoStylerFunctionToSldFunction(key) : key;\n      const valueResult = isGeoStylerFunction(value) ? geoStylerFunctionToSldFunction(value) : value;\n\n      const functionChildren: any = [];\n\n      if (isGeoStylerFunction(key)) {\n        functionChildren.unshift(Array.isArray(keyResult) ? keyResult?.[0] : keyResult);\n      } else {\n        functionChildren.unshift({\n          Literal: [{\n            '#text': keyResult\n          }]\n        });\n      }\n\n      if (isGeoStylerFunction(value)) {\n        functionChildren.push(Array.isArray(valueResult) ? valueResult?.[0] : valueResult);\n      } else {\n        functionChildren.push({\n          Literal: [{\n            '#text': valueResult\n          }]\n        });\n      }\n\n      return [{\n        Function: functionChildren,\n        ':@': {\n          '@_name': sldFunctionOperator\n        }\n      }];\n    }\n\n    if (sldOperator === 'PropertyIsNull') {\n      // empty, selfclosing Literals are not valid in a propertyIsNull filter\n      sldComparisonFilter.push({\n        [sldOperator]: [{\n          [propertyKey]: [{\n            '#text': key\n          }]\n        }]\n      });\n    } else if (sldOperator === 'PropertyIsLike') {\n      sldComparisonFilter.push({\n        [sldOperator]: [{\n          [propertyKey]: [{\n            '#text': key\n          }]\n        }, {\n          Literal: [{\n            '#text': value\n          }]\n        }],\n        [':@']: {\n          '@_wildCard': '*',\n          '@_singleChar': '.',\n          '@_escape': '!',\n        }\n      });\n    } else if (sldOperator === 'PropertyIsBetween') {\n      // Currently we only support Literals as values.\n      const betweenFilter = comparisonFilter as RangeFilter;\n      sldComparisonFilter.push({\n        [sldOperator]: [{\n          [propertyKey]: [{\n            '#text': key\n          }]\n        }, {\n          LowerBoundary: [{\n            Literal: [{\n              '#text': betweenFilter[2]\n            }]\n          }]\n        }, {\n          UpperBoundary: [{\n            Literal: [{\n              '#text': betweenFilter[3]\n            }]\n          }]\n        }]\n      });\n    } else {\n      sldComparisonFilter.push({\n        [sldOperator]: [{\n          [propertyKey]: [{\n            '#text': key\n          }]\n        }, {\n          Literal: [{\n            '#text': value\n          }]\n        }]\n      });\n    }\n\n\n    return sldComparisonFilter;\n  }\n\n  /**\n   * Get the SLD Object (readable with fast-xml-parser) from a geostyler-style Filter.\n   *\n   * @param filter A geostyler-style Filter.\n   * @return The object representation of a SLD Filter Expression (readable with fast-xml-parser)\n   */\n  getSldFilterFromFilter(filter: Filter): any[] {\n    let sldFilter: any[] = [];\n\n    if (isComparisonFilter(filter)) {\n      sldFilter = this.getSldComparisonFilterFromComparisonFilter(filter);\n    } else if (isNegationFilter(filter)) {\n      sldFilter.push({\n        Not: this.getSldFilterFromFilter(filter[1])\n      });\n    } else if (isCombinationFilter(filter)) {\n      const [\n        operator,\n        ...args\n      ] = filter;\n      const sldOperators: string[] = keysByValue(COMBINATION_MAP, operator);\n      const combinator = sldOperators[0];\n      const sldSubFilters = args.map(subFilter => this.getSldFilterFromFilter(subFilter)[0]);\n      sldFilter.push({\n        [combinator]: sldSubFilters\n      });\n    }\n    return sldFilter;\n  }\n\n  /**\n   * Checks on presence of the pseudo-property 'uom' inserted by function 'addUomEntry', removes it and inserts\n   * an uom-attribute. Do it only for SLD 1.1.0, ignore it otherwise.\n   */\n  moveUomEntryToAttributes(sldSymbolizer: any, sldSymbolizerProperties: any[]) {\n    const uomValue = sldSymbolizerProperties[sldSymbolizerProperties.length-1].uom;\n    if (!uomValue) {\n      return;\n    }\n    // put uom as attribute of symbolizer-node\n    if (this.sldVersion === '1.1.0') {\n      sldSymbolizer[':@'] = {'@_uom': uomValue};\n    }\n    // and remove this entry from symbolizer-properties because it isn't a valid property\n    sldSymbolizerProperties.pop();\n  }\n\n  /**\n   * Checks Distance-Unit used by given symbolizer and inserts a pseudo-property 'uom' if required, because\n   * we only have a property-array returned by the getSldXXXSymbolizerFromXXXSymbolizer-functions.\n   * Later, we will move to an attribute within function 'moveUomEntryToAttributes'\n   */\n  addUomEntry(sldSymbolizerProperties: any[], unit: DistanceUnit | undefined) {\n    if (unit === 'm') {\n      sldSymbolizerProperties.push({uom: unitSldMetre});\n    }\n    if (unit === 'px') {\n      sldSymbolizerProperties.push({uom: unitSldPixel});\n    }\n  }\n\n  /**\n   * Checks for an 'uom'-attribute and returns the distance-unit to be used for interpreting the\n   * units of the symbolizer.\n   */\n  getDistanceUnit(sldSymbolizer: any): DistanceUnit | undefined {\n    if (!sldSymbolizer) {\n      return undefined;\n    }\n    const uomAttribute = getAttribute(sldSymbolizer,'uom');\n    if (!uomAttribute) {\n      return undefined;\n    }\n    if (uomAttribute === unitSldMetre) {\n      return 'm';\n    }\n    if (uomAttribute === unitSldPixel) {\n      return 'px';\n    }\n    return undefined;\n  }\n\n\n  /**\n   * Get the SLD Object (readable with fast-xml-parser) from geostyler-style Symbolizers.\n   *\n   * @param symbolizers A geostyler-style Symbolizer array.\n   * @return The object representation of a SLD Symbolizer (readable with fast-xml-parser)\n   */\n  getSldSymbolizersFromSymbolizers(symbolizers: Symbolizer[]): any {\n    const sldSymbolizers: any = [];\n    const pointSymbolizerTag = this.getTagName('PointSymbolizer');\n    const textSymbolizerTag = this.getTagName('TextSymbolizer');\n    const lineSymbolizerTag = this.getTagName('LineSymbolizer');\n    const polygonSymbolizerTag = this.getTagName('PolygonSymbolizer');\n    const rasterSymbolizerTag = this.getTagName('RasterSymbolizer');\n\n    symbolizers.forEach(symb => {\n      const sldSymbolizer: any = {};\n      let sldSymb: any[] | undefined;\n      switch (symb.kind) {\n        case 'Mark':\n          sldSymb = this.getSldPointSymbolizerFromMarkSymbolizer(symb);\n          sldSymbolizer[pointSymbolizerTag] = sldSymb;\n          break;\n        case 'Icon':\n          sldSymb = this.getSldPointSymbolizerFromIconSymbolizer(symb);\n          sldSymbolizer[pointSymbolizerTag] = sldSymb;\n          break;\n        case 'Text':\n          sldSymb = this.getSldTextSymbolizerFromTextSymbolizer(symb);\n          sldSymbolizer[textSymbolizerTag] = sldSymb;\n          break;\n        case 'Line':\n          sldSymb = this.getSldLineSymbolizerFromLineSymbolizer(symb);\n          sldSymbolizer[lineSymbolizerTag] = sldSymb;\n          break;\n        case 'Fill':\n          sldSymb = this.getSldPolygonSymbolizerFromFillSymbolizer(symb);\n          sldSymbolizer[polygonSymbolizerTag] = sldSymb;\n          break;\n        case 'Raster':\n          sldSymb = this.getSldRasterSymbolizerFromRasterSymbolizer(symb);\n          sldSymbolizer[rasterSymbolizerTag] = sldSymb;\n          break;\n        default:\n          break;\n      }\n      if (sldSymbolizer && sldSymb) {\n        // move the pseudo-property 'uom' to an attribute if required\n        this.moveUomEntryToAttributes(sldSymbolizer, sldSymb);\n      }\n      sldSymbolizers.push(sldSymbolizer);\n    });\n    return sldSymbolizers;\n  }\n\n  /**\n   * Get the SLD Object (readable with fast-xml-parser) from a geostyler-style MarkSymbolizer.\n   *\n   * @param markSymbolizer A geostyler-style MarkSymbolizer.\n   * @return The object representation of a SLD PointSymbolizer with a Mark\n   */\n  getSldPointSymbolizerFromMarkSymbolizer(markSymbolizer: MarkSymbolizer): any {\n    const wellKnownName = this.getTagName('WellKnownName');\n    const CssParameter = this.getTagName('CssParameter');\n    const Fill = this.getTagName('Fill');\n    const Mark = this.getTagName('Mark');\n    const Stroke = this.getTagName('Stroke');\n    const Opacity = this.getTagName('Opacity');\n    const Rotation = this.getTagName('Rotation');\n    const Size = this.getTagName('Size');\n    const Graphic = this.getTagName('Graphic');\n    const Displacement = this.getTagName('Displacement');\n    const DisplacementX = this.getTagName('DisplacementX');\n    const DisplacementY = this.getTagName('DisplacementY');\n\n    const isFontSymbol = WELLKNOWNNAME_TTF_REGEXP.test(markSymbolizer.wellKnownName);\n    const mark: any[] = [{\n      [wellKnownName]: [{\n        '#text': isFontSymbol ? markSymbolizer.wellKnownName : markSymbolizer.wellKnownName.toLowerCase()\n      }]\n    }];\n\n    if (markSymbolizer.color || !isNil(markSymbolizer.fillOpacity)) {\n      const fillCssParamaters = [];\n      if (markSymbolizer.color) {\n        if (isGeoStylerFunction(markSymbolizer.color)) {\n          const children = geoStylerFunctionToSldFunction(markSymbolizer.color);\n          fillCssParamaters.push({\n            [CssParameter]: children,\n            ':@': {\n              '@_name': 'fill'\n            }\n          });\n        } else {\n          fillCssParamaters.push({\n            [CssParameter]: [{\n              '#text': markSymbolizer.color,\n            }],\n            ':@': {\n              '@_name': 'fill'\n            }\n          });\n        }\n      }\n      if (!isNil(markSymbolizer.fillOpacity)) {\n        if (isGeoStylerFunction(markSymbolizer.fillOpacity)) {\n          const children = geoStylerFunctionToSldFunction(markSymbolizer.fillOpacity);\n          fillCssParamaters.push({\n            [CssParameter]: children,\n            ':@': {\n              '@_name': 'fill-opacity'\n            }\n          });\n        } else {\n          fillCssParamaters.push({\n            [CssParameter]: [{\n              '#text': markSymbolizer.fillOpacity,\n            }],\n            ':@': {\n              '@_name': 'fill-opacity'\n            }\n          });\n        }\n      }\n      mark.push({\n        [Fill]: fillCssParamaters\n      });\n    }\n\n    if (markSymbolizer.strokeColor ||\n      Number.isFinite(markSymbolizer.strokeWidth) ||\n      Number.isFinite(markSymbolizer.strokeOpacity)\n    ) {\n      const strokeCssParameters = [];\n      if (markSymbolizer.strokeColor) {\n        if (isGeoStylerFunction(markSymbolizer.strokeColor)) {\n          const children = geoStylerFunctionToSldFunction(markSymbolizer.strokeColor);\n          strokeCssParameters.push({\n            [CssParameter]: children,\n            ':@': {\n              '@_name': 'stroke'\n            }\n          });\n        } else {\n          strokeCssParameters.push({\n            [CssParameter]: [{\n              '#text': markSymbolizer.strokeColor,\n            }],\n            ':@': {\n              '@_name': 'stroke'\n            }\n          });\n        }\n      }\n      if (!isNil(markSymbolizer.strokeWidth)) {\n        if (isGeoStylerFunction(markSymbolizer.strokeWidth)) {\n          const children = geoStylerFunctionToSldFunction(markSymbolizer.strokeWidth);\n          strokeCssParameters.push({\n            [CssParameter]: children,\n            ':@': {\n              '@_name': 'stroke-width'\n            }\n          });\n        } else {\n          strokeCssParameters.push({\n            [CssParameter]: [{\n              '#text': markSymbolizer.strokeWidth,\n            }],\n            ':@': {\n              '@_name': 'stroke-width'\n            }\n          });\n        }\n      }\n      if (!isNil(markSymbolizer.strokeOpacity)) {\n        if (isGeoStylerFunction(markSymbolizer.strokeOpacity)) {\n          const children = geoStylerFunctionToSldFunction(markSymbolizer.strokeOpacity);\n          strokeCssParameters.push({\n            [CssParameter]: children,\n            ':@': {\n              '@_name': 'stroke-opacity'\n            }\n          });\n        } else {\n          strokeCssParameters.push({\n            [CssParameter]: [{\n              '#text': markSymbolizer.strokeOpacity,\n            }],\n            ':@': {\n              '@_name': 'stroke-opacity'\n            }\n          });\n        }\n      }\n      if (!isNil(markSymbolizer.strokeDasharray)) {\n        if (isGeoStylerFunction(markSymbolizer.strokeDasharray)) {\n          const children = geoStylerFunctionToSldFunction(markSymbolizer.strokeDasharray);\n          strokeCssParameters.push({\n            [CssParameter]: children,\n            ':@': {\n              '@_name': 'stroke-dasharray'\n            }\n          });\n        } else {\n          strokeCssParameters.push({\n            [CssParameter]: [{\n              '#text': markSymbolizer.strokeDasharray?.join(' '),\n            }],\n            ':@': {\n              '@_name': 'stroke-dasharray'\n            }\n          });\n        }\n      }\n      mark.push({\n        [Stroke]: strokeCssParameters\n      });\n    }\n\n    const graphic: any[] = [{\n      [Mark]: mark\n    }];\n\n    if (!isNil(markSymbolizer.opacity)) {\n      graphic.push({\n        [Opacity]: [{\n          '#text': markSymbolizer.opacity!.toString()\n        }]\n      });\n    }\n\n    if (markSymbolizer.radius !== undefined) {\n      if (isGeoStylerFunction(markSymbolizer.radius)) {\n        graphic.push({\n          // TODO: Double check if we have to multiply this by 2\n          [Size]: geoStylerFunctionToSldFunction(markSymbolizer.radius)\n        });\n      } else {\n        graphic.push({\n          [Size]: [{\n            '#text': (markSymbolizer.radius * 2).toString()\n          }]\n        });\n      }\n    }\n\n    if (markSymbolizer.rotate) {\n      graphic.push({\n        [Rotation]: [{\n          '#text': markSymbolizer.rotate.toString()\n        }]\n      });\n    }\n\n    if (markSymbolizer.offset && (this.sldVersion === '1.1.0' || this.isSldEnv(sldEnvGeoServer))) {\n      graphic.push({\n        [Displacement]: [{\n          [DisplacementX]: [{\n            '#text': markSymbolizer.offset[0].toString()\n          }]\n        }, {\n          [DisplacementY]: [{\n            '#text': markSymbolizer.offset[1].toString()\n          }]\n        }]\n      });\n    }\n\n    const result = [{\n      [Graphic]: graphic\n    }];\n\n    this.addUomEntry(result, markSymbolizer.radiusUnit);\n    return result;\n  }\n\n  /**\n   * Push a new GeoServerVendorOption in the given array if such options are allowed.\n   */\n  pushGeoServerVendorOption(elementArray: any[], name: string, text: string) {\n    if (this.isSldEnv(sldEnvGeoServer)) {\n      elementArray.push(this.createGeoServerVendorOption(name, text));\n    }\n  }\n\n  /**\n   * @returns <VendorOption name=\"name\">text</VendorOption>\n   */\n  createGeoServerVendorOption(name: string, text: string) {\n    const VendorOption = this.getTagName('VendorOption');\n    return {\n      [VendorOption]: [{\n        '#text': text,\n      }],\n      ':@': {\n        '@_name': name,\n      }\n    };\n  }\n\n  /**\n   * Get the SLD Object (readable with fast-xml-parser) from a geostyler-style IconSymbolizer.\n   *\n   * @param iconSymbolizer A geostyler-style IconSymbolizer.\n   * @return The object representation of a SLD PointSymbolizer with\n   * an \"ExternalGraphic\" (readable with fast-xml-parser)\n   */\n  getSldPointSymbolizerFromIconSymbolizer(iconSymbolizer: IconSymbolizer): any {\n    const Opacity = this.getTagName('Opacity');\n    const Rotation = this.getTagName('Rotation');\n    const Size = this.getTagName('Size');\n    const Graphic = this.getTagName('Graphic');\n    const Displacement = this.getTagName('Displacement');\n    const DisplacementX = this.getTagName('DisplacementX');\n    const DisplacementY = this.getTagName('DisplacementY');\n\n    const graphic: any[] = [];\n    if (typeof iconSymbolizer.image === 'string' || iconSymbolizer.image instanceof String) {\n      const base64Object = getBase64Object(iconSymbolizer.image as string);\n      if (base64Object) {\n        graphic.push(this.getSldExternalResourceInlineContent(base64Object));\n      } else {\n        graphic.push(this.getSldExternalResourceOnlineResource(iconSymbolizer.image as string));\n      }\n    }\n\n    if (!isNil(iconSymbolizer.opacity)) {\n      graphic.push({\n        [Opacity]: [{\n          '#text': iconSymbolizer.opacity,\n        }]\n      });\n    }\n    if (iconSymbolizer.size) {\n      graphic.push({\n        [Size]: [{\n          '#text': iconSymbolizer.size,\n        }]\n      });\n    }\n    if (iconSymbolizer.rotate) {\n      graphic.push({\n        [Rotation]: [{\n          '#text': iconSymbolizer.rotate,\n        }]\n      });\n    }\n    if (iconSymbolizer.offset && this.sldVersion === '1.1.0') {\n      graphic.push({\n        [Displacement]: [{\n          [DisplacementX]: [{\n            '#text': iconSymbolizer.offset[0].toString(),\n          }]\n        }, {\n          [DisplacementY]: [{\n            '#text': iconSymbolizer.offset[1].toString(),\n          }]\n        }]\n      });\n    }\n    return [{\n      [Graphic]: graphic\n    }];\n  }\n\n  /**\n   * From a Base64ImageObject, create a SLD ExternalGraphic.\n   * @return a base64 InlineContent in an ExternalGraphic (readable with fast-xml-parser).\n   */\n  getSldExternalResourceInlineContent(image: Base64ImageObject): any {\n    const ExternalGraphic = this.getTagName('ExternalGraphic');\n    const Format = this.getTagName('Format');\n    const InlineContent = this.getTagName('InlineContent');\n    return {\n      [ExternalGraphic]: [{\n        [InlineContent]: [{\n          '#text': image.data,\n        }],\n        ':@': {\n          '@_encoding': 'base64',\n        }\n      }, {\n        [Format]: [{\n          '#text': `image/${image.extension}`,\n        }],\n      }]\n    };\n  }\n\n  /**\n   * From a URL, create a SLD ExternalGraphic.\n   * @return an OnlineResource in an ExternalGraphic (readable with fast-xml-parser).\n   */\n  getSldExternalResourceOnlineResource(image: string): any {\n    const ExternalGraphic = this.getTagName('ExternalGraphic');\n    const Format = this.getTagName('Format');\n    const OnlineResource = this.getTagName('OnlineResource');\n\n    const graphic: any = {\n      [ExternalGraphic]: [{\n        [OnlineResource]: [],\n        ':@': {\n          '@_xlink:type': 'simple',\n          '@_xmlns:xlink': 'http://www.w3.org/1999/xlink',\n          '@_xlink:href': image,\n        }\n      }, {[Format]: []}]\n    };\n\n    const iconExt = image.split('.').pop();\n    switch (iconExt) {\n      case 'png':\n      case 'jpeg':\n      case 'gif':\n        graphic[ExternalGraphic][1][Format] = [{\n          '#text': `image/${iconExt}`,\n        }];\n        break;\n      case 'jpg':\n        graphic[ExternalGraphic][1][Format] = [{\n          '#text': 'image/jpeg',\n        }];\n        break;\n      case 'svg':\n        graphic[ExternalGraphic][1][Format] = [{\n          '#text': 'image/svg+xml',\n        }];\n        break;\n      case undefined:\n      default:\n        break;\n    }\n    return graphic;\n  }\n\n  /**\n   * Translates an anchor-setting into SLD-anchor-numbers\n   */\n  getSldAnchorPointFromAnchor(anchor: TextSymbolizer['anchor'], dimension: 'x' | 'y'): number {\n    if (!anchor || isGeoStylerFunction(anchor)) {\n      return 0;\n    }\n    // As explained in https://docs.geoserver.org/main/en/user/styling/sld/reference/labeling.html#anchorpoint,\n    // we have the following translation for anchors:\n    // x-dimension\n    //   left -> 0.0\n    //   center -> 0.5\n    //   right -> 1.0\n    // y-dimension\n    //   top -> 1.0\n    //   middle -> 0.5\n    //   bottom -> 0.0\n\n    if (dimension === 'x') {\n      if (anchor.indexOf('left') >= 0) {\n        return 0.0;\n      }\n      else if (anchor.indexOf('right') >= 0) {\n        return 1.0;\n      }\n      else {\n        return 0.5;\n      }\n    }\n    else {\n      if (anchor.indexOf('bottom') >= 0) {\n        return 0.0;\n      }\n      else if (anchor.indexOf('top') >= 0) {\n        return 1.0;\n      }\n      else {\n        return 0.5;\n      }\n    }\n  }\n\n  /**\n   * Translates a SLD-anchor-number into a geostyler anchor-setting\n   */\n  getAnchorFromSldAnchorPoint(anchorX: any, anchorY: any): TextSymbolizer['anchor'] | undefined {\n\n    if (!isNumber(anchorX) || !isNumber(anchorY)) {\n      return undefined;\n    }\n    // see comment in getSldAnchorPointFromAnchor\n\n    const gsAnchorHoriz = anchorX < 0.25 ? 'left' : anchorX > 0.75 ? 'right' : '';\n    const gsAnchorVert = anchorY < 0.25 ? 'bottom' : anchorY > 0.75 ? 'top' : '';\n    const gsAnchor: TextSymbolizer['anchor'] = ((gsAnchorHoriz && gsAnchorVert) ?\n      (gsAnchorVert + '-' +gsAnchorHoriz) : (gsAnchorVert + gsAnchorHoriz)) as TextSymbolizer['anchor'];\n\n    // for not breaking existing tests like \"can read the geoserver popshade.sld\", we treat\n    // a center anchor as the default and deliver undefined in this case (instead of 'center')\n    return gsAnchor ? gsAnchor : undefined;\n  }\n\n  /**\n   * Get the SLD Object (readable with fast-xml-parser) from a geostyler-style TextSymbolizer.\n   *\n   * @param textSymbolizer A geostyler-style TextSymbolizer.\n   * @return The object representation of a SLD TextSymbolizer (readable with fast-xml-parser)\n   */\n  getSldTextSymbolizerFromTextSymbolizer(textSymbolizer: TextSymbolizer): any {\n    const CssParameter = this.getTagName('CssParameter');\n    const Fill = this.getTagName('Fill');\n    const Halo = this.getTagName('Halo');\n    const Font = this.getTagName('Font');\n    const Displacement = this.getTagName('Displacement');\n    const DisplacementX = this.getTagName('DisplacementX');\n    const DisplacementY = this.getTagName('DisplacementY');\n    const AnchorPoint = this.getTagName('AnchorPoint');\n    const AnchorPointX = this.getTagName('AnchorPointX');\n    const AnchorPointY = this.getTagName('AnchorPointY');\n    const LabelPlacement = this.getTagName('LabelPlacement');\n    const PointPlacement = this.getTagName('PointPlacement');\n    const LinePlacement = this.getTagName('LinePlacement');\n    const Rotation = this.getTagName('Rotation');\n    const Radius = this.getTagName('Radius');\n    const Label = this.getTagName('Label');\n    const PerpendicularOffset = this.getTagName('PerpendicularOffset');\n    const IsRepeated = this.getTagName('IsRepeated');\n    const Gap = this.getTagName('Gap');\n\n    const sldTextSymbolizer: any = [{\n      [Label]: textSymbolizer.label ? this.getSldLabelFromTextSymbolizer(textSymbolizer.label) : undefined\n    }];\n\n    const fontPropertyMap = {\n      font: 'font-family',\n      size: 'font-size',\n      fontStyle: 'font-style',\n      fontWeight: 'font-weight'\n    };\n\n    const fontCssParameters: any[] = Object.keys(textSymbolizer)\n      .filter((property: any) => property !== 'kind' && fontPropertyMap[property as keyof typeof fontPropertyMap])\n      .map((property: any) => {\n        if (isGeoStylerFunction(textSymbolizer[property as keyof typeof fontPropertyMap])) {\n          const children = geoStylerFunctionToSldFunction(textSymbolizer[\n            property as keyof typeof textSymbolizer] as GeoStylerFunction);\n          return {\n            [CssParameter]: children,\n            ':@': {\n              '@_name': fontPropertyMap[property as keyof typeof fontPropertyMap]\n            }\n          };\n        } else {\n          return {\n            [CssParameter]: [{\n              '#text': property === 'font'\n                ? (textSymbolizer[property as keyof typeof textSymbolizer] as any[])?.[0]\n                : textSymbolizer[property as keyof typeof textSymbolizer],\n            }],\n            ':@': {\n              '@_name': fontPropertyMap[property as keyof typeof fontPropertyMap]\n            }\n          };\n        }\n      });\n\n    if (fontCssParameters.length > 0) {\n      sldTextSymbolizer.push({\n        [Font]: fontCssParameters\n      });\n    }\n\n    if (textSymbolizer.placement === 'line') {\n      const linePlacement: any = [];\n\n      if (textSymbolizer.perpendicularOffset !== undefined) {\n        if (isGeoStylerFunction(textSymbolizer.perpendicularOffset)) {\n          const children = geoStylerFunctionToSldFunction(textSymbolizer.perpendicularOffset);\n          linePlacement.push({\n            [PerpendicularOffset]: children\n          });\n        } else {\n          linePlacement.push({\n            [PerpendicularOffset]: [{\n              '#text': textSymbolizer.perpendicularOffset.toString()\n            }]\n          });\n        }\n      }\n\n      // According to SLD 1.1 specification, isRepeated does not\n      // support expressions, whereas Gap does.\n      if (this.sldVersion === '1.1.0' && textSymbolizer.repeat !== undefined) {\n        linePlacement.push({\n          [IsRepeated]: [{\n            '#text': true\n          }]\n        });\n        if (isGeoStylerFunction(textSymbolizer.repeat)) {\n          const children = geoStylerFunctionToSldFunction(textSymbolizer.repeat);\n          linePlacement.push({\n            [Gap]: children\n          });\n        } else {\n          linePlacement.push({\n            [Gap]: [{\n              '#text': textSymbolizer.repeat.toString()\n            }]\n          });\n        }\n      }\n\n      sldTextSymbolizer.push({\n        [LabelPlacement]: [{\n          [LinePlacement]: linePlacement\n        }]\n      });\n    } else if (Number.isFinite(textSymbolizer.offset)\n      || textSymbolizer.anchor\n      || textSymbolizer.rotate !== undefined\n      || textSymbolizer.placement === 'point'\n    ) {\n      const pointPlacement: any = [];\n      if (textSymbolizer.offset) {\n        pointPlacement.push({\n          [Displacement]: [{\n            [DisplacementX]: [{\n              '#text': textSymbolizer.offset[0].toString()\n            }]\n          }, {\n            [DisplacementY]: [{\n              '#text': (-textSymbolizer.offset[1]).toString()\n            }]\n          }]\n        });\n      }\n      if (textSymbolizer.anchor) {\n        pointPlacement.push({\n          [AnchorPoint]: [{\n            [AnchorPointX]: [{\n              '#text': this.getSldAnchorPointFromAnchor(textSymbolizer.anchor,'x').toString()\n            }]\n          }, {\n            [AnchorPointY]: [{\n              '#text': this.getSldAnchorPointFromAnchor(textSymbolizer.anchor,'y').toString()\n            }]\n          }]\n        });\n      }\n      if (textSymbolizer.rotate !== undefined) {\n        pointPlacement.push({\n          [Rotation]: [{\n            '#text': textSymbolizer.rotate.toString()\n          }]\n        });\n      }\n      sldTextSymbolizer.push({\n        [LabelPlacement]: [{\n          [PointPlacement]: pointPlacement\n        }]\n      });\n    }\n\n    if (Number.isFinite(textSymbolizer.haloWidth) || textSymbolizer.haloColor) {\n      const halo: any = [];\n      const haloFillCssParameter = [];\n      if (textSymbolizer.haloWidth) {\n        halo.push({\n          [Radius]: [{\n            '#text': textSymbolizer.haloWidth.toString()\n          }]\n        });\n      }\n      if (textSymbolizer.haloColor) {\n        haloFillCssParameter.push({\n          [CssParameter]: [{\n            '#text': textSymbolizer.haloColor,\n          }],\n          ':@': {\n            '@_name': 'fill'\n          }\n        });\n      }\n      if (textSymbolizer.haloOpacity) {\n        haloFillCssParameter.push({\n          [CssParameter]: [{\n            '#text': textSymbolizer.haloOpacity,\n          }],\n          ':@': {\n            '@_name': 'fill-opacity'\n          }\n        });\n      }\n      if (haloFillCssParameter.length > 0) {\n        halo.push({\n          [Fill]: haloFillCssParameter\n        });\n      }\n      sldTextSymbolizer.push({\n        [Halo]: halo\n      });\n    }\n    if (textSymbolizer.color || Number.isFinite(textSymbolizer.opacity)) {\n      const fill = [{\n        [CssParameter]: [{\n          '#text': textSymbolizer.color || '#000000',\n        }],\n        ':@': {\n          '@_name': 'fill'\n        }\n      }];\n      if (Number.isFinite(textSymbolizer.opacity)) {\n        fill.push({\n          [CssParameter]: [{\n            '#text': `${textSymbolizer.opacity}`,\n          }],\n          ':@': {\n            '@_name': 'fill-opacity'\n          },\n        });\n      }\n      sldTextSymbolizer.push({\n        [Fill]: fill\n      });\n    }\n\n    this.addUomEntry(sldTextSymbolizer, textSymbolizer.sizeUnit);\n\n    return sldTextSymbolizer;\n  }\n\n  /**\n   * Get the Label from a TextSymbolizer\n   *\n   * @param template The Expression<string> representing the label\n   */\n  getSldLabelFromTextSymbolizer = (template: Expression<string>): any => {\n    if (isString(template))\n    {\n      const openingBraces = '{{';\n      const closingBraces = '}}';\n\n      const tokens = [];\n      let templateReducer = template;\n\n      while (templateReducer.length) {\n        let tmpTemplateReducer = templateReducer;\n        let tmpPreTemplateLiteral;\n        const openingBracesIdx = tmpTemplateReducer.indexOf(openingBraces);\n        if (openingBracesIdx === -1) {\n          if (templateReducer.includes(' ')) {\n            tokens.push({\n              'ogc:Literal': [{\n                '#cdata': [{\n                  '#text': templateReducer\n                }]\n              }]\n            });\n          } else {\n            tokens.push({\n              'ogc:Literal': [{\n                '#text': templateReducer\n              }]\n            });\n          }\n          break;\n        }\n\n        if (openingBracesIdx > 0) {\n          tmpPreTemplateLiteral = tmpTemplateReducer.slice(0, openingBracesIdx);\n        }\n        tmpTemplateReducer = tmpTemplateReducer.slice(openingBracesIdx + openingBraces.length);\n\n        const closingBracesIdx = tmpTemplateReducer.indexOf(closingBraces);\n        if (closingBracesIdx === -1) {\n          if (templateReducer.includes(' ')) {\n            tokens.push({\n              'ogc:Literal': [{\n                '#cdata': [{\n                  '#text': templateReducer\n                }]\n              }]\n            });\n          } else {\n            tokens.push({\n              'ogc:Literal': [{\n                '#text': templateReducer\n              }]\n            });\n          }\n          break;\n        }\n        const propertyName = tmpTemplateReducer.slice(0, closingBracesIdx);\n        tmpTemplateReducer = tmpTemplateReducer.slice(closingBracesIdx + closingBraces.length);\n        if (tmpPreTemplateLiteral) {\n          if (tmpPreTemplateLiteral.includes(' ')) {\n            tokens.push({\n              'ogc:Literal': [{\n                '#cdata': [{\n                  '#text': tmpPreTemplateLiteral\n                }]\n              }]\n            });\n          } else {\n            tokens.push({\n              'ogc:Literal': [{\n                '#text': tmpPreTemplateLiteral\n              }]\n            });\n          }\n        }\n        tokens.push({\n          'ogc:PropertyName': [{\n            '#text': propertyName\n          }]\n        });\n        templateReducer = tmpTemplateReducer;\n      }\n\n      return tokens;\n    }\n    // parse other GeoStylerFunction\n    return this.geoStylerFunctionToSldFunctionRecursive(template);\n  };\n\n  /**\n * Recursively converts a GeoStylerFunction (including nested) to SLD function structure.\n */\n  private geoStylerFunctionToSldFunctionRecursive(func: any): any {\n    if (func === null) {\n      return func;\n    }\n\n    // Literal at root\n    if (typeof func === 'string' || typeof func === 'number' || typeof func === 'boolean') {\n      return {\n        'ogc:Literal': [\n          { '#text': func }\n        ]\n      };\n    }\n\n    if (typeof func === 'object') {\n    // Finding functions such as 'greaterThan', 'numberFormat', 'if_then_else' etc.\n      if (typeof func.name === 'string' || Array.isArray(func.args)) {\n        const sldArgs = func.args.map((arg: any) => {\n          // Property function\n          if (\n            typeof arg === 'object' &&\n        arg !== null &&\n        arg.name === 'property' &&\n        Array.isArray(arg.args)\n          ) {\n            return {\n              'ogc:PropertyName': [\n                { '#text': arg.args[0] }\n              ]\n            };\n          }\n          // Nested function\n          if (\n            typeof arg === 'object' &&\n        arg !== null &&\n        typeof arg.name === 'string' &&\n        Array.isArray(arg.args)\n          ) {\n            //  Another function such as 'greaterThan', 'numberFormat' in the above function such as 'if_then_else'\n            return this.geoStylerFunctionToSldFunctionRecursive(arg)[0];\n          }\n          // Literal value\n          if (typeof arg === 'string' || typeof arg === 'number' || typeof arg === 'boolean') {\n            return {\n              'ogc:Literal': [\n                { '#text': arg }\n              ]\n            };\n          }\n          // Already SLD or unknown\n          return arg;\n        });\n        return [{\n          'ogc:Function': sldArgs,\n          ':@': { '@_name': func.name }\n        }];\n      }\n      // Property function at root\n      if (\n        func.name === 'property' &&\n      Array.isArray(func.args)\n      ) {\n        return {\n          'ogc:PropertyName': [\n            { '#text': func.args[0] }\n          ]\n        };\n      }\n    }\n\n    // Already SLD or unknown\n    return func;\n  }\n\n  /**\n   * Get the SLD Object (readable with fast-xml-parser) from a geostyler-style LineSymbolizer.\n   *\n   * @param lineSymbolizer A geostyler-style LineSymbolizer.\n   * @return The object representation of a SLD LineSymbolizer (readable with fast-xml-parser)\n   */\n  getSldLineSymbolizerFromLineSymbolizer(lineSymbolizer: LineSymbolizer): any[] {\n    const CssParameter = this.getTagName('CssParameter');\n    const Stroke = this.getTagName('Stroke');\n    const GraphicStroke = this.getTagName('GraphicStroke');\n    const GraphicFill = this.getTagName('GraphicFill');\n    const PerpendicularOffset = this.getTagName('PerpendicularOffset');\n\n    const propertyMap = {\n      color: 'stroke',\n      width: 'stroke-width',\n      opacity: 'stroke-opacity',\n      join: 'stroke-linejoin',\n      cap: 'stroke-linecap',\n      dasharray: 'stroke-dasharray',\n      dashOffset: 'stroke-dashoffset'\n    };\n\n    const sldLineSymbolizer: any = [];\n\n    const cssParameters: any[] = Object.keys(lineSymbolizer)\n      .filter((property: any) => property !== 'kind' && propertyMap[property as keyof typeof propertyMap] &&\n        lineSymbolizer[property as keyof typeof lineSymbolizer] !== undefined &&\n        lineSymbolizer[property as keyof typeof lineSymbolizer] !== null)\n      .map((property: any) => {\n        let value = lineSymbolizer[property as keyof typeof lineSymbolizer];\n        if (property === 'dasharray') {\n          value = lineSymbolizer.dasharray ? lineSymbolizer.dasharray.join(' ') : undefined;\n\n          return {\n            [CssParameter]: [{\n              '#text': value,\n            }],\n            ':@': {\n              '@_name': propertyMap[property as keyof typeof propertyMap]\n            }\n          };\n        }\n        // simple transformation since geostyler-style uses prop 'miter' whereas sld uses 'mitre'\n        if (property === 'join' && value === 'miter') {\n          value = 'mitre';\n        }\n\n        if (isGeoStylerFunction(lineSymbolizer[property as keyof typeof lineSymbolizer])) {\n          const children = geoStylerFunctionToSldFunction(lineSymbolizer[\n            property as keyof typeof lineSymbolizer] as GeoStylerFunction);\n          return {\n            [CssParameter]: children,\n            ':@': {\n              '@_name': propertyMap[property as keyof typeof propertyMap]\n            }\n          };\n        } else {\n          return {\n            [CssParameter]: [{\n              '#text': lineSymbolizer[property as keyof typeof lineSymbolizer],\n            }],\n            ':@': {\n              '@_name': propertyMap[property as keyof typeof propertyMap]\n            }\n          };\n        }\n\n      });\n\n    if (lineSymbolizer?.graphicStroke) {\n      if (!Array.isArray(sldLineSymbolizer?.[0]?.[Stroke])) {\n        sldLineSymbolizer[0] = { [Stroke]: [] };\n      }\n      if (lineSymbolizer?.graphicStroke?.kind === 'Mark') {\n        const graphicStroke = this.getSldPointSymbolizerFromMarkSymbolizer(lineSymbolizer.graphicStroke);\n        sldLineSymbolizer[0][Stroke].push({\n          [GraphicStroke]: graphicStroke\n        });\n      } else if (lineSymbolizer?.graphicStroke?.kind === 'Icon') {\n        const graphicStroke = this.getSldPointSymbolizerFromIconSymbolizer(lineSymbolizer.graphicStroke);\n        sldLineSymbolizer[0][Stroke].push({\n          [GraphicStroke]: graphicStroke\n        });\n      }\n    }\n\n    if (lineSymbolizer?.graphicFill) {\n      if (!Array.isArray(sldLineSymbolizer?.[0]?.[Stroke])) {\n        sldLineSymbolizer[0] = { [Stroke]: [] };\n      }\n      if (lineSymbolizer?.graphicFill?.kind === 'Mark') {\n        const graphicFill = this.getSldPointSymbolizerFromMarkSymbolizer(lineSymbolizer.graphicFill);\n        sldLineSymbolizer[0][Stroke].push({\n          [GraphicFill]: graphicFill\n        });\n      } else if (lineSymbolizer?.graphicFill?.kind === 'Icon') {\n        const graphicFill = this.getSldPointSymbolizerFromIconSymbolizer(lineSymbolizer.graphicFill);\n        sldLineSymbolizer[0][Stroke].push({\n          [GraphicFill]: graphicFill\n        });\n      }\n    }\n\n    if (cssParameters.length !== 0) {\n      if (!Array.isArray(sldLineSymbolizer?.[0]?.[Stroke])) {\n        sldLineSymbolizer[0] = { [Stroke]: [] };\n      }\n      sldLineSymbolizer[0][Stroke].push(...cssParameters);\n    }\n    if (lineSymbolizer.perpendicularOffset) {\n      sldLineSymbolizer.push({\n        [PerpendicularOffset]: [\n          {\n            '#text': lineSymbolizer.perpendicularOffset\n          }\n        ]\n      });\n    }\n\n    if (sldLineSymbolizer.length === 0) {\n      sldLineSymbolizer.push({\n        [Stroke]: {}\n      });\n    }\n\n    this.addUomEntry(sldLineSymbolizer, lineSymbolizer.widthUnit);\n\n    return sldLineSymbolizer;\n  }\n\n  /**\n   * Get the SLD Object (readable with fast-xml-parser) from a geostyler-style FillSymbolizer.\n   *\n   * @param fillSymbolizer A geostyler-style FillSymbolizer.\n   * @return The object representation of a SLD PolygonSymbolizer (readable with fast-xml-parser)\n   */\n  getSldPolygonSymbolizerFromFillSymbolizer(fillSymbolizer: FillSymbolizer): any {\n    const CssParameter = this.getTagName('CssParameter');\n    const Stroke = this.getTagName('Stroke');\n    const Fill = this.getTagName('Fill');\n    const strokePropertyMap = {\n      outlineColor: 'stroke',\n      outlineWidth: 'stroke-width',\n      outlineOpacity: 'stroke-opacity',\n      outlineDasharray: 'stroke-dasharray',\n      outlineCap: 'stroke-linecap',\n      outlineJoin: 'stroke-linejoin'\n    };\n    const fillPropertyMap = {\n      color: 'fill',\n      fillOpacity: 'fill-opacity'\n    };\n    const strokeCssParameters: any[] = [];\n    const fillCssParameters: any[] = [];\n    let graphicFill: any;\n\n    if (fillSymbolizer?.graphicFill) {\n      if (fillSymbolizer?.graphicFill.kind === 'Mark') {\n        graphicFill = this.getSldPointSymbolizerFromMarkSymbolizer(fillSymbolizer.graphicFill);\n      } else if (fillSymbolizer?.graphicFill.kind === 'Icon') {\n        graphicFill = this.getSldPointSymbolizerFromIconSymbolizer(fillSymbolizer.graphicFill);\n      }\n    }\n\n    Object.keys(fillSymbolizer)\n      .filter((property: any) => property !== 'kind')\n      .filter((property: any) => fillSymbolizer[property as keyof typeof fillSymbolizer] !== undefined &&\n        fillSymbolizer[property as keyof typeof fillSymbolizer] !== null)\n      .forEach((property: any) => {\n        if (Object.keys(fillPropertyMap).includes(property)) {\n          if (isGeoStylerFunction(fillSymbolizer[property as keyof typeof fillSymbolizer])) {\n            const children = geoStylerFunctionToSldFunction(fillSymbolizer[\n              property as keyof typeof fillSymbolizer] as GeoStylerFunction);\n            fillCssParameters.push({\n              [CssParameter]: children,\n              ':@': {\n                '@_name': fillPropertyMap[property as keyof typeof fillPropertyMap]\n              }\n            });\n          } else {\n            fillCssParameters.push({\n              [CssParameter]: [{\n                '#text': fillSymbolizer[property as keyof typeof fillSymbolizer],\n              }],\n              ':@': {\n                '@_name': fillPropertyMap[property as keyof typeof fillPropertyMap]\n              }\n            });\n          }\n        } else if (Object.keys(strokePropertyMap).includes(property)) {\n\n          let transformedValue: string = '';\n\n          if (property === 'outlineDasharray') {\n            const paramValue: number[] = fillSymbolizer[property as keyof typeof fillSymbolizer] as number[];\n            transformedValue = '';\n            paramValue.forEach((dash: number, idx) => {\n              transformedValue += dash;\n              if (idx < paramValue.length - 1) {\n                transformedValue += ' ';\n              }\n            });\n          } else if (property === 'outlineWidth') {\n            transformedValue = fillSymbolizer[property as keyof typeof fillSymbolizer] + '';\n          } else if (property === 'outlineOpacity') {\n            transformedValue = fillSymbolizer[property as keyof typeof fillSymbolizer] + '';\n          } else {\n            (transformedValue as any) = fillSymbolizer[property as keyof typeof fillSymbolizer];\n          }\n\n          if (isGeoStylerFunction(fillSymbolizer[property as keyof typeof fillSymbolizer])) {\n            const children = geoStylerFunctionToSldFunction((fillSymbolizer as any)[property]);\n            strokeCssParameters.push({\n              [CssParameter]: children,\n              ':@': {\n                '@_name': strokePropertyMap[property as keyof typeof strokePropertyMap]\n              }\n            });\n          } else {\n            strokeCssParameters.push({\n              [CssParameter]: [{\n                '#text': transformedValue,\n              }],\n              ':@': {\n                '@_name': strokePropertyMap[property as keyof typeof strokePropertyMap]\n              }\n            });\n          }\n\n        }\n      });\n\n    const polygonSymbolizer: any = [];\n    if (fillCssParameters.length > 0 || graphicFill) {\n      const fillArray: any[] = [];\n      const graphicFillPadding = fillSymbolizer.graphicFillPadding;\n      if (graphicFillPadding) {\n        this.pushGeoServerVendorOption(polygonSymbolizer, 'graphic-margin', graphicFillPadding.join(' '));\n      }\n      polygonSymbolizer.push({ [Fill]: fillArray });\n      if (graphicFill) {\n        fillArray.push({ [this.getTagName('GraphicFill')]: graphicFill });\n      }\n      if (fillCssParameters.length > 0) {\n        fillArray.push(...fillCssParameters);\n      }\n    }\n\n    if (strokeCssParameters.length > 0) {\n      polygonSymbolizer.push({\n        [Stroke]: strokeCssParameters\n      });\n    }\n\n    this.addUomEntry(polygonSymbolizer, fillSymbolizer.outlineWidthUnit);\n\n    return polygonSymbolizer;\n  }\n\n  /**\n   * Get the SLD Object (readable with fast-xml-parser) from a geostyler-style RasterSymbolizer.\n   *\n   * @param rasterSymbolizer A geostyler-style RasterSymbolizer.\n   * @return The object representation of a SLD RasterSymbolizer (readable with fast-xml-parser)\n   */\n  getSldRasterSymbolizerFromRasterSymbolizer(rasterSymbolizer: RasterSymbolizer): any {\n    const sldRasterSymbolizer: any = [];\n    if (rasterSymbolizer.opacity !== undefined) {\n      sldRasterSymbolizer.push({});\n      sldRasterSymbolizer[0].Opacity = [{\n        '#text': rasterSymbolizer.opacity\n      }];\n    }\n\n    let colorMap: any;\n    if (rasterSymbolizer.colorMap) {\n      colorMap = this.getSldColorMapFromColorMap(rasterSymbolizer.colorMap);\n      if (colorMap?.[0]) {\n        sldRasterSymbolizer.push({\n          ColorMap: colorMap\n        });\n      }\n    }\n\n    let channelSelection: any;\n    if (rasterSymbolizer.channelSelection) {\n      channelSelection = this.getSldChannelSelectionFromChannelSelection(rasterSymbolizer.channelSelection);\n      if (channelSelection?.[0]) {\n        sldRasterSymbolizer.push({\n          ChannelSelection: channelSelection\n        });\n      }\n    }\n\n    let contrastEnhancement: any;\n    if (rasterSymbolizer.contrastEnhancement) {\n      contrastEnhancement = this.getSldContrastEnhancementFromContrastEnhancement(rasterSymbolizer.contrastEnhancement);\n      if (contrastEnhancement?.[0]) {\n        sldRasterSymbolizer.push({\n          ContrastEnhancement: contrastEnhancement\n        });\n      }\n    }\n\n    return sldRasterSymbolizer;\n  }\n\n  /**\n   * Get the SLD Object (readable with fast-xml-parser) from a geostyler-style ColorMap.\n   *\n   * @param colorMap A geostyler-style ColorMap.\n   * @return The object representation of a SLD ColorMap (readable with fast-xml-parser)\n   */\n  getSldColorMapFromColorMap(colorMap: ColorMap): any {\n    const sldColorMap: any[] = [];\n    // parse colorMap.type\n    if (colorMap.type) {\n      const type = colorMap.type;\n      (sldColorMap as any)[':@'] = {\n        '@_type': type\n      };\n    }\n    // parse colorMap.extended\n    if (colorMap.extended !== undefined) {\n      const extended = colorMap.extended.toString();\n      if (!(sldColorMap as any)[':@']) {\n        (sldColorMap as any)[':@'] = {};\n      }\n      (sldColorMap as any)[':@']['@_extended'] = extended;\n    }\n    // parse colorMap.colorMapEntries\n    if (colorMap.colorMapEntries && colorMap.colorMapEntries.length > 0) {\n      const colorMapEntries: any[] = colorMap.colorMapEntries.map((entry: ColorMapEntry) => {\n        const result: any = {\n          ColorMapEntry: [],\n          ':@': {}\n        };\n        if (entry.color) {\n          result[':@']['@_color'] = entry.color;\n        }\n        if (typeof entry.quantity !== 'undefined') {\n          result[':@']['@_quantity'] = entry.quantity.toString();\n        }\n        if (entry.label) {\n          result[':@']['@_label'] = entry.label;\n        }\n        if (typeof entry.opacity !== 'undefined') {\n          result[':@']['@_opacity'] = entry.opacity.toString();\n        }\n        return result;\n        // remove empty colorMapEntries\n      }).filter((entry: any) => Object.keys(entry).length > 0);\n      sldColorMap.push(...colorMapEntries);\n    }\n    return sldColorMap;\n  }\n\n  /**\n   * Get the SLD Object (readable with fast-xml-parser) from a geostyler-style ChannelSelection.\n   *\n   * @param channelSelection A geostyler-style ChannelSelection.\n   * @return The object representation of a SLD ChannelSelection (readable with fast-xml-parser)\n   */\n  getSldChannelSelectionFromChannelSelection(channelSelection: ChannelSelection): any {\n    const propertyMap = {\n      redChannel: 'RedChannel',\n      blueChannel: 'BlueChannel',\n      greenChannel: 'GreenChannel',\n      grayChannel: 'GrayChannel'\n    };\n    const keys = Object.keys(channelSelection);\n    const sldChannelSelection: any[] = [];\n    keys.forEach((key: string) => {\n      const channel: any = [];\n      // parse sourceChannelName\n      const sourceChannelName = (channelSelection?.[key as keyof ChannelSelection] as any)?.sourceChannelName;\n      const channelName = propertyMap[key as keyof typeof propertyMap];\n      // parse contrastEnhancement\n      const contrastEnhancement = (channelSelection?.[key as keyof ChannelSelection] as any)?.contrastEnhancement;\n      if (sourceChannelName || contrastEnhancement) {\n        if (sourceChannelName) {\n          channel.push({\n            SourceChannelName: [{\n              '#text': sourceChannelName\n            }]\n          });\n        }\n        if (contrastEnhancement) {\n          channel.push({\n            ContrastEnhancement: this.getSldContrastEnhancementFromContrastEnhancement(contrastEnhancement)\n          });\n        }\n        sldChannelSelection.push({\n          [channelName]: channel\n        });\n      }\n    });\n\n    return sldChannelSelection;\n  }\n\n  /**\n     * Get the SLD Object (readable with fast-xml-parser) from a geostyler-style ContrastEnhancement.\n     *\n     * @param contrastEnhancement A geostyler-style ContrastEnhancement.\n     * @return The object representation of a SLD ContrastEnhancement (readable with fast-xml-parser)\n     */\n  getSldContrastEnhancementFromContrastEnhancement(contrastEnhancement: ContrastEnhancement): any {\n    const sldContrastEnhancement: any = [];\n    const enhancementType = contrastEnhancement?.enhancementType;\n    if (enhancementType === 'normalize') {\n      // parse normalize\n      sldContrastEnhancement.push({\n        Normalize: []\n      });\n    } else if (enhancementType === 'histogram') {\n      // parse histogram\n      sldContrastEnhancement.push({\n        Histogram: []\n      });\n    }\n    // parse gammaValue\n    if (contrastEnhancement.gammaValue !== undefined) {\n      sldContrastEnhancement.push({\n        GammaValue: [{\n          '#text': contrastEnhancement.gammaValue\n        }]\n      });\n    }\n    return sldContrastEnhancement;\n  }\n\n  checkForUnsupportedProperties(geoStylerStyle: Style): UnsupportedProperties | undefined {\n    const capitalizeFirstLetter = (a: string) => a[0].toUpperCase() + a.slice(1);\n    const unsupportedProperties: UnsupportedProperties = {};\n    geoStylerStyle.rules.forEach(rule => {\n      // ScaleDenominator and Filters are completely supported so we just check for symbolizers\n      rule.symbolizers.forEach(symbolizer => {\n        const key = capitalizeFirstLetter(`${symbolizer.kind}Symbolizer`);\n        const value = (this.unsupportedProperties?.Symbolizer as any)?.[key];\n        if (value) {\n          if (typeof value === 'string' || value instanceof String) {\n            if (!unsupportedProperties.Symbolizer) {\n              unsupportedProperties.Symbolizer = {};\n            }\n            (unsupportedProperties.Symbolizer as any)[key] = value;\n          } else {\n            Object.keys(symbolizer).forEach(property => {\n              if (value[property]) {\n                const propValue = new RegExp(`[\"']${symbolizer[property as keyof typeof symbolizer]}[\"']`);\n                if (value[property].support === 'partial' && (propValue.test(value[property].info)))\n                {\n                  return;\n                }\n                if (!unsupportedProperties.Symbolizer) {\n                  unsupportedProperties.Symbolizer = {};\n                }\n                if (!unsupportedProperties.Symbolizer[key as keyof typeof unsupportedProperties.Symbolizer]) {\n                  (unsupportedProperties.Symbolizer as any)[key] = {};\n                }\n                (unsupportedProperties.Symbolizer as any)[key][property] = value[property];\n              }\n            });\n          }\n        }\n      });\n    });\n    if (Object.keys(unsupportedProperties).length > 0) {\n      return unsupportedProperties;\n    }\n    return undefined;\n  }\n\n}\n\nexport default SldStyleParser;\n"]}