@nmshd/content 2.3.1 → 2.3.3

package/lib-web/nmshd.content.js

@@ -301,6 +301,79 @@ var AttributeValues;
 
 /***/ }),
 
+/***/ "./dist/attributes/IQLQuery.js":
+/*!*************************************!*\
+  !*** ./dist/attributes/IQLQuery.js ***!
+  \*************************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.IQLQuery = void 0;
+const ts_serval_1 = __webpack_require__(/*! @js-soft/ts-serval */ "@js-soft/ts-serval");
+const Iql = __importStar(__webpack_require__(/*! @nmshd/iql */ "./node_modules/@nmshd/iql/dist/src/index.js"));
+const AbstractAttributeQuery_1 = __webpack_require__(/*! ./AbstractAttributeQuery */ "./dist/attributes/AbstractAttributeQuery.js");
+let IQLQuery = class IQLQuery extends AbstractAttributeQuery_1.AbstractAttributeQuery {
+    static from(value) {
+        return this.fromAny(value);
+    }
+    toJSON(verbose, serializeAsString) {
+        return super.toJSON(verbose, serializeAsString);
+    }
+};
+__decorate([
+    (0, ts_serval_1.serialize)(),
+    (0, ts_serval_1.validate)({
+        max: 4096,
+        customValidator: (v) => {
+            const result = Iql.validate(v);
+            return !result.isValid
+                ? `invalid IQL query at character offset ${result.error?.location.start.column}`
+                : undefined;
+        }
+    }),
+    __metadata("design:type", String)
+], IQLQuery.prototype, "queryString", void 0);
+IQLQuery = __decorate([
+    (0, ts_serval_1.type)("IQLQuery")
+], IQLQuery);
+exports.IQLQuery = IQLQuery;
+//# sourceMappingURL=IQLQuery.js.map
+
+/***/ }),
+
 /***/ "./dist/attributes/IdentityAttribute.js":
 /*!**********************************************!*\
   !*** ./dist/attributes/IdentityAttribute.js ***!
@@ -2120,14 +2193,15 @@ __exportStar(__webpack_require__(/*! ./AbstractAttributeQuery */ "./dist/attribu
 __exportStar(__webpack_require__(/*! ./AbstractAttributeValue */ "./dist/attributes/AbstractAttributeValue.js"), exports);
 __exportStar(__webpack_require__(/*! ./AbstractComplexValue */ "./dist/attributes/AbstractComplexValue.js"), exports);
 __exportStar(__webpack_require__(/*! ./AttributeValueTypes */ "./dist/attributes/AttributeValueTypes.js"), exports);
-__exportStar(__webpack_require__(/*! ./constants */ "./dist/attributes/constants/index.js"), exports);
-__exportStar(__webpack_require__(/*! ./hints */ "./dist/attributes/hints/index.js"), exports);
+__exportStar(__webpack_require__(/*! ./IQLQuery */ "./dist/attributes/IQLQuery.js"), exports);
 __exportStar(__webpack_require__(/*! ./IdentityAttribute */ "./dist/attributes/IdentityAttribute.js"), exports);
 __exportStar(__webpack_require__(/*! ./IdentityAttributeQuery */ "./dist/attributes/IdentityAttributeQuery.js"), exports);
 __exportStar(__webpack_require__(/*! ./RelationshipAttribute */ "./dist/attributes/RelationshipAttribute.js"), exports);
 __exportStar(__webpack_require__(/*! ./RelationshipAttributeConfidentiality */ "./dist/attributes/RelationshipAttributeConfidentiality.js"), exports);
 __exportStar(__webpack_require__(/*! ./RelationshipAttributeQuery */ "./dist/attributes/RelationshipAttributeQuery.js"), exports);
 __exportStar(__webpack_require__(/*! ./ThirdPartyRelationshipAttributeQuery */ "./dist/attributes/ThirdPartyRelationshipAttributeQuery.js"), exports);
+__exportStar(__webpack_require__(/*! ./constants */ "./dist/attributes/constants/index.js"), exports);
+__exportStar(__webpack_require__(/*! ./hints */ "./dist/attributes/hints/index.js"), exports);
 __exportStar(__webpack_require__(/*! ./types */ "./dist/attributes/types/index.js"), exports);
 //# sourceMappingURL=index.js.map
 
