@nmshd/consumption 3.1.3 → 3.2.1

package/lib-web/nmshd.consumption.js

@@ -17,11 +17,11 @@ const content_1 = __webpack_require__(/*! @nmshd/content */ "@nmshd/content");
 const crypto_1 = __webpack_require__(/*! @nmshd/crypto */ "@nmshd/crypto");
 const transport_1 = __webpack_require__(/*! @nmshd/transport */ "@nmshd/transport");
 exports.buildInformation = {
-    version: "3.1.3",
-    build: "100",
-    date: "2023-03-10T13:14:12+00:00",
-    commit: "f47a99f523c75912d124da62f6a86d7dd31f9c1b",
-    dependencies: {"@js-soft/docdb-querytranslator":"^1.1.0","ts-simple-nameof":"^1.3.1"},
+    version: "3.2.1",
+    build: "103",
+    date: "2023-07-12T14:32:43+00:00",
+    commit: "3dd51183593d9fabc6311279752948af17f4b493",
+    dependencies: {"@js-soft/docdb-querytranslator":"^1.1.0","@nmshd/iql":"^0.0.1","ts-simple-nameof":"^1.3.1"},
     libraries: {
         transport: transport_1.buildInformation,
         crypto: crypto_1.buildInformation,
@@ -559,13 +559,37 @@ exports.LocalAttributeListener = LocalAttributeListener;
 /*!*********************************************************!*\
   !*** ./dist/modules/attributes/AttributesController.js ***!
   \*********************************************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AttributesController = void 0;
 const content_1 = __webpack_require__(/*! @nmshd/content */ "@nmshd/content");
+const Iql = __importStar(__webpack_require__(/*! @nmshd/iql */ "./node_modules/@nmshd/iql/dist/src/index.js"));
 const transport_1 = __webpack_require__(/*! @nmshd/transport */ "@nmshd/transport");
 const ts_simple_nameof_1 = __webpack_require__(/*! ts-simple-nameof */ "./node_modules/ts-simple-nameof/index.js");
 const consumption_1 = __webpack_require__(/*! ../../consumption */ "./dist/consumption/index.js");
@@ -676,6 +700,23 @@ class AttributesController extends consumption_1.ConsumptionBaseController {
     async getValidLocalAttributes(query, hideTechnical = false) {
         return await this.getLocalAttributes(query, hideTechnical, true);
     }
+    async executeIQLQuery(query) {
+        /* Fetch subset of attributes relevant for IQL queries. We filter for
+         * local identity attributes. */
+        const envelopedAttributes = (await this.attributes.find()).filter((e) => {
+            return e["@type"] === "LocalAttribute" && e.content["@type"] === "IdentityAttribute";
+        });
+        /* Remove envelope from attributes and execute query. IQL makes no use
+         * of the envelope data. */
+        const attributes = envelopedAttributes.map((e) => {
+            return e.content;
+        });
+        const indices = Iql.execute(query.queryString, attributes);
+        /* Map matched indices back to their respective attributes and return. */
+        const matchedAttributes = indices.map((ii) => envelopedAttributes[ii]);
+        const result = this.parseArray(matchedAttributes, LocalAttribute_1.LocalAttribute);
+        return result;
+    }
     async executeRelationshipAttributeQuery(query) {
         const parsedQuery = content_1.RelationshipAttributeQuery.from(query);
         const dbQuery = QueryTranslator_1.RelationshipAttributeQueryTranslator.translate(parsedQuery);
@@ -3401,6 +3442,7 @@ exports.ShareAttributeRequestItemProcessor = ShareAttributeRequestItemProcessor;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const content_1 = __webpack_require__(/*! @nmshd/content */ "@nmshd/content");
+const iql_1 = __webpack_require__(/*! @nmshd/iql */ "./node_modules/@nmshd/iql/dist/src/index.js");
 const consumption_1 = __webpack_require__(/*! ../../../../consumption */ "./dist/consumption/index.js");
 const ValidationResult_1 = __webpack_require__(/*! ../ValidationResult */ "./dist/modules/requests/itemProcessors/ValidationResult.js");
 function validateQuery(query, sender, recipient) {
@@ -3414,6 +3456,12 @@ function validateQuery(query, sender, recipient) {
             return ValidationResult_1.ValidationResult.error(consumption_1.CoreErrors.requests.invalidRequestItem("Cannot query own Attributes from a third party."));
         }
     }
+    else if (query instanceof content_1.IQLQuery) {
+        const validationResult = (0, iql_1.validate)(query.queryString);
+        if (!validationResult.isValid) {
+            return ValidationResult_1.ValidationResult.error(consumption_1.CoreErrors.requests.invalidRequestItem(`IQL query syntax error at character ${validationResult.error?.location.start.column}`));
+        }
+    }
     return ValidationResult_1.ValidationResult.success();
 }
 exports["default"] = validateQuery;
@@ -5043,218 +5091,1786 @@ function log(params) {
                 if (params?.logParams) {
                     thisT.log.trace(`Calling ${propertyName}(${args.map((a) => (0, json_stringify_safe_1.default)(a)).join(", ")})`);
                 }
-                else {
-                    thisT.log.trace(`Calling ${propertyName}`);
+                else {
+                    thisT.log.trace(`Calling ${propertyName}`);
+                }
+                const returnValue = method.apply(this, args);
+                if (params?.logReturnValue) {
+                    thisT.log.trace(`Returning from ${propertyName} with: ${(0, json_stringify_safe_1.default)(returnValue)}`);
+                }
+                else {
+                    thisT.log.trace(`Returning from ${propertyName}`);
+                }
+                return returnValue;
+            }
+            catch (error) {
+                if (error instanceof Error && error.stack) {
+                    error.stack = error.stack
+                        .split("\n")
+                        .filter((s) => !s.includes(".propertyDescriptorDoNotChangeMyNamePlease.value"))
+                        .join("\n");
+                }
+                thisT.log.error(`Error in ${propertyName}:`, error);
+                throw error;
+            }
+        };
+        return propertyDescriptorDoNotChangeMyNamePlease;
+    };
+}
+exports.log = log;
+//# sourceMappingURL=logDecorator.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@js-soft/ts-utils/dist/measureExcecutionTime.js":
+/*!**********************************************************************!*\
+  !*** ./node_modules/@js-soft/ts-utils/dist/measureExcecutionTime.js ***!
+  \**********************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.measureExcecutionTime = void 0;
+/* eslint-disable no-console */
+function measureExcecutionTime(_target, _propertyName, propertyDesciptor) {
+    const method = propertyDesciptor.value;
+    propertyDesciptor.value = async function (...args) {
+        const t0 = Date.now();
+        const result = await method.apply(this, args);
+        const t1 = Date.now();
+        console.info(`Execution time: ${t1 - t0}ms`);
+        return result;
+    };
+    return propertyDesciptor;
+}
+exports.measureExcecutionTime = measureExcecutionTime;
+//# sourceMappingURL=measureExcecutionTime.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@js-soft/ts-utils/dist/randomString.js":
+/*!*************************************************************!*\
+  !*** ./node_modules/@js-soft/ts-utils/dist/randomString.js ***!
+  \*************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.randomString = void 0;
+function randomString(length, characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") {
+    let result = "";
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}
+exports.randomString = randomString;
+//# sourceMappingURL=randomString.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@js-soft/ts-utils/dist/result/ApplicationError.js":
+/*!************************************************************************!*\
+  !*** ./node_modules/@js-soft/ts-utils/dist/result/ApplicationError.js ***!
+  \************************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ApplicationError = void 0;
+class ApplicationError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+    equals(error) {
+        return this.code === error.code;
+    }
+    toString() {
+        return JSON.stringify({ code: this.code, message: this.message, data: this.data }, undefined, 2);
+    }
+}
+exports.ApplicationError = ApplicationError;
+//# sourceMappingURL=ApplicationError.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@js-soft/ts-utils/dist/result/Result.js":
+/*!**************************************************************!*\
+  !*** ./node_modules/@js-soft/ts-utils/dist/result/Result.js ***!
+  \**************************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Result = void 0;
+class Result {
+    _isSuccess;
+    _error;
+    _value;
+    constructor(isSuccess, value, error) {
+        if (isSuccess && error) {
+            throw new Error("InvalidOperation: A result cannot be successful and contain an error");
+        }
+        if (!isSuccess && !error) {
+            throw new Error("InvalidOperation: A failing result needs to contain an error");
+        }
+        if (value !== undefined && !isSuccess) {
+            throw new Error("InvalidOperation: A value is only useful in case of a success.");
+        }
+        this._value = value;
+        this._isSuccess = isSuccess;
+        this._error = error;
+    }
+    get isSuccess() {
+        return this._isSuccess;
+    }
+    get isError() {
+        return !this._isSuccess;
+    }
+    get error() {
+        return this._error;
+    }
+    get value() {
+        if (!this.isSuccess) {
+            throw new Error(`Can't get the value of an error result. Use 'error' instead. Root error: \r\n${this.error}`);
+        }
+        return this._value;
+    }
+    static ok(value) {
+        return new Result(true, value);
+    }
+    static fail(error) {
+        return new Result(false, undefined, error);
+    }
+}
+exports.Result = Result;
+//# sourceMappingURL=Result.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@js-soft/ts-utils/dist/result/index.js":
+/*!*************************************************************!*\
+  !*** ./node_modules/@js-soft/ts-utils/dist/result/index.js ***!
+  \*************************************************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+__exportStar(__webpack_require__(/*! ./ApplicationError */ "./node_modules/@js-soft/ts-utils/dist/result/ApplicationError.js"), exports);
+__exportStar(__webpack_require__(/*! ./Result */ "./node_modules/@js-soft/ts-utils/dist/result/Result.js"), exports);
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@js-soft/ts-utils/dist/sleep.js":
+/*!******************************************************!*\
+  !*** ./node_modules/@js-soft/ts-utils/dist/sleep.js ***!
+  \******************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.sleep = void 0;
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+exports.sleep = sleep;
+//# sourceMappingURL=sleep.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@nmshd/iql/dist/generated/iql.js":
+/*!*******************************************************!*\
+  !*** ./node_modules/@nmshd/iql/dist/generated/iql.js ***!
+  \*******************************************************/
+/***/ ((module) => {
+
+"use strict";
+// Generated by Peggy 3.0.2.
+//
+// https://peggyjs.org/
+
+/**
+ * Takes the path through a nested dict as an array of strings and returns
+ * the value, or a fallback value, if the path does not exist.
+ */
+function resolvePath(dict, path, fallback = null) {
+    let val = dict;
+    for (const e of path) {
+        if (!Object.keys(val).includes(e)) {
+            return fallback;
+        }
+        val = val[e];
+    }
+    return val;
+}
+/**
+ * Generic matching function for attributes.
+ *
+ * attributes:    Array of attributes
+ * path:          Path to data field to apply matchFn to, represented as an
+ *                array of strings. E.g. Foo.bar.baz is represented as ["Foo",
+ *                "bar", "baz"].
+ * matchFn:       Predicate function applied to the value of the extracted
+ *                attribute data field represented by 'path'.
+ * attributeType: See comment below.
+ */
+function match(attributes, path, matchFn, attributeType = undefined) {
+    const indices = [];
+    for (let ii = 0; ii < attributes.length; ii++) {
+        const val = resolvePath(attributes[ii], path, null);
+        // If attributeType is defined, assert that it matches the attribute's
+        // type. When matching primary fields the mechanism presented by matchFn
+        // below is insufficient as it's not given the full attribute but only
+        // the selected data field.
+        if (attributeType !== undefined && attributes[ii].value["@type"] !== attributeType) {
+            continue;
+        }
+        if (val !== null && matchFn(val)) {
+            indices.push(ii);
+        }
+    }
+    return indices;
+}
+/**
+ * Returns the union of two sets (represented as arrays of primitive
+ * elements).
+ */
+function union(arr1, arr2) {
+    const result = Array.from(new Set([...arr1, ...arr2]));
+    result.sort((a, b) => { return a - b; });
+    return result;
+}
+/**
+ * Returns the intersection of two sets (represented as arrays of primitive
+ * elements).
+ */
+function intersect(b, ...a) {
+    const result = [b, ...a].reduce((p, c) => p.filter(e => c.includes(e)));
+    result.sort((a, b) => { return a - b; });
+    return result;
+}
+/**
+ * Returns the asymmetric difference of two sets (represented as arrays of
+ * primitive elements).
+ */
+function diffAsym(arr1, arr2) {
+    const result = arr1.filter((x) => { return !arr2.includes(x); });
+    result.sort((a, b) => { return a - b; });
+    return result;
+}
+function peg$subclass(child, parent) {
+    function C() { this.constructor = child; }
+    C.prototype = parent.prototype;
+    child.prototype = new C();
+}
+function peg$SyntaxError(message, expected, found, location) {
+    var self = Error.call(this, message);
+    // istanbul ignore next Check is a necessary evil to support older environments
+    if (Object.setPrototypeOf) {
+        Object.setPrototypeOf(self, peg$SyntaxError.prototype);
+    }
+    self.expected = expected;
+    self.found = found;
+    self.location = location;
+    self.name = "SyntaxError";
+    return self;
+}
+peg$subclass(peg$SyntaxError, Error);
+function peg$padEnd(str, targetLength, padString) {
+    padString = padString || " ";
+    if (str.length > targetLength) {
+        return str;
+    }
+    targetLength -= str.length;
+    padString += padString.repeat(targetLength);
+    return str + padString.slice(0, targetLength);
+}
+peg$SyntaxError.prototype.format = function (sources) {
+    var str = "Error: " + this.message;
+    if (this.location) {
+        var src = null;
+        var k;
+        for (k = 0; k < sources.length; k++) {
+            if (sources[k].source === this.location.source) {
+                src = sources[k].text.split(/\r\n|\n|\r/g);
+                break;
+            }
+        }
+        var s = this.location.start;
+        var offset_s = (this.location.source && (typeof this.location.source.offset === "function"))
+            ? this.location.source.offset(s)
+            : s;
+        var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column;
+        if (src) {
+            var e = this.location.end;
+            var filler = peg$padEnd("", offset_s.line.toString().length, ' ');
+            var line = src[s.line - 1];
+            var last = s.line === e.line ? e.column : line.length + 1;
+            var hatLen = (last - s.column) || 1;
+            str += "\n --> " + loc + "\n"
+                + filler + " |\n"
+                + offset_s.line + " | " + line + "\n"
+                + filler + " | " + peg$padEnd("", s.column - 1, ' ')
+                + peg$padEnd("", hatLen, "^");
+        }
+        else {
+            str += "\n at " + loc;
+        }
+    }
+    return str;
+};
+peg$SyntaxError.buildMessage = function (expected, found) {
+    var DESCRIBE_EXPECTATION_FNS = {
+        literal: function (expectation) {
+            return "\"" + literalEscape(expectation.text) + "\"";
+        },
+        class: function (expectation) {
+            var escapedParts = expectation.parts.map(function (part) {
+                return Array.isArray(part)
+                    ? classEscape(part[0]) + "-" + classEscape(part[1])
+                    : classEscape(part);
+            });
+            return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]";
+        },
+        any: function () {
+            return "any character";
+        },
+        end: function () {
+            return "end of input";
+        },
+        other: function (expectation) {
+            return expectation.description;
+        }
+    };
+    function hex(ch) {
+        return ch.charCodeAt(0).toString(16).toUpperCase();
+    }
+    function literalEscape(s) {
+        return s
+            .replace(/\\/g, "\\\\")
+            .replace(/"/g, "\\\"")
+            .replace(/\0/g, "\\0")
+            .replace(/\t/g, "\\t")
+            .replace(/\n/g, "\\n")
+            .replace(/\r/g, "\\r")
+            .replace(/[\x00-\x0F]/g, function (ch) { return "\\x0" + hex(ch); })
+            .replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) { return "\\x" + hex(ch); });
+    }
+    function classEscape(s) {
+        return s
+            .replace(/\\/g, "\\\\")
+            .replace(/\]/g, "\\]")
+            .replace(/\^/g, "\\^")
+            .replace(/-/g, "\\-")
+            .replace(/\0/g, "\\0")
+            .replace(/\t/g, "\\t")
+            .replace(/\n/g, "\\n")
+            .replace(/\r/g, "\\r")
+            .replace(/[\x00-\x0F]/g, function (ch) { return "\\x0" + hex(ch); })
+            .replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) { return "\\x" + hex(ch); });
+    }
+    function describeExpectation(expectation) {
+        return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
+    }
+    function describeExpected(expected) {
+        var descriptions = expected.map(describeExpectation);
+        var i, j;
+        descriptions.sort();
+        if (descriptions.length > 0) {
+            for (i = 1, j = 1; i < descriptions.length; i++) {
+                if (descriptions[i - 1] !== descriptions[i]) {
+                    descriptions[j] = descriptions[i];
+                    j++;
+                }
+            }
+            descriptions.length = j;
+        }
+        switch (descriptions.length) {
+            case 1:
+                return descriptions[0];
+            case 2:
+                return descriptions[0] + " or " + descriptions[1];
+            default:
+                return descriptions.slice(0, -1).join(", ")
+                    + ", or "
+                    + descriptions[descriptions.length - 1];
+        }
+    }
+    function describeFound(found) {
+        return found ? "\"" + literalEscape(found) + "\"" : "end of input";
+    }
+    return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
+};
+function peg$parse(input, options) {
+    options = options !== undefined ? options : {};
+    var peg$FAILED = {};
+    var peg$source = options.grammarSource;
+    var peg$startRuleFunctions = { Expr: peg$parseExpr };
+    var peg$startRuleFunction = peg$parseExpr;
+    var peg$c0 = "||";
+    var peg$c1 = "&&";
+    var peg$c2 = "!";
+    var peg$c3 = "(";
+    var peg$c4 = ")";
+    var peg$c5 = ".";
+    var peg$c6 = "#";
+    var peg$c7 = "'";
+    var peg$c8 = "\\\\";
+    var peg$c9 = "\\'";
+    var peg$r0 = /^[=><~]/;
+    var peg$r1 = /^[?]/;
+    var peg$r2 = /^[^'\\]/;
+    var peg$r3 = /^[^'\\ ]/;
+    var peg$r4 = /^[a-z]/;
+    var peg$r5 = /^[A-za-z0-9]/;
+    var peg$r6 = /^[A-Z]/;
+    var peg$r7 = /^[A-Za-z0-9]/;
+    var peg$r8 = /^[ \t\n\r]/;
+    var peg$e0 = peg$literalExpectation("||", false);
+    var peg$e1 = peg$literalExpectation("&&", false);
+    var peg$e2 = peg$literalExpectation("!", false);
+    var peg$e3 = peg$literalExpectation("(", false);
+    var peg$e4 = peg$literalExpectation(")", false);
+    var peg$e5 = peg$otherExpectation("metadata field term");
+    var peg$e6 = peg$literalExpectation(".", false);
+    var peg$e7 = peg$otherExpectation("tag term");
+    var peg$e8 = peg$literalExpectation("#", false);
+    var peg$e9 = peg$otherExpectation("primary field term");
+    var peg$e10 = peg$classExpectation(["=", ">", "<", "~"], false, false);
+    var peg$e11 = peg$classExpectation(["?"], false, false);
+    var peg$e12 = peg$literalExpectation("'", false);
+    var peg$e13 = peg$literalExpectation("\\\\", false);
+    var peg$e14 = peg$literalExpectation("\\'", false);
+    var peg$e15 = peg$classExpectation(["'", "\\"], true, false);
+    var peg$e16 = peg$classExpectation(["'", "\\", " "], true, false);
+    var peg$e17 = peg$classExpectation([["a", "z"]], false, false);
+    var peg$e18 = peg$classExpectation([["A", "z"], ["a", "z"], ["0", "9"]], false, false);
+    var peg$e19 = peg$otherExpectation("attribute type");
+    var peg$e20 = peg$classExpectation([["A", "Z"]], false, false);
+    var peg$e21 = peg$classExpectation([["A", "Z"], ["a", "z"], ["0", "9"]], false, false);
+    var peg$e22 = peg$otherExpectation("whitespace");
+    var peg$e23 = peg$classExpectation([" ", "\t", "\n", "\r"], false, false);
+    var peg$f0 = function (h, t) {
+        return t.reduce((acc, element) => {
+            return union(acc, element);
+        }, h);
+    };
+    var peg$f1 = function (h, t) {
+        return t.reduce((acc, element) => {
+            return intersect(acc, element);
+        }, h);
+    };
+    var peg$f2 = function (expr) {
+        const allIndices = [...Array(options.attributes.length).keys()];
+        return diffAsym(allIndices, expr);
+    };
+    var peg$f3 = function (pathPrefix, pathSuffix, matchFn) {
+        return match(options.attributes, [pathPrefix, ...pathSuffix], matchFn);
+    };
+    var peg$f4 = function (tag) {
+        return match(options.attributes, ["tags"], (fieldVal) => { return Array.isArray(fieldVal) && fieldVal.includes(tag); });
+    };
+    var peg$f5 = function (attributeType, path, matchFn) {
+        const result = match(options.attributes, ["value", ...path], matchFn, attributeType);
+        return result;
+    };
+    var peg$f6 = function (attributeType, matchFn) {
+        return match(options.attributes, ["value", "value"], matchFn, attributeType);
+    };
+    var peg$f7 = function (attributeType) {
+        // Providing only the attribute type returns attributes whose type
+        // matches. E.g. 'PhoneNumber' will return all attributes whose type is
+        // 'PhoneNumber', regardless of the values of any of their fields.
+        return match(options.attributes, ["value", "@type"], (fieldVal) => { return fieldVal === attributeType; });
+    };
+    var peg$f8 = function (op, rhs) {
+        switch (op) {
+            case "=":
+                return (fieldVal) => { return String(fieldVal) === rhs; };
+            case ">":
+                return (fieldVal) => { return new Date(fieldVal) >= new Date(rhs); };
+            case "<":
+                return (fieldVal) => { return new Date(fieldVal) <= new Date(rhs); };
+            case "~":
+                return (fieldVal) => { return Array.isArray(fieldVal) && fieldVal.includes(rhs); };
+        }
+    };
+    var peg$f9 = function (op) {
+        switch (op) {
+            case "?":
+                return (fieldVal) => { return fieldVal != undefined; };
+        }
+    };
+    var peg$f10 = function (val) {
+        return val.join("").replaceAll("\\\\", "\\").replaceAll("\\'", "'");
+    };
+    var peg$f11 = function (val) {
+        return val.join("").replaceAll("\\\\", "\\").replaceAll("\\'", "'");
+    };
+    var peg$currPos = 0;
+    var peg$savedPos = 0;
+    var peg$posDetailsCache = [{ line: 1, column: 1 }];
+    var peg$maxFailPos = 0;
+    var peg$maxFailExpected = [];
+    var peg$silentFails = 0;
+    var peg$result;
+    if ("startRule" in options) {
+        if (!(options.startRule in peg$startRuleFunctions)) {
+            throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
+        }
+        peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
+    }
+    function text() {
+        return input.substring(peg$savedPos, peg$currPos);
+    }
+    function offset() {
+        return peg$savedPos;
+    }
+    function range() {
+        return {
+            source: peg$source,
+            start: peg$savedPos,
+            end: peg$currPos
+        };
+    }
+    function location() {
+        return peg$computeLocation(peg$savedPos, peg$currPos);
+    }
+    function expected(description, location) {
+        location = location !== undefined
+            ? location
+            : peg$computeLocation(peg$savedPos, peg$currPos);
+        throw peg$buildStructuredError([peg$otherExpectation(description)], input.substring(peg$savedPos, peg$currPos), location);
+    }
+    function error(message, location) {
+        location = location !== undefined
+            ? location
+            : peg$computeLocation(peg$savedPos, peg$currPos);
+        throw peg$buildSimpleError(message, location);
+    }
+    function peg$literalExpectation(text, ignoreCase) {
+        return { type: "literal", text: text, ignoreCase: ignoreCase };
+    }
+    function peg$classExpectation(parts, inverted, ignoreCase) {
+        return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
+    }
+    function peg$anyExpectation() {
+        return { type: "any" };
+    }
+    function peg$endExpectation() {
+        return { type: "end" };
+    }
+    function peg$otherExpectation(description) {
+        return { type: "other", description: description };
+    }
+    function peg$computePosDetails(pos) {
+        var details = peg$posDetailsCache[pos];
+        var p;
+        if (details) {
+            return details;
+        }
+        else {
+            p = pos - 1;
+            while (!peg$posDetailsCache[p]) {
+                p--;
+            }
+            details = peg$posDetailsCache[p];
+            details = {
+                line: details.line,
+                column: details.column
+            };
+            while (p < pos) {
+                if (input.charCodeAt(p) === 10) {
+                    details.line++;
+                    details.column = 1;
+                }
+                else {
+                    details.column++;
+                }
+                p++;
+            }
+            peg$posDetailsCache[pos] = details;
+            return details;
+        }
+    }
+    function peg$computeLocation(startPos, endPos, offset) {
+        var startPosDetails = peg$computePosDetails(startPos);
+        var endPosDetails = peg$computePosDetails(endPos);
+        var res = {
+            source: peg$source,
+            start: {
+                offset: startPos,
+                line: startPosDetails.line,
+                column: startPosDetails.column
+            },
+            end: {
+                offset: endPos,
+                line: endPosDetails.line,
+                column: endPosDetails.column
+            }
+        };
+        if (offset && peg$source && (typeof peg$source.offset === "function")) {
+            res.start = peg$source.offset(res.start);
+            res.end = peg$source.offset(res.end);
+        }
+        return res;
+    }
+    function peg$fail(expected) {
+        if (peg$currPos < peg$maxFailPos) {
+            return;
+        }
+        if (peg$currPos > peg$maxFailPos) {
+            peg$maxFailPos = peg$currPos;
+            peg$maxFailExpected = [];
+        }
+        peg$maxFailExpected.push(expected);
+    }
+    function peg$buildSimpleError(message, location) {
+        return new peg$SyntaxError(message, null, null, location);
+    }
+    function peg$buildStructuredError(expected, found, location) {
+        return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location);
+    }
+    function peg$parseExpr() {
+        var s0, s1, s2, s3, s4, s5, s6, s7;
+        s0 = peg$currPos;
+        s1 = peg$parseExpr0();
+        if (s1 !== peg$FAILED) {
+            s2 = [];
+            s3 = peg$currPos;
+            s4 = [];
+            s5 = peg$parse_();
+            if (s5 !== peg$FAILED) {
+                while (s5 !== peg$FAILED) {
+                    s4.push(s5);
+                    s5 = peg$parse_();
+                }
+            }
+            else {
+                s4 = peg$FAILED;
+            }
+            if (s4 !== peg$FAILED) {
+                if (input.substr(peg$currPos, 2) === peg$c0) {
+                    s5 = peg$c0;
+                    peg$currPos += 2;
+                }
+                else {
+                    s5 = peg$FAILED;
+                    if (peg$silentFails === 0) {
+                        peg$fail(peg$e0);
+                    }
+                }
+                if (s5 !== peg$FAILED) {
+                    s6 = [];
+                    s7 = peg$parse_();
+                    if (s7 !== peg$FAILED) {
+                        while (s7 !== peg$FAILED) {
+                            s6.push(s7);
+                            s7 = peg$parse_();
+                        }
+                    }
+                    else {
+                        s6 = peg$FAILED;
+                    }
+                    if (s6 !== peg$FAILED) {
+                        s7 = peg$parseExpr0();
+                        if (s7 !== peg$FAILED) {
+                            s3 = s7;
+                        }
+                        else {
+                            peg$currPos = s3;
+                            s3 = peg$FAILED;
+                        }
+                    }
+                    else {
+                        peg$currPos = s3;
+                        s3 = peg$FAILED;
+                    }
+                }
+                else {
+                    peg$currPos = s3;
+                    s3 = peg$FAILED;
+                }
+            }
+            else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+            }
+            while (s3 !== peg$FAILED) {
+                s2.push(s3);
+                s3 = peg$currPos;
+                s4 = [];
+                s5 = peg$parse_();
+                if (s5 !== peg$FAILED) {
+                    while (s5 !== peg$FAILED) {
+                        s4.push(s5);
+                        s5 = peg$parse_();
+                    }
+                }
+                else {
+                    s4 = peg$FAILED;
+                }
+                if (s4 !== peg$FAILED) {
+                    if (input.substr(peg$currPos, 2) === peg$c0) {
+                        s5 = peg$c0;
+                        peg$currPos += 2;
+                    }
+                    else {
+                        s5 = peg$FAILED;
+                        if (peg$silentFails === 0) {
+                            peg$fail(peg$e0);
+                        }
+                    }
+                    if (s5 !== peg$FAILED) {
+                        s6 = [];
+                        s7 = peg$parse_();
+                        if (s7 !== peg$FAILED) {
+                            while (s7 !== peg$FAILED) {
+                                s6.push(s7);
+                                s7 = peg$parse_();
+                            }
+                        }
+                        else {
+                            s6 = peg$FAILED;
+                        }
+                        if (s6 !== peg$FAILED) {
+                            s7 = peg$parseExpr0();
+                            if (s7 !== peg$FAILED) {
+                                s3 = s7;
+                            }
+                            else {
+                                peg$currPos = s3;
+                                s3 = peg$FAILED;
+                            }
+                        }
+                        else {
+                            peg$currPos = s3;
+                            s3 = peg$FAILED;
+                        }
+                    }
+                    else {
+                        peg$currPos = s3;
+                        s3 = peg$FAILED;
+                    }
+                }
+                else {
+                    peg$currPos = s3;
+                    s3 = peg$FAILED;
+                }
+            }
+            peg$savedPos = s0;
+            s0 = peg$f0(s1, s2);
+        }
+        else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+        }
+        return s0;
+    }
+    function peg$parseExpr0() {
+        var s0, s1, s2, s3, s4, s5, s6, s7;
+        s0 = peg$currPos;
+        s1 = peg$parseExpr1();
+        if (s1 !== peg$FAILED) {
+            s2 = [];
+            s3 = peg$currPos;
+            s4 = [];
+            s5 = peg$parse_();
+            if (s5 !== peg$FAILED) {
+                while (s5 !== peg$FAILED) {
+                    s4.push(s5);
+                    s5 = peg$parse_();
+                }
+            }
+            else {
+                s4 = peg$FAILED;
+            }
+            if (s4 !== peg$FAILED) {
+                if (input.substr(peg$currPos, 2) === peg$c1) {
+                    s5 = peg$c1;
+                    peg$currPos += 2;
+                }
+                else {
+                    s5 = peg$FAILED;
+                    if (peg$silentFails === 0) {
+                        peg$fail(peg$e1);
+                    }
+                }
+                if (s5 !== peg$FAILED) {
+                    s6 = [];
+                    s7 = peg$parse_();
+                    if (s7 !== peg$FAILED) {
+                        while (s7 !== peg$FAILED) {
+                            s6.push(s7);
+                            s7 = peg$parse_();
+                        }
+                    }
+                    else {
+                        s6 = peg$FAILED;
+                    }
+                    if (s6 !== peg$FAILED) {
+                        s7 = peg$parseExpr1();
+                        if (s7 !== peg$FAILED) {
+                            s3 = s7;
+                        }
+                        else {
+                            peg$currPos = s3;
+                            s3 = peg$FAILED;
+                        }
+                    }
+                    else {
+                        peg$currPos = s3;
+                        s3 = peg$FAILED;
+                    }
+                }
+                else {
+                    peg$currPos = s3;
+                    s3 = peg$FAILED;
+                }
+            }
+            else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+            }
+            while (s3 !== peg$FAILED) {
+                s2.push(s3);
+                s3 = peg$currPos;
+                s4 = [];
+                s5 = peg$parse_();
+                if (s5 !== peg$FAILED) {
+                    while (s5 !== peg$FAILED) {
+                        s4.push(s5);
+                        s5 = peg$parse_();
+                    }
+                }
+                else {
+                    s4 = peg$FAILED;
+                }
+                if (s4 !== peg$FAILED) {
+                    if (input.substr(peg$currPos, 2) === peg$c1) {
+                        s5 = peg$c1;
+                        peg$currPos += 2;
+                    }
+                    else {
+                        s5 = peg$FAILED;
+                        if (peg$silentFails === 0) {
+                            peg$fail(peg$e1);
+                        }
+                    }
+                    if (s5 !== peg$FAILED) {
+                        s6 = [];
+                        s7 = peg$parse_();
+                        if (s7 !== peg$FAILED) {
+                            while (s7 !== peg$FAILED) {
+                                s6.push(s7);
+                                s7 = peg$parse_();
+                            }
+                        }
+                        else {
+                            s6 = peg$FAILED;
+                        }
+                        if (s6 !== peg$FAILED) {
+                            s7 = peg$parseExpr1();
+                            if (s7 !== peg$FAILED) {
+                                s3 = s7;
+                            }
+                            else {
+                                peg$currPos = s3;
+                                s3 = peg$FAILED;
+                            }
+                        }
+                        else {
+                            peg$currPos = s3;
+                            s3 = peg$FAILED;
+                        }
+                    }
+                    else {
+                        peg$currPos = s3;
+                        s3 = peg$FAILED;
+                    }
+                }
+                else {
+                    peg$currPos = s3;
+                    s3 = peg$FAILED;
+                }
+            }
+            peg$savedPos = s0;
+            s0 = peg$f1(s1, s2);
+        }
+        else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+        }
+        return s0;
+    }
+    function peg$parseExpr1() {
+        var s0, s1, s2;
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 33) {
+            s1 = peg$c2;
+            peg$currPos++;
+        }
+        else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e2);
+            }
+        }
+        if (s1 !== peg$FAILED) {
+            s2 = peg$parseExpr1();
+            if (s2 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s0 = peg$f2(s2);
+            }
+            else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+            }
+        }
+        else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+            s0 = peg$parseExpr2();
+        }
+        return s0;
+    }
+    function peg$parseExpr2() {
+        var s0, s1, s2, s3, s4, s5;
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 40) {
+            s1 = peg$c3;
+            peg$currPos++;
+        }
+        else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e3);
+            }
+        }
+        if (s1 !== peg$FAILED) {
+            s2 = [];
+            s3 = peg$parse_();
+            if (s3 !== peg$FAILED) {
+                while (s3 !== peg$FAILED) {
+                    s2.push(s3);
+                    s3 = peg$parse_();
+                }
+            }
+            else {
+                s2 = peg$FAILED;
+            }
+            if (s2 !== peg$FAILED) {
+                s3 = peg$parseExpr();
+                if (s3 !== peg$FAILED) {
+                    s4 = [];
+                    s5 = peg$parse_();
+                    if (s5 !== peg$FAILED) {
+                        while (s5 !== peg$FAILED) {
+                            s4.push(s5);
+                            s5 = peg$parse_();
+                        }
+                    }
+                    else {
+                        s4 = peg$FAILED;
+                    }
+                    if (s4 !== peg$FAILED) {
+                        if (input.charCodeAt(peg$currPos) === 41) {
+                            s5 = peg$c4;
+                            peg$currPos++;
+                        }
+                        else {
+                            s5 = peg$FAILED;
+                            if (peg$silentFails === 0) {
+                                peg$fail(peg$e4);
+                            }
+                        }
+                        if (s5 !== peg$FAILED) {
+                            s0 = s3;
+                        }
+                        else {
+                            peg$currPos = s0;
+                            s0 = peg$FAILED;
+                        }
+                    }
+                    else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                    }
+                }
+                else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                }
+            }
+            else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+            }
+        }
+        else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+            s0 = peg$parseTerm();
+        }
+        return s0;
+    }
+    function peg$parseTerm() {
+        var s0;
+        s0 = peg$parsePrimaryFieldTerm();
+        if (s0 === peg$FAILED) {
+            s0 = peg$parseMetadataFieldTerm();
+            if (s0 === peg$FAILED) {
+                s0 = peg$parseTagTerm();
+            }
+        }
+        return s0;
+    }
+    function peg$parseMetadataFieldTerm() {
+        var s0, s1, s2, s3, s4, s5;
+        peg$silentFails++;
+        s0 = peg$currPos;
+        s1 = peg$parsePathSegment();
+        if (s1 !== peg$FAILED) {
+            s2 = [];
+            s3 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 46) {
+                s4 = peg$c5;
+                peg$currPos++;
+            }
+            else {
+                s4 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                    peg$fail(peg$e6);
+                }
+            }
+            if (s4 !== peg$FAILED) {
+                s5 = peg$parsePathSegment();
+                if (s5 !== peg$FAILED) {
+                    s3 = s5;
+                }
+                else {
+                    peg$currPos = s3;
+                    s3 = peg$FAILED;
+                }
+            }
+            else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+            }
+            while (s3 !== peg$FAILED) {
+                s2.push(s3);
+                s3 = peg$currPos;
+                if (input.charCodeAt(peg$currPos) === 46) {
+                    s4 = peg$c5;
+                    peg$currPos++;
+                }
+                else {
+                    s4 = peg$FAILED;
+                    if (peg$silentFails === 0) {
+                        peg$fail(peg$e6);
+                    }
+                }
+                if (s4 !== peg$FAILED) {
+                    s5 = peg$parsePathSegment();
+                    if (s5 !== peg$FAILED) {
+                        s3 = s5;
+                    }
+                    else {
+                        peg$currPos = s3;
+                        s3 = peg$FAILED;
+                    }
+                }
+                else {
+                    peg$currPos = s3;
+                    s3 = peg$FAILED;
+                }
+            }
+            s3 = peg$parsePredicate();
+            if (s3 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s0 = peg$f3(s1, s2, s3);
+            }
+            else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+            }
+        }
+        else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e5);
+            }
+        }
+        return s0;
+    }
+    function peg$parseTagTerm() {
+        var s0, s1, s2;
+        peg$silentFails++;
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 35) {
+            s1 = peg$c6;
+            peg$currPos++;
+        }
+        else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e8);
+            }
+        }
+        if (s1 !== peg$FAILED) {
+            s2 = peg$parsePredicateRHS();
+            if (s2 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s0 = peg$f4(s2);
+            }
+            else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+            }
+        }
+        else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e7);
+            }
+        }
+        return s0;
+    }
+    function peg$parsePrimaryFieldTerm() {
+        var s0, s1, s2, s3, s4, s5;
+        peg$silentFails++;
+        s0 = peg$currPos;
+        s1 = peg$parseAttributeType();
+        if (s1 !== peg$FAILED) {
+            s2 = [];
+            s3 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 46) {
+                s4 = peg$c5;
+                peg$currPos++;
+            }
+            else {
+                s4 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                    peg$fail(peg$e6);
+                }
+            }
+            if (s4 !== peg$FAILED) {
+                s5 = peg$parsePathSegment();
+                if (s5 !== peg$FAILED) {
+                    s3 = s5;
+                }
+                else {
+                    peg$currPos = s3;
+                    s3 = peg$FAILED;
+                }
+            }
+            else {
+                peg$currPos = s3;
+                s3 = peg$FAILED;
+            }
+            if (s3 !== peg$FAILED) {
+                while (s3 !== peg$FAILED) {
+                    s2.push(s3);
+                    s3 = peg$currPos;
+                    if (input.charCodeAt(peg$currPos) === 46) {
+                        s4 = peg$c5;
+                        peg$currPos++;
+                    }
+                    else {
+                        s4 = peg$FAILED;
+                        if (peg$silentFails === 0) {
+                            peg$fail(peg$e6);
+                        }
+                    }
+                    if (s4 !== peg$FAILED) {
+                        s5 = peg$parsePathSegment();
+                        if (s5 !== peg$FAILED) {
+                            s3 = s5;
+                        }
+                        else {
+                            peg$currPos = s3;
+                            s3 = peg$FAILED;
+                        }
+                    }
+                    else {
+                        peg$currPos = s3;
+                        s3 = peg$FAILED;
+                    }
+                }
+            }
+            else {
+                s2 = peg$FAILED;
+            }
+            if (s2 !== peg$FAILED) {
+                s3 = peg$parsePredicate();
+                if (s3 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s0 = peg$f5(s1, s2, s3);
+                }
+                else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                }
+            }
+            else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+            }
+        }
+        else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            s1 = peg$parseAttributeType();
+            if (s1 !== peg$FAILED) {
+                s2 = peg$parsePredicate();
+                if (s2 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s0 = peg$f6(s1, s2);
+                }
+                else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                }
+            }
+            else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+            }
+            if (s0 === peg$FAILED) {
+                s0 = peg$currPos;
+                s1 = peg$parseAttributeType();
+                if (s1 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s1 = peg$f7(s1);
+                }
+                s0 = s1;
+            }
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e9);
+            }
+        }
+        return s0;
+    }
+    function peg$parsePredicate() {
+        var s0, s1, s2;
+        s0 = peg$currPos;
+        if (peg$r0.test(input.charAt(peg$currPos))) {
+            s1 = input.charAt(peg$currPos);
+            peg$currPos++;
+        }
+        else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e10);
+            }
+        }
+        if (s1 !== peg$FAILED) {
+            s2 = peg$parsePredicateRHS();
+            if (s2 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s0 = peg$f8(s1, s2);
+            }
+            else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+            }
+        }
+        else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            if (peg$r1.test(input.charAt(peg$currPos))) {
+                s1 = input.charAt(peg$currPos);
+                peg$currPos++;
+            }
+            else {
+                s1 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                    peg$fail(peg$e11);
+                }
+            }
+            if (s1 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s1 = peg$f9(s1);
+            }
+            s0 = s1;
+        }
+        return s0;
+    }
+    function peg$parsePredicateRHS() {
+        var s0, s1, s2, s3;
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 39) {
+            s1 = peg$c7;
+            peg$currPos++;
+        }
+        else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e12);
+            }
+        }
+        if (s1 !== peg$FAILED) {
+            s2 = [];
+            if (input.substr(peg$currPos, 2) === peg$c8) {
+                s3 = peg$c8;
+                peg$currPos += 2;
+            }
+            else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                    peg$fail(peg$e13);
+                }
+            }
+            if (s3 === peg$FAILED) {
+                if (input.substr(peg$currPos, 2) === peg$c9) {
+                    s3 = peg$c9;
+                    peg$currPos += 2;
+                }
+                else {
+                    s3 = peg$FAILED;
+                    if (peg$silentFails === 0) {
+                        peg$fail(peg$e14);
+                    }
+                }
+                if (s3 === peg$FAILED) {
+                    if (peg$r2.test(input.charAt(peg$currPos))) {
+                        s3 = input.charAt(peg$currPos);
+                        peg$currPos++;
+                    }
+                    else {
+                        s3 = peg$FAILED;
+                        if (peg$silentFails === 0) {
+                            peg$fail(peg$e15);
+                        }
+                    }
+                }
+            }
+            while (s3 !== peg$FAILED) {
+                s2.push(s3);
+                if (input.substr(peg$currPos, 2) === peg$c8) {
+                    s3 = peg$c8;
+                    peg$currPos += 2;
+                }
+                else {
+                    s3 = peg$FAILED;
+                    if (peg$silentFails === 0) {
+                        peg$fail(peg$e13);
+                    }
+                }
+                if (s3 === peg$FAILED) {
+                    if (input.substr(peg$currPos, 2) === peg$c9) {
+                        s3 = peg$c9;
+                        peg$currPos += 2;
+                    }
+                    else {
+                        s3 = peg$FAILED;
+                        if (peg$silentFails === 0) {
+                            peg$fail(peg$e14);
+                        }
+                    }
+                    if (s3 === peg$FAILED) {
+                        if (peg$r2.test(input.charAt(peg$currPos))) {
+                            s3 = input.charAt(peg$currPos);
+                            peg$currPos++;
+                        }
+                        else {
+                            s3 = peg$FAILED;
+                            if (peg$silentFails === 0) {
+                                peg$fail(peg$e15);
+                            }
+                        }
+                    }
+                }
+            }
+            if (input.charCodeAt(peg$currPos) === 39) {
+                s3 = peg$c7;
+                peg$currPos++;
+            }
+            else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                    peg$fail(peg$e12);
+                }
+            }
+            if (s3 !== peg$FAILED) {
+                peg$savedPos = s0;
+                s0 = peg$f10(s2);
+            }
+            else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+            }
+        }
+        else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+        }
+        if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            s1 = [];
+            if (input.substr(peg$currPos, 2) === peg$c8) {
+                s2 = peg$c8;
+                peg$currPos += 2;
+            }
+            else {
+                s2 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                    peg$fail(peg$e13);
+                }
+            }
+            if (s2 === peg$FAILED) {
+                if (input.substr(peg$currPos, 2) === peg$c9) {
+                    s2 = peg$c9;
+                    peg$currPos += 2;
+                }
+                else {
+                    s2 = peg$FAILED;
+                    if (peg$silentFails === 0) {
+                        peg$fail(peg$e14);
+                    }
+                }
+                if (s2 === peg$FAILED) {
+                    if (peg$r3.test(input.charAt(peg$currPos))) {
+                        s2 = input.charAt(peg$currPos);
+                        peg$currPos++;
+                    }
+                    else {
+                        s2 = peg$FAILED;
+                        if (peg$silentFails === 0) {
+                            peg$fail(peg$e16);
+                        }
+                    }
+                }
+            }
+            while (s2 !== peg$FAILED) {
+                s1.push(s2);
+                if (input.substr(peg$currPos, 2) === peg$c8) {
+                    s2 = peg$c8;
+                    peg$currPos += 2;
+                }
+                else {
+                    s2 = peg$FAILED;
+                    if (peg$silentFails === 0) {
+                        peg$fail(peg$e13);
+                    }
+                }
+                if (s2 === peg$FAILED) {
+                    if (input.substr(peg$currPos, 2) === peg$c9) {
+                        s2 = peg$c9;
+                        peg$currPos += 2;
+                    }
+                    else {
+                        s2 = peg$FAILED;
+                        if (peg$silentFails === 0) {
+                            peg$fail(peg$e14);
+                        }
+                    }
+                    if (s2 === peg$FAILED) {
+                        if (peg$r3.test(input.charAt(peg$currPos))) {
+                            s2 = input.charAt(peg$currPos);
+                            peg$currPos++;
+                        }
+                        else {
+                            s2 = peg$FAILED;
+                            if (peg$silentFails === 0) {
+                                peg$fail(peg$e16);
+                            }
+                        }
+                    }
+                }
+            }
+            peg$savedPos = s0;
+            s1 = peg$f11(s1);
+            s0 = s1;
+        }
+        return s0;
+    }
+    function peg$parsePathSegment() {
+        var s0, s1, s2, s3, s4;
+        s0 = peg$currPos;
+        s1 = peg$currPos;
+        if (peg$r4.test(input.charAt(peg$currPos))) {
+            s2 = input.charAt(peg$currPos);
+            peg$currPos++;
+        }
+        else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e17);
+            }
+        }
+        if (s2 !== peg$FAILED) {
+            s3 = [];
+            if (peg$r5.test(input.charAt(peg$currPos))) {
+                s4 = input.charAt(peg$currPos);
+                peg$currPos++;
+            }
+            else {
+                s4 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                    peg$fail(peg$e18);
+                }
+            }
+            if (s4 !== peg$FAILED) {
+                while (s4 !== peg$FAILED) {
+                    s3.push(s4);
+                    if (peg$r5.test(input.charAt(peg$currPos))) {
+                        s4 = input.charAt(peg$currPos);
+                        peg$currPos++;
+                    }
+                    else {
+                        s4 = peg$FAILED;
+                        if (peg$silentFails === 0) {
+                            peg$fail(peg$e18);
+                        }
+                    }
+                }
+            }
+            else {
+                s3 = peg$FAILED;
+            }
+            if (s3 !== peg$FAILED) {
+                s2 = [s2, s3];
+                s1 = s2;
+            }
+            else {
+                peg$currPos = s1;
+                s1 = peg$FAILED;
+            }
+        }
+        else {
+            peg$currPos = s1;
+            s1 = peg$FAILED;
+        }
+        if (s1 !== peg$FAILED) {
+            s0 = input.substring(s0, peg$currPos);
+        }
+        else {
+            s0 = s1;
+        }
+        return s0;
+    }
+    function peg$parseAttributeType() {
+        var s0, s1, s2, s3, s4;
+        peg$silentFails++;
+        s0 = peg$currPos;
+        s1 = peg$currPos;
+        if (peg$r6.test(input.charAt(peg$currPos))) {
+            s2 = input.charAt(peg$currPos);
+            peg$currPos++;
+        }
+        else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e20);
+            }
+        }
+        if (s2 !== peg$FAILED) {
+            s3 = [];
+            if (peg$r7.test(input.charAt(peg$currPos))) {
+                s4 = input.charAt(peg$currPos);
+                peg$currPos++;
+            }
+            else {
+                s4 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                    peg$fail(peg$e21);
                 }
-                const returnValue = method.apply(this, args);
-                if (params?.logReturnValue) {
-                    thisT.log.trace(`Returning from ${propertyName} with: ${(0, json_stringify_safe_1.default)(returnValue)}`);
+            }
+            while (s4 !== peg$FAILED) {
+                s3.push(s4);
+                if (peg$r7.test(input.charAt(peg$currPos))) {
+                    s4 = input.charAt(peg$currPos);
+                    peg$currPos++;
                 }
                 else {
-                    thisT.log.trace(`Returning from ${propertyName}`);
+                    s4 = peg$FAILED;
+                    if (peg$silentFails === 0) {
+                        peg$fail(peg$e21);
+                    }
                 }
-                return returnValue;
             }
-            catch (error) {
-                if (error instanceof Error && error.stack) {
-                    error.stack = error.stack
-                        .split("\n")
-                        .filter((s) => !s.includes(".propertyDescriptorDoNotChangeMyNamePlease.value"))
-                        .join("\n");
-                }
-                thisT.log.error(`Error in ${propertyName}:`, error);
-                throw error;
+            s2 = [s2, s3];
+            s1 = s2;
+        }
+        else {
+            peg$currPos = s1;
+            s1 = peg$FAILED;
+        }
+        if (s1 !== peg$FAILED) {
+            s0 = input.substring(s0, peg$currPos);
+        }
+        else {
+            s0 = s1;
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e19);
             }
