lit-xml/dist/index.js

Burning your XML documents to the ground? Yes please. In the mean time, let's use lit-xml.

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

// src/validators.ts
var validators_exports = {};
__export(validators_exports, {
  isWellFormed: () => isWellFormed
});
import { XMLValidator } from "fast-xml-parser";

// src/invalid-xml-error.ts
var InvalidXmlError = class extends Error {
  constructor(line, message, xmlDocument) {
    super(`Error on line ${line}: ${message}`);
    this.xmlDocument = xmlDocument;
  }
};

// src/validators.ts
function isWellFormed(xml2) {
  const validationResult = XMLValidator.validate(xml2);
  if (validationResult !== true) {
    throw new InvalidXmlError(validationResult.err.line, validationResult.err.msg, xml2);
  }
}

// src/xml-helpers.ts
import { XMLParser, XMLBuilder } from "fast-xml-parser";
function valueToString(value) {
  if (value instanceof XmlFragment) {
    return value.toStringRaw();
  }
  if (value === null) {
    return "null";
  }
  if (value === void 0) {
    return "";
  }
  if (isJsonSerializable(value)) {
    return sanitize(value.toJSON());
  }
  if (Array.isArray(value)) {
    return value.map(valueToString).join("");
  }
  return sanitize(value.toString());
}
function isJsonSerializable(value) {
  return Boolean(value) && typeof value.toJSON === "function";
}
var fastXmlOptions = {
  attributeNamePrefix: "",
  attributesGroupName: "$attr",
  //default is 'false'
  textNodeName: "#text",
  ignoreAttributes: false,
  removeNSPrefix: false,
  allowBooleanAttributes: false,
  suppressBooleanAttributes: false,
  parseTagValue: true,
  parseAttributeValue: false,
  trimValues: true,
  cdataPropName: "__cdata",
  //default is 'false'
  suppressEmptyNode: true
};
function format(xml2, { format: format2, indent }) {
  if (format2) {
    const indentBy = new Array(indent).fill(" ").join("");
    const xmlAsJson = new XMLParser(fastXmlOptions).parse(xml2, fastXmlOptions);
    return new XMLBuilder({ ...fastXmlOptions, format: format2, indentBy }).build(xmlAsJson);
  } else {
    return xml2;
  }
}
var XML_ESCAPE_MAP = Object.freeze({
  ["&"]: "&",
  ["'"]: "'",
  ['"']: """,
  ["<"]: "&lt;",
  [">"]: "&gt;"
});
var XML_SPECIAL_CHAR_REGEX = new RegExp(`([${Object.keys(XML_ESCAPE_MAP).join("")}])`, "g");
function sanitize(text) {
  return text.replace(XML_SPECIAL_CHAR_REGEX, (_match, char) => XML_ESCAPE_MAP[char]);
}

// src/xml-fragment.ts
var XmlFragment = class {
  constructor(xmlLiterals, values, options) {
    this.xmlLiterals = xmlLiterals;
    this.values = values;
    this.options = options;
  }
  toString() {
    const xml2 = this.toStringRaw();
    this.options.validators.forEach((validator) => validator(xml2));
    return format(xml2, this.options);
  }
  /**
   * @internal
   */
  toStringRaw() {
    let stringBuilder = "";
    for (let i = 0; i < this.values.length; i++) {
      stringBuilder = stringBuilder.concat(this.xmlLiterals[i], valueToString(this.values[i]));
    }
    return stringBuilder + this.xmlLiterals[this.xmlLiterals.length - 1];
  }
};

// src/create-lit-xml.ts
var DEFAULT_OPTIONS = {
  format: false,
  indent: 2,
  validators: [],
  strictTemplateValues: false
};
function createLitXml(overrideOptions) {
  const options = Object.freeze({ ...DEFAULT_OPTIONS, ...overrideOptions });
  return function xml2(xmlLiterals, ...values) {
    return new XmlFragment(xmlLiterals, values, options);
  };
}
createLitXml.inject = ["lit-xml-options"];
var xml = createLitXml();
export {
  InvalidXmlError,
  XmlFragment,
  createLitXml,
  validators_exports as validators,
  xml
};
//# sourceMappingURL=index.js.map