@@ -6147,11 +6221,11 @@ const ts_serval_1 = __webpack_require__(/*! @js-soft/ts-serval */ "@js-soft/ts-s
 const crypto_1 = __webpack_require__(/*! @nmshd/crypto */ "@nmshd/crypto");
 const transport_1 = __webpack_require__(/*! @nmshd/transport */ "@nmshd/transport");
 exports.buildInformation = {
-    version: "2.3.1",
-    build: "129",
-    date: "2023-01-30T12:56:50+00:00",
-    commit: "38d80aa128a01aa87fb51340cd5c35a7f4a654e8",
-    dependencies: {"@js-soft/logging-abstractions":"^1.0.0","easy-tsnameof":"^3.0.6","mocha-param":"^2.0.1"},
+    version: "2.3.3",
+    build: "132",
+    date: "2023-07-07T14:43:20+00:00",
+    commit: "06d8af0cdd884006ca8818565990ae34f854273b",
+    dependencies: {"@js-soft/logging-abstractions":"^1.0.0","@nmshd/iql":"^0.0.1","easy-tsnameof":"^3.0.6","mocha-param":"^2.0.1"},
     libraries: {
         serval: ts_serval_1.buildInformation,
         crypto: crypto_1.buildInformation,
@@ -6972,7 +7046,7 @@ let ProposeAttributeRequestItem = ProposeAttributeRequestItem_1 = class ProposeA
     }
 };
 __decorate([
-    (0, ts_serval_1.serialize)({ unionTypes: [attributes_1.IdentityAttributeQuery, attributes_1.RelationshipAttributeQuery] }),
+    (0, ts_serval_1.serialize)({ unionTypes: [attributes_1.IdentityAttributeQuery, attributes_1.RelationshipAttributeQuery, attributes_1.IQLQuery] }),
     (0, ts_serval_1.validate)(),
     __metadata("design:type", Object)
 ], ProposeAttributeRequestItem.prototype, "query", void 0);
@@ -7065,7 +7139,7 @@ let ReadAttributeRequestItem = class ReadAttributeRequestItem extends RequestIte
 };
 __decorate([
     (0, ts_serval_1.serialize)({
-        unionTypes: [attributes_1.IdentityAttributeQuery, attributes_1.RelationshipAttributeQuery, attributes_1.ThirdPartyRelationshipAttributeQuery]
+        unionTypes: [attributes_1.IdentityAttributeQuery, attributes_1.RelationshipAttributeQuery, attributes_1.ThirdPartyRelationshipAttributeQuery, attributes_1.IQLQuery]
     }),
     (0, ts_serval_1.validate)(),
     __metadata("design:type", Object)
@@ -7678,6 +7752,1572 @@ __exportStar(__webpack_require__(/*! ./ResponseItemResult */ "./dist/requests/re
 
 /***/ }),
 
+/***/ "./node_modules/@nmshd/iql/dist/generated/iql.js":
+/*!*******************************************************!*\
+  !*** ./node_modules/@nmshd/iql/dist/generated/iql.js ***!
+  \*******************************************************/
+/***/ ((module) => {
+
+// 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);
+                }
+            }
+            while (s4 !== peg$FAILED) {
+                s3.push(s4);
+                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);
+                    }
+                }
+            }
+            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 s0;
+    }
+    function peg$parse_() {
+        var s0, s1;
+        peg$silentFails++;
+        if (peg$r8.test(input.charAt(peg$currPos))) {
+            s0 = input.charAt(peg$currPos);
+            peg$currPos++;
+        }
+        else {
+            s0 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e23);
+            }
+        }
+        peg$silentFails--;
+        if (s0 === peg$FAILED) {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) {
+                peg$fail(peg$e22);
+            }
+        }
+        return s0;
+    }
+    peg$result = peg$startRuleFunction();
+    if (peg$result !== peg$FAILED && peg$currPos === input.length) {
+        return peg$result;
+    }
+    else {
+        if (peg$result !== peg$FAILED && peg$currPos < input.length) {
+            peg$fail(peg$endExpectation());
+        }
+        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));
+    }
+}
+module.exports = {
+    SyntaxError: peg$SyntaxError,
+    parse: peg$parse
+};
+//# sourceMappingURL=iql.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@nmshd/iql/dist/src/index.js":
+/*!***************************************************!*\
+  !*** ./node_modules/@nmshd/iql/dist/src/index.js ***!
+  \***************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+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.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
+
+/***/ }),
+
 /***/ "./node_modules/easy-tsnameof/dist/easy-tsnameof.esm.js":
 /*!**************************************************************!*\
   !*** ./node_modules/easy-tsnameof/dist/easy-tsnameof.esm.js ***!
@@ -7687,7 +9327,7 @@ __exportStar(__webpack_require__(/*! ./ResponseItemResult */ "./dist/requests/re
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (/* binding */ nameOf),
-/* harmony export */   "nameOf": () => (/* binding */ nameOf)
+/* harmony export */   nameOf: () => (/* binding */ nameOf)
 /* harmony export */ });
 var _handlersConfig;
 
@@ -8520,8 +10160,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.
@@ -8534,25 +10178,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
@@ -8561,10 +10207,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();
@@ -9223,7 +10893,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;
 }
@@ -9455,6 +11128,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;
@@ -9464,7 +11140,7 @@ class Formatter {
       if (c === "'") {
         if (currentFull.length > 0) {
           splits.push({
-            literal: bracketed,
+            literal: bracketed || /^\s+$/.test(currentFull),
             val: currentFull
           });
         }
@@ -9478,7 +11154,7 @@ class Formatter {
       } else {
         if (currentFull.length > 0) {
           splits.push({
-            literal: false,
+            literal: /^\s+$/.test(currentFull),
             val: currentFull
           });
         }
@@ -9488,7 +11164,7 @@ class Formatter {
     }
     if (currentFull.length > 0) {
       splits.push({
-        literal: bracketed,
+        literal: bracketed || /^\s+$/.test(currentFull),
         val: currentFull
       });
     }
@@ -11216,7 +12892,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());
   }
 
   /**
@@ -12082,6 +13758,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);
       }
@@ -12136,9 +13816,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];
@@ -12613,7 +14294,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,
@@ -14660,7 +16341,7 @@ function friendlyDateTime(dateTimeish) {
   }
 }
 
-const VERSION = "3.2.1";
+const VERSION = "3.3.0";
 
 exports.DateTime = DateTime;
 exports.Duration = Duration;