-        };
-        return propertyDescriptorDoNotChangeMyNamePlease;
-    };
-}
-exports.log = log;
-//# sourceMappingURL=logDecorator.js.map
-
-/***/ }),
-
-/***/ "./node_modules/@js-soft/ts-utils/dist/measureExcecutionTime.js":
-/*!**********************************************************************!*\
-  !*** ./node_modules/@js-soft/ts-utils/dist/measureExcecutionTime.js ***!
-  \**********************************************************************/
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.measureExcecutionTime = void 0;
-/* eslint-disable no-console */
-function measureExcecutionTime(_target, _propertyName, propertyDesciptor) {
-    const method = propertyDesciptor.value;
-    propertyDesciptor.value = async function (...args) {
-        const t0 = Date.now();
-        const result = await method.apply(this, args);
-        const t1 = Date.now();
-        console.info(`Execution time: ${t1 - t0}ms`);
-        return result;
-    };
-    return propertyDesciptor;
-}
-exports.measureExcecutionTime = measureExcecutionTime;
-//# sourceMappingURL=measureExcecutionTime.js.map
-
-/***/ }),
-
-/***/ "./node_modules/@js-soft/ts-utils/dist/randomString.js":
-/*!*************************************************************!*\
-  !*** ./node_modules/@js-soft/ts-utils/dist/randomString.js ***!
-  \*************************************************************/
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.randomString = void 0;
-function randomString(length, characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") {
-    let result = "";
-    const charactersLength = characters.length;
-    for (let i = 0; i < length; i++) {
-        result += characters.charAt(Math.floor(Math.random() * charactersLength));
-    }
-    return result;
-}
-exports.randomString = randomString;
-//# sourceMappingURL=randomString.js.map
-
-/***/ }),
-
-/***/ "./node_modules/@js-soft/ts-utils/dist/result/ApplicationError.js":
-/*!************************************************************************!*\
-  !*** ./node_modules/@js-soft/ts-utils/dist/result/ApplicationError.js ***!
-  \************************************************************************/
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ApplicationError = void 0;
-class ApplicationError extends Error {
-    code;
-    data;
-    constructor(code, message, data) {
-        super(message);
-        this.code = code;
-        this.data = data;
-    }
-    equals(error) {
-        return this.code === error.code;
-    }
-    toString() {
-        return JSON.stringify({ code: this.code, message: this.message, data: this.data }, undefined, 2);
+        }
+        return s0;
     }
