@fecp/designer 5.5.48 → 5.5.50

package/es/node_modules/saxen/dist/index.esm.mjs

@@ -0,0 +1,632 @@
+var fromCharCode = String.fromCharCode;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var ENTITY_PATTERN = /&#(\d+);|&#x([0-9a-f]+);|&(\w+);/ig;
+var ENTITY_MAPPING = {
+  "amp": "&",
+  "apos": "'",
+  "gt": ">",
+  "lt": "<",
+  "quot": '"'
+};
+Object.keys(ENTITY_MAPPING).forEach(function(k) {
+  ENTITY_MAPPING[k.toUpperCase()] = ENTITY_MAPPING[k];
+});
+function replaceEntities(_, d, x, z) {
+  if (z) {
+    if (hasOwnProperty.call(ENTITY_MAPPING, z)) {
+      return ENTITY_MAPPING[z];
+    } else {
+      return "&" + z + ";";
+    }
+  }
+  if (d) {
+    return fromCharCode(d);
+  }
+  return fromCharCode(parseInt(x, 16));
+}
+function decodeEntities(s) {
+  if (s.length > 3 && s.indexOf("&") !== -1) {
+    return s.replace(ENTITY_PATTERN, replaceEntities);
+  }
+  return s;
+}
+var XSI_URI = "http://www.w3.org/2001/XMLSchema-instance";
+var XSI_PREFIX = "xsi";
+var XSI_TYPE = "xsi:type";
+var NON_WHITESPACE_OUTSIDE_ROOT_NODE = "non-whitespace outside of root node";
+function error(msg) {
+  return new Error(msg);
+}
+function missingNamespaceForPrefix(prefix) {
+  return "missing namespace for prefix <" + prefix + ">";
+}
+function getter(getFn) {
+  return {
+    "get": getFn,
+    "enumerable": true
+  };
+}
+function cloneNsMatrix(nsMatrix) {
+  var clone = {}, key;
+  for (key in nsMatrix) {
+    clone[key] = nsMatrix[key];
+  }
+  return clone;
+}
+function uriPrefix(prefix) {
+  return prefix + "$uri";
+}
+function buildNsMatrix(nsUriToPrefix) {
+  var nsMatrix = {}, uri, prefix;
+  for (uri in nsUriToPrefix) {
+    prefix = nsUriToPrefix[uri];
+    nsMatrix[prefix] = prefix;
+    nsMatrix[uriPrefix(prefix)] = uri;
+  }
+  return nsMatrix;
+}
+function noopGetContext() {
+  return { "line": 0, "column": 0 };
+}
+function throwFunc(err) {
+  throw err;
+}
+function Parser(options) {
+  if (!this) {
+    return new Parser(options);
+  }
+  var proxy = options && options["proxy"];
+  var onText, onOpenTag, onCloseTag, onCDATA, onError = throwFunc, onWarning, onComment, onQuestion, onAttention;
+  var getContext = noopGetContext;
+  var maybeNS = false;
+  var isNamespace = false;
+  var returnError = null;
+  var parseStop = false;
+  var nsUriToPrefix;
+  function handleError(err) {
+    if (!(err instanceof Error)) {
+      err = error(err);
+    }
+    returnError = err;
+    onError(err, getContext);
+  }
+  function handleWarning(err) {
+    if (!onWarning) {
+      return;
+    }
+    if (!(err instanceof Error)) {
+      err = error(err);
+    }
+    onWarning(err, getContext);
+  }
+  this["on"] = function(name, cb) {
+    if (typeof cb !== "function") {
+      throw error("required args <name, cb>");
+    }
+    switch (name) {
+      case "openTag":
+        onOpenTag = cb;
+        break;
+      case "text":
+        onText = cb;
+        break;
+      case "closeTag":
+        onCloseTag = cb;
+        break;
+      case "error":
+        onError = cb;
+        break;
+      case "warn":
+        onWarning = cb;
+        break;
+      case "cdata":
+        onCDATA = cb;
+        break;
+      case "attention":
+        onAttention = cb;
+        break;
+      // <!XXXXX zzzz="eeee">
+      case "question":
+        onQuestion = cb;
+        break;
+      // <? ....  ?>
+      case "comment":
+        onComment = cb;
+        break;
+      default:
+        throw error("unsupported event: " + name);
+    }
+    return this;
+  };
+  this["ns"] = function(nsMap) {
+    if (typeof nsMap === "undefined") {
+      nsMap = {};
+    }
+    if (typeof nsMap !== "object") {
+      throw error("required args <nsMap={}>");
+    }
+    var _nsUriToPrefix = {}, k;
+    for (k in nsMap) {
+      _nsUriToPrefix[k] = nsMap[k];
+    }
+    _nsUriToPrefix[XSI_URI] = XSI_PREFIX;
+    isNamespace = true;
+    nsUriToPrefix = _nsUriToPrefix;
+    return this;
+  };
+  this["parse"] = function(xml) {
+    if (typeof xml !== "string") {
+      throw error("required args <xml=string>");
+    }
+    returnError = null;
+    parse(xml);
+    getContext = noopGetContext;
+    parseStop = false;
+    return returnError;
+  };
+  this["stop"] = function() {
+    parseStop = true;
+  };
+  function parse(xml) {
+    var nsMatrixStack = isNamespace ? [] : null, nsMatrix = isNamespace ? buildNsMatrix(nsUriToPrefix) : null, _nsMatrix, nodeStack = [], anonymousNsCount = 0, tagStart = false, tagEnd = false, i = 0, j = 0, x, y, q, w, v, xmlns, elementName, _elementName, elementProxy;
+    var attrsString = "", attrsStart = 0, cachedAttrs;
+    function getAttrs() {
+      if (cachedAttrs !== null) {
+        return cachedAttrs;
+      }
+      var nsUri, nsUriPrefix, nsName, defaultAlias = isNamespace && nsMatrix["xmlns"], attrList = isNamespace && maybeNS ? [] : null, i2 = attrsStart, s = attrsString, l = s.length, hasNewMatrix, newalias, value, alias, name, attrs = {}, seenAttrs = {}, skipAttr, w2, j2;
+      parseAttr:
+        for (; i2 < l; i2++) {
+          skipAttr = false;
+          w2 = s.charCodeAt(i2);
+          if (w2 === 32 || w2 < 14 && w2 > 8) {
+            continue;
+          }
+          if (w2 < 65 || w2 > 122 || w2 > 90 && w2 < 97) {
+            if (w2 !== 95 && w2 !== 58) {
+              handleWarning("illegal first char attribute name");
+              skipAttr = true;
+            }
+          }
+          for (j2 = i2 + 1; j2 < l; j2++) {
+            w2 = s.charCodeAt(j2);
+            if (w2 > 96 && w2 < 123 || w2 > 64 && w2 < 91 || w2 > 47 && w2 < 59 || w2 === 46 || // '.'
+            w2 === 45 || // '-'
+            w2 === 95) {
+              continue;
+            }
+            if (w2 === 32 || w2 < 14 && w2 > 8) {
+              handleWarning("missing attribute value");
+              i2 = j2;
+              continue parseAttr;
+            }
+            if (w2 === 61) {
+              break;
+            }
+            handleWarning("illegal attribute name char");
+            skipAttr = true;
+          }
+          name = s.substring(i2, j2);
+          if (name === "xmlns:xmlns") {
+            handleWarning("illegal declaration of xmlns");
+            skipAttr = true;
+          }
+          w2 = s.charCodeAt(j2 + 1);
+          if (w2 === 34) {
+            j2 = s.indexOf('"', i2 = j2 + 2);
+            if (j2 === -1) {
+              j2 = s.indexOf("'", i2);
+              if (j2 !== -1) {
+                handleWarning("attribute value quote missmatch");
+                skipAttr = true;
+              }
+            }
+          } else if (w2 === 39) {
+            j2 = s.indexOf("'", i2 = j2 + 2);
+            if (j2 === -1) {
+              j2 = s.indexOf('"', i2);
+              if (j2 !== -1) {
+                handleWarning("attribute value quote missmatch");
+                skipAttr = true;
+              }
+            }
+          } else {
+            handleWarning("missing attribute value quotes");
+            skipAttr = true;
+            for (j2 = j2 + 1; j2 < l; j2++) {
+              w2 = s.charCodeAt(j2 + 1);
+              if (w2 === 32 || w2 < 14 && w2 > 8) {
+                break;
+              }
+            }
+          }
+          if (j2 === -1) {
+            handleWarning("missing closing quotes");
+            j2 = l;
+            skipAttr = true;
+          }
+          if (!skipAttr) {
+            value = s.substring(i2, j2);
+          }
+          i2 = j2;
+          for (; j2 + 1 < l; j2++) {
+            w2 = s.charCodeAt(j2 + 1);
+            if (w2 === 32 || w2 < 14 && w2 > 8) {
+              break;
+            }
+            if (i2 === j2) {
+              handleWarning("illegal character after attribute end");
+              skipAttr = true;
+            }
+          }
+          i2 = j2 + 1;
+          if (skipAttr) {
+            continue parseAttr;
+          }
+          if (name in seenAttrs) {
+            handleWarning("attribute <" + name + "> already defined");
+            continue;
+          }
+          seenAttrs[name] = true;
+          if (!isNamespace) {
+            attrs[name] = value;
+            continue;
+          }
+          if (maybeNS) {
+            newalias = name === "xmlns" ? "xmlns" : name.charCodeAt(0) === 120 && name.substr(0, 6) === "xmlns:" ? name.substr(6) : null;
+            if (newalias !== null) {
+              nsUri = decodeEntities(value);
+              nsUriPrefix = uriPrefix(newalias);
+              alias = nsUriToPrefix[nsUri];
+              if (!alias) {
+                if (newalias === "xmlns" || nsUriPrefix in nsMatrix && nsMatrix[nsUriPrefix] !== nsUri) {
+                  do {
+                    alias = "ns" + anonymousNsCount++;
+                  } while (typeof nsMatrix[alias] !== "undefined");
+                } else {
+                  alias = newalias;
+                }
+                nsUriToPrefix[nsUri] = alias;
+              }
+              if (nsMatrix[newalias] !== alias) {
+                if (!hasNewMatrix) {
+                  nsMatrix = cloneNsMatrix(nsMatrix);
+                  hasNewMatrix = true;
+                }
+                nsMatrix[newalias] = alias;
+                if (newalias === "xmlns") {
+                  nsMatrix[uriPrefix(alias)] = nsUri;
+                  defaultAlias = alias;
+                }
+                nsMatrix[nsUriPrefix] = nsUri;
+              }
+              attrs[name] = value;
+              continue;
+            }
+            attrList.push(name, value);
+            continue;
+          }
+          w2 = name.indexOf(":");
+          if (w2 === -1) {
+            attrs[name] = value;
+            continue;
+          }
+          if (!(nsName = nsMatrix[name.substring(0, w2)])) {
+            handleWarning(missingNamespaceForPrefix(name.substring(0, w2)));
+            continue;
+          }
+          name = defaultAlias === nsName ? name.substr(w2 + 1) : nsName + name.substr(w2);
+          if (name === XSI_TYPE) {
+            w2 = value.indexOf(":");
+            if (w2 !== -1) {
+              nsName = value.substring(0, w2);
+              nsName = nsMatrix[nsName] || nsName;
+              value = nsName + value.substring(w2);
+            } else {
+              value = defaultAlias + ":" + value;
+            }
+          }
+          attrs[name] = value;
+        }
+      if (maybeNS) {
+        for (i2 = 0, l = attrList.length; i2 < l; i2++) {
+          name = attrList[i2++];
+          value = attrList[i2];
+          w2 = name.indexOf(":");
+          if (w2 !== -1) {
+            if (!(nsName = nsMatrix[name.substring(0, w2)])) {
+              handleWarning(missingNamespaceForPrefix(name.substring(0, w2)));
+              continue;
+            }
+            name = defaultAlias === nsName ? name.substr(w2 + 1) : nsName + name.substr(w2);
+            if (name === XSI_TYPE) {
+              w2 = value.indexOf(":");
+              if (w2 !== -1) {
+                nsName = value.substring(0, w2);
+                nsName = nsMatrix[nsName] || nsName;
+                value = nsName + value.substring(w2);
+              } else {
+                value = defaultAlias + ":" + value;
+              }
+            }
+          }
+          attrs[name] = value;
+        }
+      }
+      return cachedAttrs = attrs;
+    }
+    function getParseContext() {
+      var splitsRe = /(\r\n|\r|\n)/g;
+      var line = 0;
+      var column = 0;
+      var startOfLine = 0;
+      var endOfLine = j;
+      var match;
+      var data;
+      while (i >= startOfLine) {
+        match = splitsRe.exec(xml);
+        if (!match) {
+          break;
+        }
+        endOfLine = match[0].length + match.index;
+        if (endOfLine > i) {
+          break;
+        }
+        line += 1;
+        startOfLine = endOfLine;
+      }
+      if (i == -1) {
+        column = endOfLine;
+        data = xml.substring(j);
+      } else if (j === 0) {
+        data = xml.substring(j, i);
+      } else {
+        column = i - startOfLine;
+        data = j == -1 ? xml.substring(i) : xml.substring(i, j + 1);
+      }
+      return {
+        "data": data,
+        "line": line,
+        "column": column
+      };
+    }
+    getContext = getParseContext;
+    if (proxy) {
+      elementProxy = Object.create({}, {
+        "name": getter(function() {
+          return elementName;
+        }),
+        "originalName": getter(function() {
+          return _elementName;
+        }),
+        "attrs": getter(getAttrs),
+        "ns": getter(function() {
+          return nsMatrix;
+        })
+      });
+    }
+    while (j !== -1) {
+      if (xml.charCodeAt(j) === 60) {
+        i = j;
+      } else {
+        i = xml.indexOf("<", j);
+      }
+      if (i === -1) {
+        if (nodeStack.length) {
+          return handleError("unexpected end of file");
+        }
+        if (j === 0) {
+          return handleError("missing start tag");
+        }
+        if (j < xml.length) {
+          if (xml.substring(j).trim()) {
+            handleWarning(NON_WHITESPACE_OUTSIDE_ROOT_NODE);
+          }
+        }
+        return;
+      }
+      if (j !== i) {
+        if (nodeStack.length) {
+          if (onText) {
+            onText(xml.substring(j, i), decodeEntities, getContext);
+            if (parseStop) {
+              return;
+            }
+          }
+        } else {
+          if (xml.substring(j, i).trim()) {
+            handleWarning(NON_WHITESPACE_OUTSIDE_ROOT_NODE);
+            if (parseStop) {
+              return;
+            }
+          }
+        }
+      }
+      w = xml.charCodeAt(i + 1);
+      if (w === 33) {
+        q = xml.charCodeAt(i + 2);
+        if (q === 91 && xml.substr(i + 3, 6) === "CDATA[") {
+          j = xml.indexOf("]]>", i);
+          if (j === -1) {
+            return handleError("unclosed cdata");
+          }
+          if (onCDATA) {
+            onCDATA(xml.substring(i + 9, j), getContext);
+            if (parseStop) {
+              return;
+            }
+          }
+          j += 3;
+          continue;
+        }
+        if (q === 45 && xml.charCodeAt(i + 3) === 45) {
+          j = xml.indexOf("-->", i);
+          if (j === -1) {
+            return handleError("unclosed comment");
+          }
+          if (onComment) {
+            onComment(xml.substring(i + 4, j), decodeEntities, getContext);
+            if (parseStop) {
+              return;
+            }
+          }
+          j += 3;
+          continue;
+        }
+      }
+      if (w === 63) {
+        j = xml.indexOf("?>", i);
+        if (j === -1) {
+          return handleError("unclosed question");
+        }
+        if (onQuestion) {
+          onQuestion(xml.substring(i, j + 2), getContext);
+          if (parseStop) {
+            return;
+          }
+        }
+        j += 2;
+        continue;
+      }
+      for (x = i + 1; ; x++) {
+        v = xml.charCodeAt(x);
+        if (isNaN(v)) {
+          j = -1;
+          return handleError("unclosed tag");
+        }
+        if (v === 34) {
+          q = xml.indexOf('"', x + 1);
+          x = q !== -1 ? q : x;
+        } else if (v === 39) {
+          q = xml.indexOf("'", x + 1);
+          x = q !== -1 ? q : x;
+        } else if (v === 62) {
+          j = x;
+          break;
+        }
+      }
+      if (w === 33) {
+        if (onAttention) {
+          onAttention(xml.substring(i, j + 1), decodeEntities, getContext);
+          if (parseStop) {
+            return;
+          }
+        }
+        j += 1;
+        continue;
+      }
+      cachedAttrs = {};
+      if (w === 47) {
+        tagStart = false;
+        tagEnd = true;
+        if (!nodeStack.length) {
+          return handleError("missing open tag");
+        }
+        x = elementName = nodeStack.pop();
+        q = i + 2 + x.length;
+        if (xml.substring(i + 2, q) !== x) {
+          return handleError("closing tag mismatch");
+        }
+        for (; q < j; q++) {
+          w = xml.charCodeAt(q);
+          if (w === 32 || w > 8 && w < 14) {
+            continue;
+          }
+          return handleError("close tag");
+        }
+      } else {
+        if (xml.charCodeAt(j - 1) === 47) {
+          x = elementName = xml.substring(i + 1, j - 1);
+          tagStart = true;
+          tagEnd = true;
+        } else {
+          x = elementName = xml.substring(i + 1, j);
+          tagStart = true;
+          tagEnd = false;
+        }
+        if (!(w > 96 && w < 123 || w > 64 && w < 91 || w === 95 || w === 58)) {
+          return handleError("illegal first char nodeName");
+        }
+        for (q = 1, y = x.length; q < y; q++) {
+          w = x.charCodeAt(q);
+          if (w > 96 && w < 123 || w > 64 && w < 91 || w > 47 && w < 59 || w === 45 || w === 95 || w == 46) {
+            continue;
+          }
+          if (w === 32 || w < 14 && w > 8) {
+            elementName = x.substring(0, q);
+            cachedAttrs = null;
+            break;
+          }
+          return handleError("invalid nodeName");
+        }
+        if (!tagEnd) {
+          nodeStack.push(elementName);
+        }
+      }
+      if (isNamespace) {
+        _nsMatrix = nsMatrix;
+        if (tagStart) {
+          if (!tagEnd) {
+            nsMatrixStack.push(_nsMatrix);
+          }
+          if (cachedAttrs === null) {
+            if (maybeNS = x.indexOf("xmlns", q) !== -1) {
+              attrsStart = q;
+              attrsString = x;
+              getAttrs();
+              maybeNS = false;
+            }
+          }
+        }
+        _elementName = elementName;
+        w = elementName.indexOf(":");
+        if (w !== -1) {
+          xmlns = nsMatrix[elementName.substring(0, w)];
+          if (!xmlns) {
+            return handleError("missing namespace on <" + _elementName + ">");
+          }
+          elementName = elementName.substr(w + 1);
+        } else {
+          xmlns = nsMatrix["xmlns"];
+        }
+        if (xmlns) {
+          elementName = xmlns + ":" + elementName;
+        }
+      }
+      if (tagStart) {
+        attrsStart = q;
+        attrsString = x;
+        if (onOpenTag) {
+          if (proxy) {
+            onOpenTag(elementProxy, decodeEntities, tagEnd, getContext);
+          } else {
+            onOpenTag(elementName, getAttrs, decodeEntities, tagEnd, getContext);
+          }
+          if (parseStop) {
+            return;
+          }
+        }
+      }
+      if (tagEnd) {
+        if (onCloseTag) {
+          onCloseTag(proxy ? elementProxy : elementName, decodeEntities, tagStart, getContext);
+          if (parseStop) {
+            return;
+          }
+        }
+        if (isNamespace) {
+          if (!tagStart) {
+            nsMatrix = nsMatrixStack.pop();
+          } else {
+            nsMatrix = _nsMatrix;
+          }
+        }
+      }
+      j += 1;
+    }
+  }
+}
+export {
+  Parser,
+  decodeEntities as decode
+};