lit-xml/dist/index.cjs

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

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  InvalidXmlError: () => InvalidXmlError,
  XmlFragment: () => XmlFragment,
  createLitXml: () => createLitXml,
  validators: () => validators_exports,
  xml: () => xml
});
module.exports = __toCommonJS(src_exports);

// src/validators.ts
var validators_exports = {};
__export(validators_exports, {
  isWellFormed: () => isWellFormed
});
var import_fast_xml_parser = require("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 = import_fast_xml_parser.XMLValidator.validate(xml2);
  if (validationResult !== true) {
    throw new InvalidXmlError(validationResult.err.line, validationResult.err.msg, xml2);
  }
}

// src/xml-helpers.ts
var import_fast_xml_parser2 = require("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 import_fast_xml_parser2.XMLParser(fastXmlOptions).parse(xml2, fastXmlOptions);
    return new import_fast_xml_parser2.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();
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  InvalidXmlError,
  XmlFragment,
  createLitXml,
  validators,
  xml
});
//# sourceMappingURL=index.cjs.map