-}
-exports.ApplicationError = ApplicationError;
-//# sourceMappingURL=ApplicationError.js.map
-
-/***/ }),
-
-/***/ "./node_modules/@js-soft/ts-utils/dist/result/Result.js":
-/*!**************************************************************!*\
-  !*** ./node_modules/@js-soft/ts-utils/dist/result/Result.js ***!
-  \**************************************************************/
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Result = void 0;
-class Result {
-    _isSuccess;
-    _error;
-    _value;
-    constructor(isSuccess, value, error) {
-        if (isSuccess && error) {
-            throw new Error("InvalidOperation: A result cannot be successful and contain an error");
+    function peg$parse_() {
+        var s0, s1;
+        peg$silentFails++;
+        if (peg$r8.test(input.charAt(peg$currPos))) {
+            s0 = input.charAt(peg$currPos);
+            peg$currPos++;
         }
-        if (!isSuccess && !error) {
-            throw new Error("InvalidOperation: A failing result needs to contain an error");
+        else {
+            s0 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e23);
+            }
         }
-        if (value !== undefined && !isSuccess) {
-            throw new Error("InvalidOperation: A value is only useful in case of a success.");
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e22);
+            }
         }
-        this._value = value;
-        this._isSuccess = isSuccess;
-        this._error = error;
-    }
-    get isSuccess() {
-        return this._isSuccess;
+        return s0;
     }
