@simplysm/sd-cli 10.0.4 → 10.0.22

package/dist/sd-orm-common/src/QueryHelper.mjs

@@ -0,0 +1,627 @@
+import { QueryUnit } from "./QueryUnit";
+import { DateOnly, DateTime, NeverEntryError, Time, Uuid } from "@simplysm/sd-core-common";
+import { Queryable } from "./Queryable";
+import { SdOrmUtil } from "./utils/SdOrmUtil";
+import { CaseWhenQueryHelper } from "./CaseWhenQueryHelper";
+import { CaseQueryHelper } from "./CaseQueryHelper";
+export class QueryHelper {
+    constructor(_dialect) {
+        this._dialect = _dialect;
+    }
+    // ----------------------------------------------------
+    // WHERE
+    // ----------------------------------------------------
+    // region WHERE
+    equal(source, target) {
+        if (target === undefined) {
+            return this.isNull(source);
+        }
+        if (this._dialect === "mysql") {
+            return [this.getQueryValue(source), " <=> ", this.getQueryValue(target)];
+        }
+        else {
+            if (source instanceof QueryUnit && target instanceof QueryUnit) {
+                return this.or([
+                    this.and([this.isNull(source), this.isNull(target)]),
+                    [this.getQueryValue(source), " = ", this.getQueryValue(target)]
+                ]);
+            }
+            else {
+                return [this.getQueryValue(source), " = ", this.getQueryValue(target)];
+            }
+        }
+    }
+    notEqual(source, target) {
+        if (target === undefined) {
+            return this.isNotNull(source);
+        }
+        else if (source instanceof QueryUnit && target instanceof QueryUnit) {
+            return this.or([
+                this.and([this.isNull(source), this.isNotNull(target)]),
+                this.and([this.isNotNull(source), this.isNull(target)]),
+                [this.getQueryValue(source), " != ", this.getQueryValue(target)]
+            ]);
+        }
+        else {
+            return this.or([
+                this.isNull(source),
+                [this.getQueryValue(source), " != ", this.getQueryValue(target)]
+            ]);
+        }
+    }
+    isNull(source) {
+        return [this.getQueryValue(source), " IS ", "NULL"];
+    }
+    isNotNull(source) {
+        return [this.getQueryValue(source), " IS NOT ", "NULL"];
+    }
+    isFalse(source) {
+        return this.or([
+            this.isNull(source),
+            this.equal(source, false)
+        ]);
+    }
+    isTrue(source) {
+        return this.and([
+            this.isNotNull(source),
+            this.equal(source, true)
+        ]);
+    }
+    lessThen(source, target) {
+        return [this.getQueryValue(source), " < ", this.getQueryValue(target)];
+    }
+    lessThenOrEqual(source, target) {
+        return [this.getQueryValue(source), " <= ", this.getQueryValue(target)];
+    }
+    greaterThen(source, target) {
+        return [this.getQueryValue(source), " > ", this.getQueryValue(target)];
+    }
+    greaterThenOrEqual(source, target) {
+        return [this.getQueryValue(source), " >= ", this.getQueryValue(target)];
+    }
+    between(source, from, to) {
+        if (from != null || to != null) {
+            return this.and([
+                from != null ? this.greaterThenOrEqual(source, from) : undefined,
+                to != null ? this.lessThenOrEqual(source, to) : undefined
+            ].filterExists());
+        }
+        else {
+            return [];
+        }
+    }
+    includes(source, target) {
+        return [this.getQueryValue(source), " LIKE ", this.concat("%", target, "%").query];
+    }
+    notIncludes(source, target) {
+        return this.or([
+            this.isNull(source),
+            [this.getQueryValue(source), " NOT LIKE ", this.concat("%", target, "%").query]
+        ]);
+    }
+    like(source, target) {
+        return [this.getQueryValue(source), " LIKE ", this.getQueryValue(target)];
+    }
+    notLike(source, target) {
+        return this.or([
+            this.isNull(source),
+            [this.getQueryValue(source), " NOT LIKE ", this.getQueryValue(target)]
+        ]);
+    }
+    startsWith(source, target) {
+        return [this.getQueryValue(source), " LIKE ", this.getQueryValue(target), this._dialect === "sqlite" ? " || " : " + ", "'%'"];
+    }
+    notStartsWith(source, target) {
+        return [this.getQueryValue(source), " NOT LIKE ", this.getQueryValue(target), this._dialect === "sqlite" ? " || " : " + ", "'%'"];
+    }
+    endsWith(source, target) {
+        return [this.getQueryValue(source), " LIKE ", "'%'", this._dialect === "sqlite" ? " || " : " + ", this.getQueryValue(target)];
+    }
+    notEndsWith(source, target) {
+        return [this.getQueryValue(source), " NOT LIKE ", "'%'", this._dialect === "sqlite" ? " || " : " + ", this.getQueryValue(target)];
+    }
+    in(src, target) {
+        if (target.length < 1) {
+            return ["1", " = ", "0"];
+        }
+        else {
+            if (target.every((item) => item === undefined)) {
+                return this.isNull(src);
+            }
+            const result = [this.getQueryValue(src), " IN ", target.filterExists().mapMany((item) => [this.getQueryValue(item), ", "]).slice(0, -1)];
+            if (target.includes(undefined)) {
+                return this.or([
+                    result,
+                    this.isNull(src)
+                ]);
+            }
+            return result;
+        }
+    }
+    notIn(src, target) {
+        if (target.length < 1) {
+            return ["1", " = ", "1"];
+        }
+        else {
+            if (target.every((item) => item === undefined)) {
+                return this.isNull(src);
+            }
+            const result = [this.getQueryValue(src), " NOT IN ", target.filterExists().mapMany((item) => [this.getQueryValue(item), ", "]).slice(0, -1)];
+            if (!target.includes(undefined)) {
+                return this.or([
+                    result,
+                    this.isNull(src)
+                ]);
+            }
+            return result;
+        }
+    }
+    and(args) {
+        const result = [];
+        for (const arg of args) {
+            const queryValue = this.getQueryValue(arg);
+            if (typeof queryValue !== "undefined") {
+                result.push(...[queryValue, " AND "]);
+            }
+        }
+        return result.slice(0, -1);
+    }
+    or(args) {
+        const result = [];
+        for (const arg of args) {
+            const queryValue = this.getQueryValue(arg);
+            result.push(...[queryValue, " OR "]);
+        }
+        return result.slice(0, -1);
+    }
+    // endregion
+    // ----------------------------------------------------
+    // FIELD
+    // ----------------------------------------------------
+    // region FIELD
+    query(type, texts) {
+        const arr = [];
+        for (const text of texts) {
+            if (text instanceof QueryUnit) {
+                arr.push(this.getQueryValue(text));
+            }
+            else {
+                arr.push(text);
+            }
+        }
+        return new QueryUnit(type, arr);
+    }
+    val(value, type) {
+        const currType = type ?? SdOrmUtil.getQueryValueType(value);
+        return new QueryUnit(currType, this.getQueryValue(value));
+    }
+    is(where) {
+        return this.case(where, true).else(false);
+    }
+    dateDiff(separator, from, to) {
+        if (this._dialect === "mysql") {
+            return new QueryUnit(Number, ["TIMESTAMPDIFF(", separator, ", ", this.getQueryValue(from), ", ", this.getQueryValue(to), ")"]);
+        }
+        else {
+            return new QueryUnit(Number, ["DATEDIFF(", separator, ", ", this.getQueryValue(from), ", ", this.getQueryValue(to), ")"]);
+        }
+    }
+    dateAdd(separator, from, value) {
+        const type = SdOrmUtil.getQueryValueType(from);
+        return new QueryUnit(type, ["DATEADD(", separator, ", ", this.getQueryValue(value), ", ", this.getQueryValue(from), ")"]);
+    }
+    dateToString(value, code) {
+        if (this._dialect === "mysql") {
+            if (code === 112) {
+                return new QueryUnit(String, ["DATE_FORMAT(", this.getQueryValue(value), ", '%Y%m%d')"]);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            else if (code === 120) {
+                return new QueryUnit(String, ["DATE_FORMAT(", this.getQueryValue(value), ", '%Y-%m-%d %H:%i:%s')"]);
+            }
+            else {
+                throw new NeverEntryError();
+            }
+        }
+        else {
+            return new QueryUnit(String, ["CONVERT(NVARCHAR(25), ", this.getQueryValue(value), ", ", this.getQueryValue(code), ")"]);
+        }
+    }
+    year(value) {
+        return new QueryUnit(Number, ["YEAR(", this.getQueryValue(value), ")"]);
+    }
+    month(value) {
+        return new QueryUnit(Number, ["MONTH(", this.getQueryValue(value), ")"]);
+    }
+    ifNull(source, ...targets) {
+        let cursorQuery = this.getQueryValue(source);
+        let type = SdOrmUtil.getQueryValueType(source);
+        for (const target of targets) {
+            if (this._dialect === "mssql" || this._dialect === "mssql-azure") {
+                cursorQuery = ["ISNULL(", cursorQuery, ", ", this.getQueryValue(target), ")"];
+            }
+            else {
+                cursorQuery = ["IFNULL(", cursorQuery, ", ", this.getQueryValue(target), ")"];
+            }
+            type = type ?? SdOrmUtil.getQueryValueType(target);
+        }
+        return new QueryUnit(type, cursorQuery);
+    }
+    case(predicate, then) {
+        const type = SdOrmUtil.getQueryValueType(then);
+        const caseQueryable = new CaseQueryHelper(this, type);
+        return caseQueryable.case(predicate, then);
+    }
+    caseWhen(arg) {
+        return new CaseWhenQueryHelper(this, arg);
+    }
+    /*public greater<T extends number | Number | DateOnly | DateTime | Time>(source: TEntityValue<T>, target: TEntityValue<T>): QueryUnit<T> {
+      const type = SdOrmUtil.getQueryValueType(source);
+      if (!type) throw new TypeError();
+  
+      return this.case(this.greaterThen(source, target), source).else(target);
+    }*/
+    greatest(...args) {
+        let type;
+        for (const arg of args) {
+            type = SdOrmUtil.getQueryValueType(arg);
+            if (type)
+                break;
+        }
+        if (!type)
+            throw new TypeError();
+        return new QueryUnit(type, ["GREATEST(", ...args.mapMany((arg) => [this.getQueryValue(arg), ", "]).slice(0, -1), ")"]);
+    }
+    dataLength(arg) {
+        if (this._dialect === "mysql") {
+            return new QueryUnit(Number, ["LENGTH(", this.getQueryValue(arg), ")"]);
+        }
+        else {
+            return new QueryUnit(Number, ["DATALENGTH(", this.getQueryValue(arg), ")"]);
+        }
+    }
+    stringLength(arg) {
+        return new QueryUnit(Number, ["LEN(", this.getQueryValue(arg), ")"]);
+    }
+    cast(src, targetType) {
+        if (this._dialect === "mysql") {
+            return new QueryUnit(targetType, ["CONVERT(", this.getQueryValue(src), ", ", this.mysqlConvertType(targetType), ")"]);
+        }
+        else {
+            return new QueryUnit(targetType, ["CONVERT(", this.type(targetType), ", ", this.getQueryValue(src), ")"]);
+        }
+    }
+    left(src, num) {
+        return new QueryUnit(String, ["LEFT(", this.getQueryValue(src), ", ", this.getQueryValue(num), ")"]);
+    }
+    right(src, num) {
+        return new QueryUnit(String, ["RIGHT(", this.getQueryValue(src), ", ", this.getQueryValue(num), ")"]);
+    }
+    replace(src, from, to) {
+        return new QueryUnit(String, [
+            "REPLACE(",
+            this.getQueryValue(src),
+            ", ",
+            this.getQueryValue(from),
+            ", ",
+            this.getQueryValue(to),
+            ")"
+        ]);
+    }
+    toUpperCase(src) {
+        return new QueryUnit(String, ["UPPER(", this.getQueryValue(src), ")"]);
+    }
+    toLowerCase(src) {
+        return new QueryUnit(String, ["LOWER(", this.getQueryValue(src), ")"]);
+    }
+    abs(src) {
+        return new QueryUnit(Number, ["ABS(", this.getQueryValue(src), ")"]);
+    }
+    concat(...args) {
+        if (this._dialect === "mysql") {
+            return new QueryUnit(String, [
+                "CONCAT(",
+                ...args.mapMany((arg) => [arg !== undefined ? this.ifNull(arg, "").query : "", ", "]).slice(0, -1),
+                ")"
+            ]);
+        }
+        else {
+            return new QueryUnit(String, [
+                ...args.mapMany((arg) => [arg instanceof QueryUnit ? this.ifNull(arg, "").query : arg !== undefined ? this.getQueryValue(arg) : "", this._dialect === "sqlite" ? " || " : " + "]).slice(0, -1)
+            ]);
+        }
+    }
+    rowIndex(orderBy) {
+        return new QueryUnit(Number, ["ROW_NUMBER() OVER(ORDER BY ", orderBy.map((item) => this.getQueryValue(item[0]) + " " + item[1].toUpperCase()).join(" "), ")"]);
+    }
+    // endregion
+    // ----------------------------------------------------
+    // GROUPING FIELD
+    // ----------------------------------------------------
+    // region GROUPING FIELD
+    count(arg) {
+        if (arg !== undefined) {
+            return new QueryUnit(Number, ["COUNT(DISTINCT(", this.getQueryValue(arg), "))"]);
+        }
+        else {
+            return new QueryUnit(Number, "COUNT(*)");
+        }
+    }
+    sum(arg) {
+        return new QueryUnit(Number, ["SUM(", this.getQueryValue(arg), ")"]);
+    }
+    avg(arg) {
+        return new QueryUnit(Number, ["AVG(", this.getQueryValue(arg), ")"]);
+    }
+    round(arg, len) {
+        return new QueryUnit(Number, ["ROUND(", this.getQueryValue(arg), ", ", len, ")"]);
+    }
+    ceil(arg) {
+        return new QueryUnit(Number, ["CEILING(", this.getQueryValue(arg), ")"]);
+    }
+    floor(arg) {
+        return new QueryUnit(Number, ["FLOOR(", this.getQueryValue(arg), ")"]);
+    }
+    max(unit) {
+        const type = SdOrmUtil.getQueryValueType(unit);
+        if (!type)
+            throw new TypeError();
+        return new QueryUnit(type, ["MAX(", this.getQueryValue(unit), ")"]);
+    }
+    min(unit) {
+        const type = SdOrmUtil.getQueryValueType(unit);
+        if (!type)
+            throw new TypeError();
+        return new QueryUnit(type, ["MIN(", this.getQueryValue(unit), ")"]);
+    }
+    exists(arg) {
+        return this.case(this.greaterThen(this.ifNull(this.count(arg), 0), 0), true).else(false);
+    }
+    notExists(arg) {
+        return this.case(this.lessThenOrEqual(this.ifNull(this.count(arg), 0), 0), true).else(false);
+    }
+    getQueryValue(value) {
+        if (value instanceof QueryUnit) {
+            if (value.query instanceof Array) {
+                return this._getQueryValueArray(value.query);
+            }
+            else if (value.query instanceof QueryUnit) {
+                return this.getQueryValue(value.query);
+            }
+            else if (value.query instanceof Queryable) {
+                return this.getQueryValue(value.query);
+            }
+            else {
+                return value.query;
+            }
+        }
+        else if (typeof value === "string") {
+            if (this._dialect === "mysql" || this._dialect === "sqlite") {
+                return `'${value.replace(/'/g, "''")}'`;
+            }
+            else {
+                return `N'${value.replace(/'/g, "''")}'`;
+            }
+        }
+        else if (typeof value === "boolean") {
+            return value ? "1" : "0";
+        }
+        else if (value instanceof DateTime) {
+            if (this._dialect === "mysql") {
+                return "STR_TO_DATE('" + value.toFormatString("yyyy-MM-dd HH:mm:ss") + "', '%Y-%m-%d %H:%i:%s')";
+            }
+            else {
+                return "'" + value.toFormatString("yyyy-MM-dd HH:mm:ss") + "'";
+            }
+            // "select"할때 어차피 "fff"를 못가져오는 관계로, 아래 코드 주석
+            // (차후에 "tedious"가 업데이트 되면, 다시 "fff를 넣어야 할 수도 있음)
+            // return "'" + arg.toFormatString("yyyy-MM-dd HH:mm:ss.fff") + "'";
+        }
+        else if (value instanceof DateOnly) {
+            if (this._dialect === "mysql") {
+                return "STR_TO_DATE('" + value.toFormatString("yyyy-MM-dd") + "', '%Y-%m-%d')";
+            }
+            else {
+                return "'" + value.toFormatString("yyyy-MM-dd") + "'";
+            }
+        }
+        else if (value instanceof Time) {
+            return "'" + value.toFormatString("HH:mm:ss") + "'";
+        }
+        else if (value instanceof Buffer) {
+            return `0x${value.toString("hex")}`;
+        }
+        else if (value instanceof Uuid) {
+            if (this._dialect === "mysql") {
+                return "'" + value.toString().replace(/-/g, "") + "'";
+            }
+            else {
+                return "'" + value.toString() + "'";
+            }
+        }
+        else if (value instanceof Queryable) {
+            const selectDef = value.getSelectQueryDef();
+            if (selectDef.top !== 1) {
+                throw new Error("하나의 필드를 추출하기 위한 내부쿼리에서는 반드시 TOP 1 이 지정 되야 합니다.");
+            }
+            if (Object.keys(selectDef.select).length > 1) {
+                throw new Error("하나의 필드를 추출하기 위한 내부쿼리에서는 반드시 하나의 컬럼만 SELECT 되야 합니다.");
+            }
+            return selectDef;
+        }
+        else if (value == null) {
+            return "NULL";
+        }
+        else {
+            return value;
+        }
+    }
+    getBulkInsertQueryValue(value) {
+        if (value instanceof QueryUnit) {
+            if (value.query instanceof Array) {
+                return this._getBulkInsertQueryValueArray(value.query);
+            }
+            else if (value.query instanceof QueryUnit) {
+                return this.getBulkInsertQueryValue(value.query);
+            }
+            else if (value.query instanceof Queryable) {
+                return this.getBulkInsertQueryValue(value.query);
+            }
+            else {
+                return value.query;
+            }
+        }
+        else if (typeof value === "string") {
+            return value;
+        }
+        else if (typeof value === "boolean") {
+            return value ? 1 : 0;
+        }
+        else if (value instanceof DateTime) {
+            return value.toFormatString("yyyy-MM-dd HH:mm:ss");
+            // return value.date;
+        }
+        else if (value instanceof DateOnly) {
+            return value.toFormatString("yyyy-MM-dd");
+            //return this._dialect === "mssql" || this._dialect === "mssql-azure" ? value.date : value;
+        }
+        else if (value instanceof Time) {
+            return value.toFormatString("HH:mm:ss");
+        }
+        else if (value instanceof Buffer) {
+            return `0x${value.toString("hex")}`;
+        }
+        else if (value instanceof Uuid) {
+            return value.toString();
+        }
+        else if (value instanceof Queryable) {
+            const selectDef = value.getSelectQueryDef();
+            if (selectDef.top !== 1) {
+                throw new Error("하나의 필드를 추출하기 위한 내부쿼리에서는 반드시 TOP 1 이 지정 되야 합니다.");
+            }
+            if (typeof selectDef.select !== "undefined" || Object.keys(selectDef.select).length > 1) {
+                throw new Error("하나의 필드를 추출하기 위한 내부쿼리에서는 반드시 하나의 컬럼만 SELECT 되야 합니다.");
+            }
+            return selectDef;
+        }
+        else {
+            return value;
+        }
+    }
+    _getBulkInsertQueryValueArray(arr) {
+        return arr.map((item) => {
+            if (item instanceof Array) {
+                return this._getBulkInsertQueryValueArray(item);
+            }
+            else if (item instanceof QueryUnit) {
+                return this.getBulkInsertQueryValue(item);
+            }
+            else if (item instanceof Queryable) {
+                return this.getBulkInsertQueryValue(item);
+            }
+            else {
+                return item;
+            }
+        });
+    }
+    _getQueryValueArray(arr) {
+        return arr.map((item) => {
+            if (item instanceof Array) {
+                return this._getQueryValueArray(item);
+            }
+            else if (item instanceof QueryUnit) {
+                return this.getQueryValue(item);
+            }
+            else if (item instanceof Queryable) {
+                return this.getQueryValue(item);
+            }
+            else {
+                return item;
+            }
+        });
+    }
+    type(type) {
+        if (typeof type === "string") {
+            return type;
+        }
+        else if (type?.["type"] !== undefined) {
+            const currType = type;
+            switch (currType.type) {
+                case "TEXT":
+                    return this._dialect === "mysql" ? "LONGTEXT" : "NTEXT";
+                case "DECIMAL":
+                    return "DECIMAL(" + currType.precision + ((currType.digits == null || currType.digits === 0) ? "" : (", " + currType.digits)) + ")";
+                case "STRING":
+                    if (this._dialect === "mysql" && currType.length === "MAX") {
+                        return "LONGTEXT";
+                    }
+                    else {
+                        return "NVARCHAR(" + (currType.length ?? "255") + ")";
+                    }
+                case "FIXSTRING":
+                    return "NCHAR(" + currType.length + ")";
+                case "BINARY":
+                    if (this._dialect === "mysql") {
+                        const len = (currType.length ?? "MAX");
+                        if (len === "MAX") {
+                            return "LONGBLOB";
+                        }
+                        else {
+                            return "VARBINARY(" + len + ")";
+                        }
+                    }
+                    else {
+                        return "VARBINARY(" + (currType.length ?? "MAX") + ")";
+                    }
+                default:
+                    throw new TypeError();
+            }
+        }
+        else {
+            const currType = type;
+            switch (currType) {
+                case String:
+                    return "NVARCHAR(255)";
+                case Number:
+                    return this._dialect === "sqlite" ? "INTEGER" : "BIGINT";
+                case Boolean:
+                    return this._dialect === "mysql" ? "BOOLEAN" : "BIT";
+                case DateTime:
+                    return this._dialect === "mysql" ? "DATETIME" : "DATETIME2";
+                case DateOnly:
+                    return "DATE";
+                case Time:
+                    return "TIME";
+                case Uuid:
+                    return this._dialect === "mysql" ? "CHAR(38)" : "UNIQUEIDENTIFIER";
+                case Buffer:
+                    return this.type({ type: "BINARY", length: "MAX" });
+                default:
+                    throw new TypeError(currType !== undefined ? currType.name : "undefined");
+            }
+        }
+    }
+    mysqlConvertType(type) {
+        switch (type) {
+            case String:
+                return "CHAR";
+            case Number:
+                return "DECIMAL";
+            case Boolean:
+                return "DECIMAL";
+            case DateTime:
+                return "DATETIME";
+            case DateOnly:
+                return "DATE";
+            case Time:
+                return "TIME";
+            case Uuid:
+                return "CHAR";
+            case Buffer:
+                return "BINARY";
+            default:
+                throw new TypeError(type.name);
+        }
+    }
+}
+//# sourceMappingURL=QueryHelper.js.map

package/dist/sd-orm-common/src/QueryUnit.d.ts

@@ -0,0 +1,10 @@
+import { Type, WrappedType } from "@simplysm/sd-core-common";
+export declare class QueryUnit<T> {
+    readonly type: Type<T | WrappedType<T>> | undefined;
+    private readonly _query;
+    T: T;
+    constructor(type: Type<T | WrappedType<T>> | undefined, _query: any);
+    get query(): any;
+    notNull(): QueryUnit<NonNullable<T>>;
+    nullable(): QueryUnit<T | undefined>;
+}

package/dist/sd-orm-common/src/QueryUnit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryUnit.js","sourceRoot":"","sources":["../../../../sd-orm-common/src/QueryUnit.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,SAAS;IAGpB,YAAmC,IAA0C,EACzC,MAAW;QADZ,SAAI,GAAJ,IAAI,CAAsC;QACzC,WAAM,GAAN,MAAM,CAAK;IAC/C,CAAC;IAED,IAAW,KAAK;QACd,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAEM,OAAO;QACZ,OAAO,IAAW,CAAC;IACrB,CAAC;IAEM,QAAQ;QACb,OAAO,IAAW,CAAC;IACrB,CAAC;CACF"}

package/dist/sd-orm-common/src/QueryUnit.mjs

@@ -0,0 +1,16 @@
+export class QueryUnit {
+    constructor(type, _query) {
+        this.type = type;
+        this._query = _query;
+    }
+    get query() {
+        return this._query;
+    }
+    notNull() {
+        return this;
+    }
+    nullable() {
+        return this;
+    }
+}
+//# sourceMappingURL=QueryUnit.js.map