node-red-contrib-tak-registration 0.14.1 → 0.15.0

package/node_modules/fast-xml-parser/src/{v5 → v6}/valueParsers/EntitiesParser.js

@@ -13,11 +13,11 @@ const htmlEntities = {
     "copyright" : { regex: /&(copy|#169);/g, val: "©" },
     "reg" : { regex: /&(reg|#174);/g, val: "®" },
     "inr" : { regex: /&(inr|#8377);/g, val: "₹" },
-    "num_dec": { regex: /&#([0-9]{1,7});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 10)) },
-    "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 16)) },
+    "num_dec": { regex: /&#([0-9]{1,7});/g, val : (_, str) => String.fromCodePoint(Number.parseInt(str, 10)) },
+    "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val : (_, str) => String.fromCodePoint(Number.parseInt(str, 16)) },
 };
 
-class EntitiesParser{
+export default class EntitiesParser{
     constructor(replaceHtmlEntities) {
       this.replaceHtmlEntities = replaceHtmlEntities;
       this.docTypeEntities = {};
@@ -103,5 +103,3 @@ function validateEntityName(name){
     }
     return name;
 }
-
-module.exports = EntitiesParser;

package/node_modules/fast-xml-parser/src/{v5 → v6}/valueParsers/booleanParser.js

@@ -1,4 +1,4 @@
-class boolParser{
+export default class boolParser{
     constructor(trueList, falseList){
         if(trueList)
             this.trueList = trueList;
@@ -20,4 +20,3 @@ class boolParser{
         return val;
     }
 }
-module.exports = boolParser;

package/node_modules/fast-xml-parser/src/{v5 → v6}/valueParsers/booleanParserExt.js

@@ -1,4 +1,4 @@
-function boolParserExt(val){
+export default function boolParserExt(val){
     if(isArray(val)){
         for (let i = 0; i < val.length; i++) {
             val[i] = parse(val[i])
@@ -17,4 +17,3 @@ function parse(val){
     }
     return val;
 }
-module.exports = boolParserExt;

package/node_modules/fast-xml-parser/src/{v5 → v6}/valueParsers/currency.js

@@ -16,7 +16,7 @@ const symbol = "(?:\$|€|¥|₹)?";
 
 const currencyCheckRegex = /^\s*(?:-|\+)?(?:\d+|\d{1,3}(?:,\d{3})+)?(?:\.\d{1,2})?\s*(?:\$|€|¥|₹)?\s*$/u;
 
-class CurrencyParser{
+export default class CurrencyParser{
     constructor(options){
         this.options = options || defaultOptions;
     }
@@ -36,5 +36,3 @@ class CurrencyParser{
     }
 }
 CurrencyParser.defaultOptions = defaultOptions;
-
-module.exports = CurrencyParser;

package/node_modules/fast-xml-parser/src/{v5 → v6}/valueParsers/join.js

@@ -4,11 +4,10 @@
  * @param {string} by 
  * @returns 
  */
-function join(val, by=" "){
+export default function join(val, by=" "){
     if(isArray(val)){
         val.join(by)
     }
     return val;
 }
 
-module.exports = join;

package/node_modules/fast-xml-parser/src/{v5 → v6}/valueParsers/number.js

@@ -1,7 +1,7 @@
-const toNumber = require("strnum");
+import toNumber from "strnum";
 
 
-class numParser{
+export default class numParser{
     constructor(options){
         this.options = options;
     }
@@ -12,5 +12,3 @@ class numParser{
         return val;
     }
 }
-
-module.exports = numParser;

package/node_modules/fast-xml-parser/src/{v5 → v6}/valueParsers/trim.js

@@ -1,8 +1,6 @@
-class trimmer{
+export default class trimmer{
     parse(val){
         if(typeof val === "string") return val.trim();
         else return val;
     }
 }
-
-module.exports = trimmer;

package/node_modules/fast-xml-parser/src/validator.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const util = require('./util');
+import {getAllMatches, isName} from './util.js';
 
 const defaultOptions = {
   allowBooleanAttributes: false, //A tag can have attributes without any value
@@ -8,7 +8,7 @@ const defaultOptions = {
 };
 
 //const tagsPattern = new RegExp("<\\/?([\\w:\\-_\.]+)\\s*\/?>","g");
-exports.validate = function (xmlData, options) {
+export function validate(xmlData, options) {
   options = Object.assign({}, defaultOptions, options);
 
   //xmlData = xmlData.replace(/(\r\n|\n|\r)/gm,"");//make it single line
@@ -321,7 +321,7 @@ function validateAttributeString(attrStr, options) {
 
   //if(attrStr.trim().length === 0) return true; //empty string
 
-  const matches = util.getAllMatches(attrStr, validAttrStrRegxp);
+  const matches = getAllMatches(attrStr, validAttrStrRegxp);
   const attrNames = {};
 
   for (let i = 0; i < matches.length; i++) {
@@ -399,13 +399,13 @@ function getErrorObject(code, message, lineNumber) {
 }
 
 function validateAttrName(attrName) {
-  return util.isName(attrName);
+  return isName(attrName);
 }
 
 // const startsWithXML = /^xml/i;
 
 function validateTagName(tagname) {
-  return util.isName(tagname) /* && !tagname.match(startsWithXML) */;
+  return isName(tagname) /* && !tagname.match(startsWithXML) */;
 }
 
 //this function returns the line number for the character at the given index

package/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js

@@ -1,7 +1,7 @@
 'use strict';
 //parse Empty Node as self closing node
-const buildFromOrderedJs = require('./orderedJs2Xml');
-const getIgnoreAttributesFn = require('../ignoreAttributes')
+import buildFromOrderedJs from './orderedJs2Xml.js';
+import getIgnoreAttributesFn from "../ignoreAttributes.js";
 
 const defaultOptions = {
   attributeNamePrefix: '@_',
@@ -37,7 +37,7 @@ const defaultOptions = {
   oneListGroup: false
 };
 
-function Builder(options) {
+export default function Builder(options) {
   this.options = Object.assign({}, defaultOptions, options);
   if (this.options.ignoreAttributes === true || this.options.attributesGroupName) {
     this.isAttribute = function(/*a*/) {
@@ -92,6 +92,8 @@ Builder.prototype.j2x = function(jObj, level, ajPath) {
       // null attribute should be ignored by the attribute list, but should not cause the tag closing
       if (this.isAttribute(key)) {
         val += '';
+      } else if (key === this.options.cdataPropName) {
+        val += '';
       } else if (key[0] === '?') {
         val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;
       } else {
@@ -281,4 +283,3 @@ function isAttribute(name /*, options*/) {
   }
 }
 
-module.exports = Builder;

package/node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js

@@ -6,7 +6,7 @@ const EOL = "\n";
  * @param {any} options 
  * @returns 
  */
-function toXml(jArray, options) {
+export default function toXml(jArray, options) {
     let indentation = "";
     if (options.format && options.indentBy.length > 0) {
         indentation = EOL;
@@ -132,4 +132,3 @@ function replaceEntitiesValue(textValue, options) {
     }
     return textValue;
 }
-module.exports = toXml;

package/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js

@@ -1,7 +1,7 @@
-const util = require('../util');
+import {isName} from '../util.js';
 
 //TODO: handle comments
-function readDocType(xmlData, i){
+export default function readDocType(xmlData, i){
     
     const entities = {};
     if( xmlData[i + 3] === 'O' &&
@@ -17,21 +17,30 @@ function readDocType(xmlData, i){
         let exp = "";
         for(;i<xmlData.length;i++){
             if (xmlData[i] === '<' && !comment) { //Determine the tag type
-                if( hasBody && isEntity(xmlData, i)){
+                if( hasBody && hasSeq(xmlData, "!ENTITY",i)){
                     i += 7; 
                     let entityName, val;
                     [entityName, val,i] = readEntityExp(xmlData,i+1);
                     if(val.indexOf("&") === -1) //Parameter entities are not supported
-                        entities[ validateEntityName(entityName) ] = {
+                        entities[ entityName ] = {
                             regx : RegExp( `&${entityName};`,"g"),
                             val: val
                         };
                 }
-                else if( hasBody && isElement(xmlData, i))  i += 8;//Not supported
-                else if( hasBody && isAttlist(xmlData, i))  i += 8;//Not supported
-                else if( hasBody && isNotation(xmlData, i)) i += 9;//Not supported
-                else if( isComment)                         comment = true;
-                else                                        throw new Error("Invalid DOCTYPE");
+                else if( hasBody && hasSeq(xmlData, "!ELEMENT",i))  {
+                    i += 8;//Not supported
+                    const {index} = readElementExp(xmlData,i+1);
+                    i = index;
+                }else if( hasBody && hasSeq(xmlData, "!ATTLIST",i)){
+                    i += 8;//Not supported
+                    // const {index} = readAttlistExp(xmlData,i+1);
+                    // i = index;
+                }else if( hasBody && hasSeq(xmlData, "!NOTATION",i)) {
+                    i += 9;//Not supported
+                    const {index} = readNotationExp(xmlData,i+1);
+                    i = index;
+                }else if( hasSeq(xmlData, "!--",i) ) comment = true;
+                else throw new Error("Invalid DOCTYPE");
 
                 angleBracketsCount++;
                 exp = "";
@@ -62,7 +71,14 @@ function readDocType(xmlData, i){
     return {entities, i};
 }
 
-function readEntityExp(xmlData,i){
+const skipWhitespace = (data, index) => {
+    while (index < data.length && /\s/.test(data[index])) {
+        index++;
+    }
+    return index;
+};
+
+function readEntityExp(xmlData, i) {    
     //External entities are not supported
     //    <!ENTITY ext SYSTEM "http://normal-website.com" >
 
@@ -71,83 +87,283 @@ function readEntityExp(xmlData,i){
 
     //Internal entities are supported
     //    <!ENTITY entityname "replacement text">
-    
-    //read EntityName
+
+    // Skip leading whitespace after <!ENTITY
+    i = skipWhitespace(xmlData, i);
+
+    // Read entity name
     let entityName = "";
-    for (; i < xmlData.length && (xmlData[i] !== "'" && xmlData[i] !== '"' ); i++) {
-        // if(xmlData[i] === " ") continue;
-        // else 
+    while (i < xmlData.length && !/\s/.test(xmlData[i]) && xmlData[i] !== '"' && xmlData[i] !== "'") {
         entityName += xmlData[i];
+        i++;
     }
-    entityName = entityName.trim();
-    if(entityName.indexOf(" ") !== -1) throw new Error("External entites are not supported");
+    validateEntityName(entityName);
 
-    //read Entity Value
-    const startChar = xmlData[i++];
-    let val = ""
-    for (; i < xmlData.length && xmlData[i] !== startChar ; i++) {
-        val += xmlData[i];
+    // Skip whitespace after entity name
+    i = skipWhitespace(xmlData, i);
+
+    // Check for unsupported constructs (external entities or parameter entities)
+    if (xmlData.substring(i, i + 6).toUpperCase() === "SYSTEM") {
+        throw new Error("External entities are not supported");
+    }else if (xmlData[i] === "%") {
+        throw new Error("Parameter entities are not supported");
     }
-    return [entityName, val, i];
+
+    // Read entity value (internal entity)
+    let entityValue = "";
+    [i, entityValue] = readIdentifierVal(xmlData, i, "entity");
+    i--;
+    return [entityName, entityValue, i ];
 }
 
-function isComment(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === '-' &&
-    xmlData[i+3] === '-') return true
-    return false
+function readNotationExp(xmlData, i) {
+    // Skip leading whitespace after <!NOTATION
+    i = skipWhitespace(xmlData, i);
+
+    // Read notation name
+    let notationName = "";
+    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+        notationName += xmlData[i];
+        i++;
+    }
+    validateEntityName(notationName);
+
+    // Skip whitespace after notation name
+    i = skipWhitespace(xmlData, i);
+
+    // Check identifier type (SYSTEM or PUBLIC)
+    const identifierType = xmlData.substring(i, i + 6).toUpperCase();
+    if (identifierType !== "SYSTEM" && identifierType !== "PUBLIC") {
+        throw new Error(`Expected SYSTEM or PUBLIC, found "${identifierType}"`);
+    }
+    i += identifierType.length;
+
+    // Skip whitespace after identifier type
+    i = skipWhitespace(xmlData, i);
+
+    // Read public identifier (if PUBLIC)
+    let publicIdentifier = null;
+    let systemIdentifier = null;
+
+    if (identifierType === "PUBLIC") {
+        [i, publicIdentifier ] = readIdentifierVal(xmlData, i, "publicIdentifier");
+
+        // Skip whitespace after public identifier
+        i = skipWhitespace(xmlData, i);
+
+        // Optionally read system identifier
+        if (xmlData[i] === '"' || xmlData[i] === "'") {
+            [i, systemIdentifier ] = readIdentifierVal(xmlData, i,"systemIdentifier");
+        }
+    } else if (identifierType === "SYSTEM") {
+        // Read system identifier (mandatory for SYSTEM)
+        [i, systemIdentifier ] = readIdentifierVal(xmlData, i, "systemIdentifier");
+
+        if (!systemIdentifier) {
+            throw new Error("Missing mandatory system identifier for SYSTEM notation");
+        }
+    }
+    
+    return {notationName, publicIdentifier, systemIdentifier, index: --i};
 }
-function isEntity(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === 'E' &&
-    xmlData[i+3] === 'N' &&
-    xmlData[i+4] === 'T' &&
-    xmlData[i+5] === 'I' &&
-    xmlData[i+6] === 'T' &&
-    xmlData[i+7] === 'Y') return true
-    return false
+
+function readIdentifierVal(xmlData, i, type) {
+    let identifierVal = "";
+    const startChar = xmlData[i];
+    if (startChar !== '"' && startChar !== "'") {
+        throw new Error(`Expected quoted string, found "${startChar}"`);
+    }
+    i++;
+
+    while (i < xmlData.length && xmlData[i] !== startChar) {
+        identifierVal += xmlData[i];
+        i++;
+    }
+
+    if (xmlData[i] !== startChar) {
+        throw new Error(`Unterminated ${type} value`);
+    }
+    i++;
+    return [i, identifierVal];
 }
-function isElement(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === 'E' &&
-    xmlData[i+3] === 'L' &&
-    xmlData[i+4] === 'E' &&
-    xmlData[i+5] === 'M' &&
-    xmlData[i+6] === 'E' &&
-    xmlData[i+7] === 'N' &&
-    xmlData[i+8] === 'T') return true
-    return false
+
+function readElementExp(xmlData, i) {
+    // <!ELEMENT br EMPTY>
+    // <!ELEMENT div ANY>
+    // <!ELEMENT title (#PCDATA)>
+    // <!ELEMENT book (title, author+)>
+    // <!ELEMENT name (content-model)>
+    
+    // Skip leading whitespace after <!ELEMENT
+    i = skipWhitespace(xmlData, i);
+
+    // Read element name
+    let elementName = "";
+    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+        elementName += xmlData[i];
+        i++;
+    }
+
+    // Validate element name
+    if (!validateEntityName(elementName)) {
+        throw new Error(`Invalid element name: "${elementName}"`);
+    }
+
+    // Skip whitespace after element name
+    i = skipWhitespace(xmlData, i);
+    let contentModel = "";
+    // Expect '(' to start content model
+    if(xmlData[i] === "E" && hasSeq(xmlData, "MPTY",i)) i+=6;
+    else if(xmlData[i] === "A" && hasSeq(xmlData, "NY",i)) i+=4;
+    else if (xmlData[i] === "(") {
+        i++; // Move past '('
+
+        // Read content model
+        while (i < xmlData.length && xmlData[i] !== ")") {
+            contentModel += xmlData[i];
+            i++;
+        }
+        if (xmlData[i] !== ")") {
+            throw new Error("Unterminated content model");
+        }
+
+    }else{
+        throw new Error(`Invalid Element Expression, found "${xmlData[i]}"`);
+    }
+    
+    return {
+        elementName,
+        contentModel: contentModel.trim(),
+        index: i
+    };
 }
 
-function isAttlist(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === 'A' &&
-    xmlData[i+3] === 'T' &&
-    xmlData[i+4] === 'T' &&
-    xmlData[i+5] === 'L' &&
-    xmlData[i+6] === 'I' &&
-    xmlData[i+7] === 'S' &&
-    xmlData[i+8] === 'T') return true
-    return false
+function readAttlistExp(xmlData, i) {
+    // Skip leading whitespace after <!ATTLIST
+    i = skipWhitespace(xmlData, i);
+
+    // Read element name
+    let elementName = "";
+    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+        elementName += xmlData[i];
+        i++;
+    }
+
+    // Validate element name
+    validateEntityName(elementName)
+
+    // Skip whitespace after element name
+    i = skipWhitespace(xmlData, i);
+
+    // Read attribute name
+    let attributeName = "";
+    while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+        attributeName += xmlData[i];
+        i++;
+    }
+
+    // Validate attribute name
+    if (!validateEntityName(attributeName)) {
+        throw new Error(`Invalid attribute name: "${attributeName}"`);
+    }
+
+    // Skip whitespace after attribute name
+    i = skipWhitespace(xmlData, i);
+
+    // Read attribute type
+    let attributeType = "";
+    if (xmlData.substring(i, i + 8).toUpperCase() === "NOTATION") {
+        attributeType = "NOTATION";
+        i += 8; // Move past "NOTATION"
+
+        // Skip whitespace after "NOTATION"
+        i = skipWhitespace(xmlData, i);
+
+        // Expect '(' to start the list of notations
+        if (xmlData[i] !== "(") {
+            throw new Error(`Expected '(', found "${xmlData[i]}"`);
+        }
+        i++; // Move past '('
+
+        // Read the list of allowed notations
+        let allowedNotations = [];
+        while (i < xmlData.length && xmlData[i] !== ")") {
+            let notation = "";
+            while (i < xmlData.length && xmlData[i] !== "|" && xmlData[i] !== ")") {
+                notation += xmlData[i];
+                i++;
+            }
+
+            // Validate notation name
+            notation = notation.trim();
+            if (!validateEntityName(notation)) {
+                throw new Error(`Invalid notation name: "${notation}"`);
+            }
+
+            allowedNotations.push(notation);
+
+            // Skip '|' separator or exit loop
+            if (xmlData[i] === "|") {
+                i++; // Move past '|'
+                i = skipWhitespace(xmlData, i); // Skip optional whitespace after '|'
+            }
+        }
+
+        if (xmlData[i] !== ")") {
+            throw new Error("Unterminated list of notations");
+        }
+        i++; // Move past ')'
+
+        // Store the allowed notations as part of the attribute type
+        attributeType += " (" + allowedNotations.join("|") + ")";
+    } else {
+        // Handle simple types (e.g., CDATA, ID, IDREF, etc.)
+        while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+            attributeType += xmlData[i];
+            i++;
+        }
+
+        // Validate simple attribute type
+        const validTypes = ["CDATA", "ID", "IDREF", "IDREFS", "ENTITY", "ENTITIES", "NMTOKEN", "NMTOKENS"];
+        if (!validTypes.includes(attributeType.toUpperCase())) {
+            throw new Error(`Invalid attribute type: "${attributeType}"`);
+        }
+    }
+
+    // Skip whitespace after attribute type
+    i = skipWhitespace(xmlData, i);
+
+    // Read default value
+    let defaultValue = "";
+    if (xmlData.substring(i, i + 8).toUpperCase() === "#REQUIRED") {
+        defaultValue = "#REQUIRED";
+        i += 8;
+    } else if (xmlData.substring(i, i + 7).toUpperCase() === "#IMPLIED") {
+        defaultValue = "#IMPLIED";
+        i += 7;
+    } else {
+        [i, defaultValue] = readIdentifierVal(xmlData, i, "ATTLIST");
+    }
+
+    return {
+        elementName,
+        attributeName,
+        attributeType,
+        defaultValue,
+        index: i
+    }
 }
-function isNotation(xmlData, i){
-    if(xmlData[i+1] === '!' &&
-    xmlData[i+2] === 'N' &&
-    xmlData[i+3] === 'O' &&
-    xmlData[i+4] === 'T' &&
-    xmlData[i+5] === 'A' &&
-    xmlData[i+6] === 'T' &&
-    xmlData[i+7] === 'I' &&
-    xmlData[i+8] === 'O' &&
-    xmlData[i+9] === 'N') return true
-    return false
+
+function hasSeq(data, seq,i){
+    for(let j=0;j<seq.length;j++){
+        if(seq[j]!==data[i+j+1]) return false;
+    }
+    return true;
 }
 
 function validateEntityName(name){
-    if (util.isName(name))
+    if (isName(name))
 	return name;
     else
         throw new Error(`Invalid entity name ${name}`);
 }
-
-module.exports = readDocType;

package/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js

@@ -1,5 +1,5 @@
 
-const defaultOptions = {
+export const defaultOptions = {
     preserveOrder: false,
     attributeNamePrefix: '@_',
     attributesGroupName: false,
@@ -38,11 +38,9 @@ const defaultOptions = {
       return tagName
     },
     // skipEmptyListItem: false
+    captureMetaData: false,
 };
    
-const buildOptions = function(options) {
+export const buildOptions = function(options) {
     return Object.assign({}, defaultOptions, options);
 };
-
-exports.buildOptions = buildOptions;
-exports.defaultOptions = defaultOptions;