-    get isError() {
-        return !this._isSuccess;
-    }
-    get error() {
-        return this._error;
+    peg$result = peg$startRuleFunction();
+    if (peg$result !== peg$FAILED && peg$currPos === input.length) {
+        return peg$result;
     }
-    get value() {
-        if (!this.isSuccess) {
-            throw new Error(`Can't get the value of an error result. Use 'error' instead. Root error: \r\n${this.error}`);
+    else {
+        if (peg$result !== peg$FAILED && peg$currPos < input.length) {
+            peg$fail(peg$endExpectation());
         }
-        return this._value;
-    }
-    static ok(value) {
-        return new Result(true, value);
-    }
-    static fail(error) {
-        return new Result(false, undefined, error);
+        throw peg$buildStructuredError(peg$maxFailExpected, peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, peg$maxFailPos < input.length
+            ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
+            : peg$computeLocation(peg$maxFailPos, peg$maxFailPos));
     }
 }
-exports.Result = Result;
-//# sourceMappingURL=Result.js.map
-
-/***/ }),
-
-/***/ "./node_modules/@js-soft/ts-utils/dist/result/index.js":
-/*!*************************************************************!*\
-  !*** ./node_modules/@js-soft/ts-utils/dist/result/index.js ***!
-  \*************************************************************/
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+module.exports = {
+    SyntaxError: peg$SyntaxError,
+    parse: peg$parse
 };
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(/*! ./ApplicationError */ "./node_modules/@js-soft/ts-utils/dist/result/ApplicationError.js"), exports);
-__exportStar(__webpack_require__(/*! ./Result */ "./node_modules/@js-soft/ts-utils/dist/result/Result.js"), exports);
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=iql.js.map
 
 /***/ }),
 
-/***/ "./node_modules/@js-soft/ts-utils/dist/sleep.js":
-/*!******************************************************!*\
-  !*** ./node_modules/@js-soft/ts-utils/dist/sleep.js ***!
-  \******************************************************/
-/***/ ((__unused_webpack_module, exports) => {
+/***/ "./node_modules/@nmshd/iql/dist/src/index.js":
+/*!***************************************************!*\
+  !*** ./node_modules/@nmshd/iql/dist/src/index.js ***!
+  \***************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.sleep = void 0;
-function sleep(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
+exports.validate = exports.execute = void 0;
+const iql_js_1 = __webpack_require__(/*! ../generated/iql.js */ "./node_modules/@nmshd/iql/dist/generated/iql.js");
+/**
+ * Executes IQL query, returning array of indicies of matched attributes in
+ * attribute array.
+ */
+function execute(iqlQuery, attributes) {
+    return (0, iql_js_1.parse)(iqlQuery, { attributes });
 }
-exports.sleep = sleep;
-//# sourceMappingURL=sleep.js.map
+exports.execute = execute;
+function validate(iqlQuery) {
+    try {
+        (0, iql_js_1.parse)(iqlQuery, { attributes: [] });
+        return { isValid: true };
+    }
+    catch (error) {
+        // FIXME: Is there a cleaner way to catch IQL SyntaxErrors?
+        //        For the sake of backwards compatibility peggy compiles to old
+        //        js without the use of classes. Thus the static type inference
+        //        for the SyntaxError type is severely crippled.
+        if (error instanceof iql_js_1.SyntaxError) {
+            const err = error; // see FIXME above.
+            return {
+                isValid: false,
+                error: {
+                    message: err.message,
+                    location: {
+                        start: err.location.start,
+                        end: err.location.end
+                    }
+                }
+            };
+        }
+        return {
+            isValid: false,
+            error: {
+                message: JSON.stringify(error),
+                location: {
+                    start: {
+                        column: 0,
+                        line: 0,
+                        offset: 0
+                    },
+                    end: {
+                        column: 0,
+                        line: 0,
+                        offset: 0
+                    }
+                }
+            }
+        };
+    }
+}
+exports.validate = validate;
+//# sourceMappingURL=index.js.map
 
 /***/ }),
 
@@ -24883,8 +26499,12 @@ class PolyNumberFormatter {
 class PolyDateFormatter {
   constructor(dt, intl, opts) {
     this.opts = opts;
+    this.originalZone = undefined;
     let z = undefined;
-    if (dt.zone.isUniversal) {
+    if (this.opts.timeZone) {
+      // Don't apply any workarounds if a timeZone is explicitly provided in opts
+      this.dt = dt;
+    } else if (dt.zone.type === "fixed") {
       // UTC-8 or Etc/UTC-8 are not part of tzdata, only Etc/GMT+8 and the like.
       // That is why fixed-offset TZ is set to that unless it is:
       // 1. Representing offset 0 when UTC is used to maintain previous behavior and does not become GMT.
@@ -24897,25 +26517,27 @@ class PolyDateFormatter {
         z = offsetZ;
         this.dt = dt;
       } else {
-        // Not all fixed-offset zones like Etc/+4:30 are present in tzdata.
-        // So we have to make do. Two cases:
-        // 1. The format options tell us to show the zone. We can't do that, so the best
-        // we can do is format the date in UTC.
-        // 2. The format options don't tell us to show the zone. Then we can adjust them
-        // the time and tell the formatter to show it to us in UTC, so that the time is right
-        // and the bad zone doesn't show up.
+        // Not all fixed-offset zones like Etc/+4:30 are present in tzdata so
+        // we manually apply the offset and substitute the zone as needed.
         z = "UTC";
-        if (opts.timeZoneName) {
-          this.dt = dt;
-        } else {
-          this.dt = dt.offset === 0 ? dt : DateTime.fromMillis(dt.ts + dt.offset * 60 * 1000);
-        }
+        this.dt = dt.offset === 0 ? dt : dt.setZone("UTC").plus({
+          minutes: dt.offset
+        });
+        this.originalZone = dt.zone;
       }
     } else if (dt.zone.type === "system") {
       this.dt = dt;
-    } else {
+    } else if (dt.zone.type === "iana") {
       this.dt = dt;
       z = dt.zone.name;
+    } else {
+      // Custom zones can have any offset / offsetName so we just manually
+      // apply the offset and substitute the zone as needed.
+      z = "UTC";
+      this.dt = dt.setZone("UTC").plus({
+        minutes: dt.offset
+      });
+      this.originalZone = dt.zone;
     }
     const intlOpts = {
       ...this.opts
@@ -24924,10 +26546,34 @@ class PolyDateFormatter {
     this.dtf = getCachedDTF(intl, intlOpts);
   }
   format() {
+    if (this.originalZone) {
+      // If we have to substitute in the actual zone name, we have to use
+      // formatToParts so that the timezone can be replaced.
+      return this.formatToParts().map(({
+        value
+      }) => value).join("");
+    }
     return this.dtf.format(this.dt.toJSDate());
   }
   formatToParts() {
-    return this.dtf.formatToParts(this.dt.toJSDate());
+    const parts = this.dtf.formatToParts(this.dt.toJSDate());
+    if (this.originalZone) {
+      return parts.map(part => {
+        if (part.type === "timeZoneName") {
+          const offsetName = this.originalZone.offsetName(this.dt.ts, {
+            locale: this.dt.locale,
+            format: this.opts.timeZoneName
+          });
+          return {
+            ...part,
+            value: offsetName
+          };
+        } else {
+          return part;
+        }
+      });
+    }
+    return parts;
   }
   resolvedOptions() {
     return this.dtf.resolvedOptions();
@@ -25586,7 +27232,10 @@ function objToLocalTS(obj) {
   // for legacy reasons, years between 0 and 99 are interpreted as 19XX; revert that
   if (obj.year < 100 && obj.year >= 0) {
     d = new Date(d);
-    d.setUTCFullYear(d.getUTCFullYear() - 1900);
+    // set the month and day again, this is necessary because year 2000 is a leap year, but year 100 is not
+    // so if obj.year is in 99, but obj.day makes it roll over into year 100,
+    // the calculations done by Date.UTC are using year 2000 - which is incorrect
+    d.setUTCFullYear(obj.year, obj.month - 1, obj.day);
   }
   return +d;
 }
@@ -25818,6 +27467,9 @@ class Formatter {
     return new Formatter(locale, opts);
   }
   static parseFormat(fmt) {
+    // white-space is always considered a literal in user-provided formats
+    // the " " token has a special meaning (see unitForToken)
+
     let current = null,
       currentFull = "",
       bracketed = false;
@@ -25827,7 +27479,7 @@ class Formatter {
       if (c === "'") {
         if (currentFull.length > 0) {
           splits.push({
-            literal: bracketed,
+            literal: bracketed || /^\s+$/.test(currentFull),
             val: currentFull
           });
         }
@@ -25841,7 +27493,7 @@ class Formatter {
       } else {
         if (currentFull.length > 0) {
           splits.push({
-            literal: false,
+            literal: /^\s+$/.test(currentFull),
             val: currentFull
           });
         }
@@ -25851,7 +27503,7 @@ class Formatter {
     }
     if (currentFull.length > 0) {
       splits.push({
-        literal: bracketed,
+        literal: bracketed || /^\s+$/.test(currentFull),
         val: currentFull
       });
     }
@@ -27579,7 +29231,7 @@ class Interval {
     if (!this.isValid) return NaN;
     const start = this.start.startOf(unit),
       end = this.end.startOf(unit);
-    return Math.floor(end.diff(start, unit).get(unit)) + 1;
+    return Math.floor(end.diff(start, unit).get(unit)) + (end.valueOf() !== this.end.valueOf());
   }
 
   /**
@@ -28445,6 +30097,10 @@ function unitForToken(token, loc) {
         // because we don't have any way to figure out what they are
         case "z":
           return simple(/[a-z_+-/]{1,256}?/i);
+        // this special-case "token" represents a place where a macro-token expanded into a white-space literal
+        // in this case we accept any non-newline white-space
+        case " ":
+          return simple(/[^\S\n\r]/);
         default:
           return literal(t);
       }
@@ -28499,9 +30155,10 @@ function tokenForPart(part, formatOpts) {
     value
   } = part;
   if (type === "literal") {
+    const isSpace = /^\s+$/.test(value);
     return {
-      literal: true,
-      val: value
+      literal: !isSpace,
+      val: isSpace ? " " : value
     };
   }
   const style = formatOpts[type];
@@ -28976,7 +30633,7 @@ function parseDataToDateTime(parsed, parsedZone, opts, format, text, specificOff
     setZone,
     zone
   } = opts;
-  if (parsed && Object.keys(parsed).length !== 0) {
+  if (parsed && Object.keys(parsed).length !== 0 || parsedZone) {
     const interpretationZone = parsedZone || zone,
       inst = DateTime.fromObject(parsed, {
         ...opts,
@@ -31023,7 +32680,7 @@ function friendlyDateTime(dateTimeish) {
   }
 }
 
-const VERSION = "3.2.1";
+const VERSION = "3.3.0";
 
 exports.DateTime = DateTime;
 exports.Duration = Duration;