squel 5.13.0 → 6.0.5

package/dist/cjs/index.js

@@ -0,0 +1,1824 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  squel: () => core_default,
+  default: () => src_default
+});
+module.exports = __toCommonJS(exports_src);
+// package.json
+var package_default = {
+  name: "squel",
+  version: "6.0.5",
+  description: "SQL query string builder",
+  keywords: [
+    "sql",
+    "database",
+    "rdbms",
+    "query-builder",
+    "mysql",
+    "postgres",
+    "mssql"
+  ],
+  author: "Ramesh Nair <ram@hiddentao.com> (http://www.hiddentao.com/)",
+  contributors: [
+    "Ramesh Nair <ram@hiddentao.com> (http://www.hiddentao.com/)",
+    "Sergej Brjuchanov <serges@seznam.cz>"
+  ],
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/hiddentao/squel.git"
+  },
+  homepage: "https://github.com/hiddentao/squel",
+  bugs: {
+    url: "https://github.com/hiddentao/squel/issues"
+  },
+  type: "module",
+  main: "./dist/cjs/index.js",
+  module: "./dist/esm/index.js",
+  types: "./dist/types/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/types/index.d.ts",
+      import: "./dist/esm/index.js",
+      require: "./dist/cjs/index.js"
+    },
+    "./browser": "./dist/browser/squel.min.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE.md",
+    "CHANGELOG.md"
+  ],
+  engines: {
+    node: ">=18.0.0"
+  },
+  publishConfig: {
+    access: "public",
+    provenance: true
+  },
+  scripts: {
+    build: "bun run scripts/build.ts",
+    test: "bun test",
+    "test:coverage": "bun test --coverage --coverage-reporter=lcov",
+    "test:watch": "bun test --watch",
+    lint: "biome check --write ./src ./tests ./scripts",
+    format: "biome format --write ./src ./tests ./scripts",
+    check: "biome check ./src ./tests ./scripts",
+    typecheck: "tsc --noEmit",
+    prepare: "husky",
+    prepublishOnly: "bun run build && bun run test"
+  },
+  dependencies: {},
+  devDependencies: {
+    "@biomejs/biome": "^1.9.4",
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@types/bun": "latest",
+    "@types/node": "^22.0.0",
+    "commit-and-tag-version": "^12.6.0",
+    husky: "^9.1.7",
+    typescript: "^5.3.0"
+  }
+};
+
+// src/core.ts
+function _pad(str, pad) {
+  return str.length ? str + pad : str;
+}
+function _extend(dst, ...sources) {
+  if (dst && sources) {
+    for (const src of sources) {
+      if (src && typeof src === "object") {
+        for (const key of Object.getOwnPropertyNames(src)) {
+          dst[key] = src[key];
+        }
+      }
+    }
+  }
+  return dst;
+}
+function _isPlainObject(obj) {
+  return !!obj && obj.constructor.prototype === Object.prototype;
+}
+function _isArray(obj) {
+  return !!obj && obj.constructor.prototype === Array.prototype;
+}
+function _clone(src) {
+  if (!src)
+    return src;
+  const anySrc = src;
+  if (typeof anySrc.clone === "function")
+    return anySrc.clone();
+  if (_isPlainObject(src) || _isArray(src)) {
+    const ret = new anySrc.constructor;
+    for (const key of Object.getOwnPropertyNames(src)) {
+      if (typeof anySrc[key] !== "function") {
+        ret[key] = _clone(anySrc[key]);
+      }
+    }
+    return ret;
+  }
+  return JSON.parse(JSON.stringify(src));
+}
+function registerValueHandler(handlers, type, handler) {
+  const typeofType = typeof type;
+  if (typeofType !== "function" && typeofType !== "string") {
+    throw new Error("type must be a class constructor or string");
+  }
+  if (typeof handler !== "function") {
+    throw new Error("handler must be a function");
+  }
+  for (const typeHandler of handlers) {
+    if (typeHandler.type === type) {
+      typeHandler.handler = handler;
+      return;
+    }
+  }
+  handlers.push({ type, handler });
+}
+function getValueHandler(value, localHandlers, globalHandlers) {
+  return _getValueHandler(value, localHandlers) || _getValueHandler(value, globalHandlers);
+}
+function _getValueHandler(value, handlers) {
+  for (const typeHandler of handlers) {
+    if (typeof value === typeHandler.type || typeof typeHandler.type !== "string" && value instanceof typeHandler.type) {
+      return typeHandler.handler;
+    }
+  }
+  return;
+}
+function _buildSquel(flavour = null) {
+  const cls = {
+    isSquelBuilder(obj) {
+      return !!obj && !!obj._toParamString;
+    }
+  };
+  const _shouldApplyNesting = (obj) => {
+    return !cls.isSquelBuilder(obj) || !obj.options.rawNesting;
+  };
+  cls.DefaultQueryBuilderOptions = {
+    autoQuoteTableNames: false,
+    autoQuoteFieldNames: false,
+    autoQuoteAliasNames: true,
+    useAsForTableAliasNames: false,
+    nameQuoteCharacter: "`",
+    tableAliasQuoteCharacter: "`",
+    fieldAliasQuoteCharacter: '"',
+    valueHandlers: [],
+    parameterCharacter: "?",
+    numberedParameters: false,
+    numberedParametersPrefix: "$",
+    numberedParametersStartAt: 1,
+    replaceSingleQuotes: false,
+    singleQuoteReplacement: "''",
+    separator: " ",
+    stringFormatter: null,
+    rawNesting: false
+  };
+  cls.globalValueHandlers = [];
+  cls.registerValueHandler = (type, handler) => {
+    registerValueHandler(cls.globalValueHandlers, type, handler);
+  };
+  cls.Cloneable = class {
+    clone() {
+      const newInstance = new this.constructor;
+      return _extend(newInstance, _clone(_extend({}, this)));
+    }
+  };
+  cls.BaseBuilder = class extends cls.Cloneable {
+    options;
+    constructor(options) {
+      super();
+      const defaults = JSON.parse(JSON.stringify(cls.DefaultQueryBuilderOptions));
+      defaults.stringFormatter = cls.DefaultQueryBuilderOptions.stringFormatter;
+      this.options = _extend(defaults, options);
+    }
+    registerValueHandler(type, handler) {
+      registerValueHandler(this.options.valueHandlers, type, handler);
+      return this;
+    }
+    _sanitizeExpression(expr) {
+      if (!cls.isSquelBuilder(expr)) {
+        if (typeof expr !== "string") {
+          throw new Error("expression must be a string or builder instance");
+        }
+      }
+      return expr;
+    }
+    _sanitizeName(value, type) {
+      if (typeof value !== "string") {
+        throw new Error(`${type} must be a string`);
+      }
+      return value;
+    }
+    _sanitizeField(item) {
+      if (!cls.isSquelBuilder(item)) {
+        return this._sanitizeName(item, "field name");
+      }
+      return item;
+    }
+    _sanitizeBaseBuilder(item) {
+      if (cls.isSquelBuilder(item))
+        return item;
+      throw new Error("must be a builder instance");
+    }
+    _sanitizeTable(item, _allowNested) {
+      if (typeof item !== "string") {
+        try {
+          return this._sanitizeBaseBuilder(item);
+        } catch (_e) {
+          throw new Error("table name must be a string or a builder");
+        }
+      }
+      return this._sanitizeName(item, "table");
+    }
+    _sanitizeTableAlias(item) {
+      return this._sanitizeName(item, "table alias");
+    }
+    _sanitizeFieldAlias(item) {
+      return this._sanitizeName(item, "field alias");
+    }
+    _sanitizeLimitOffset(value) {
+      const num = Number.parseInt(value, 10);
+      if (num < 0 || Number.isNaN(num)) {
+        throw new Error("limit/offset must be >= 0");
+      }
+      return num;
+    }
+    _sanitizeValue(item) {
+      const itemType = typeof item;
+      if (item === null) {} else if (itemType === "string" || itemType === "number" || itemType === "boolean") {} else if (cls.isSquelBuilder(item)) {} else {
+        const typeIsValid = !!getValueHandler(item, this.options.valueHandlers, cls.globalValueHandlers);
+        if (!typeIsValid) {
+          throw new Error("field value must be a string, number, boolean, null or one of the registered custom value types");
+        }
+      }
+      return item;
+    }
+    _escapeValue(value) {
+      return this.options.replaceSingleQuotes && value ? value.replace(/'/g, this.options.singleQuoteReplacement) : value;
+    }
+    _formatTableName(item) {
+      if (this.options.autoQuoteTableNames) {
+        const q = this.options.nameQuoteCharacter;
+        item = `${q}${item}${q}`;
+      }
+      return item;
+    }
+    _formatFieldAlias(item) {
+      if (this.options.autoQuoteAliasNames) {
+        const q = this.options.fieldAliasQuoteCharacter;
+        item = `${q}${item}${q}`;
+      }
+      return item;
+    }
+    _formatTableAlias(item) {
+      if (this.options.autoQuoteAliasNames) {
+        const q = this.options.tableAliasQuoteCharacter;
+        item = `${q}${item}${q}`;
+      }
+      return this.options.useAsForTableAliasNames ? `AS ${item}` : item;
+    }
+    _formatFieldName(item, formattingOptions = {}) {
+      if (this.options.autoQuoteFieldNames) {
+        const q = this.options.nameQuoteCharacter;
+        if (formattingOptions.ignorePeriodsForFieldNameQuotes) {
+          item = `${q}${item}${q}`;
+        } else {
+          item = item.split(".").map((v) => v === "*" ? v : `${q}${v}${q}`).join(".");
+        }
+      }
+      return item;
+    }
+    _formatCustomValue(value, asParam, formattingOptions) {
+      const customHandler = getValueHandler(value, this.options.valueHandlers, cls.globalValueHandlers);
+      if (customHandler) {
+        value = customHandler(value, asParam, formattingOptions);
+        if (value && value.rawNesting) {
+          return { formatted: true, rawNesting: true, value: value.value };
+        }
+      }
+      return { formatted: !!customHandler, value };
+    }
+    _formatValueForParamArray(value, formattingOptions = {}) {
+      if (_isArray(value)) {
+        return value.map((v) => this._formatValueForParamArray(v, formattingOptions));
+      }
+      return this._formatCustomValue(value, true, formattingOptions).value;
+    }
+    _formatValueForQueryString(initialValue, formattingOptions = {}) {
+      const {
+        rawNesting,
+        formatted,
+        value: fv
+      } = this._formatCustomValue(initialValue, false, formattingOptions);
+      let value = fv;
+      if (formatted) {
+        if (rawNesting)
+          return value;
+        return this._applyNestingFormatting(value, _shouldApplyNesting(initialValue));
+      }
+      if (_isArray(value)) {
+        value = value.map((v) => this._formatValueForQueryString(v));
+        value = this._applyNestingFormatting(value.join(", "), _shouldApplyNesting(value));
+      } else {
+        const typeofValue = typeof value;
+        if (value === null) {
+          value = "NULL";
+        } else if (typeofValue === "boolean") {
+          value = value ? "TRUE" : "FALSE";
+        } else if (cls.isSquelBuilder(value)) {
+          value = this._applyNestingFormatting(value.toString(), _shouldApplyNesting(value));
+        } else if (typeofValue !== "number") {
+          if (typeofValue === "string" && this.options.stringFormatter) {
+            return this.options.stringFormatter(value);
+          }
+          if (formattingOptions.dontQuote) {
+            value = `${value}`;
+          } else {
+            const escapedValue = this._escapeValue(value);
+            value = `'${escapedValue}'`;
+          }
+        }
+      }
+      return value;
+    }
+    _applyNestingFormatting(str, nesting = true) {
+      if (str && typeof str === "string" && nesting && !this.options.rawNesting) {
+        let alreadyHasBrackets = str.charAt(0) === "(" && str.charAt(str.length - 1) === ")";
+        if (alreadyHasBrackets) {
+          let idx = 0;
+          let open = 1;
+          while (str.length - 1 > ++idx) {
+            const c = str.charAt(idx);
+            if (c === "(") {
+              open++;
+            } else if (c === ")") {
+              open--;
+              if (open < 1) {
+                alreadyHasBrackets = false;
+                break;
+              }
+            }
+          }
+        }
+        if (!alreadyHasBrackets) {
+          str = `(${str})`;
+        }
+      }
+      return str;
+    }
+    _buildString(str, values, options = {}) {
+      const { nested, buildParameterized, formattingOptions } = options;
+      values = values || [];
+      str = str || "";
+      let formattedStr = "";
+      let curValue = -1;
+      const formattedValues = [];
+      const paramChar = this.options.parameterCharacter;
+      let idx = 0;
+      while (str.length > idx) {
+        if (str.substring(idx, idx + paramChar.length) === paramChar) {
+          let value = values[++curValue];
+          if (buildParameterized) {
+            if (cls.isSquelBuilder(value)) {
+              const ret = value._toParamString({
+                buildParameterized,
+                nested: true
+              });
+              formattedStr += ret.text;
+              ret.values.forEach((v) => formattedValues.push(v));
+            } else {
+              value = this._formatValueForParamArray(value, formattingOptions);
+              if (_isArray(value)) {
+                const tmpStr = value.map(() => paramChar).join(", ");
+                formattedStr += `(${tmpStr})`;
+                value.forEach((val) => formattedValues.push(val));
+              } else {
+                formattedStr += paramChar;
+                formattedValues.push(value);
+              }
+            }
+          } else {
+            formattedStr += this._formatValueForQueryString(value, formattingOptions);
+          }
+          idx += paramChar.length;
+        } else {
+          formattedStr += str.charAt(idx);
+          idx++;
+        }
+      }
+      return {
+        text: this._applyNestingFormatting(formattedStr, !!nested),
+        values: formattedValues
+      };
+    }
+    _buildManyStrings(strings, strValues, options = {}) {
+      const parts = [];
+      const totalValues = [];
+      for (let idx = 0;strings.length > idx; ++idx) {
+        const inputString = strings[idx];
+        const inputValues = strValues[idx];
+        const { text, values } = this._buildString(inputString, inputValues, {
+          buildParameterized: options.buildParameterized,
+          nested: false
+        });
+        parts.push(text);
+        values.forEach((v) => totalValues.push(v));
+      }
+      const totalStr = parts.join(this.options.separator);
+      return {
+        text: totalStr.length ? this._applyNestingFormatting(totalStr, !!options.nested) : "",
+        values: totalValues
+      };
+    }
+    _toParamString(_options) {
+      throw new Error("Not yet implemented");
+    }
+    toString(options = {}) {
+      return this._toParamString(options).text;
+    }
+    toParam(options = {}) {
+      return this._toParamString({ ...options, buildParameterized: true });
+    }
+  };
+  cls.Expression = class extends cls.BaseBuilder {
+    _nodes;
+    constructor(options) {
+      super(options);
+      this._nodes = [];
+    }
+    and(expr, ...params) {
+      expr = this._sanitizeExpression(expr);
+      this._nodes.push({ type: "AND", expr, para: params });
+      return this;
+    }
+    or(expr, ...params) {
+      expr = this._sanitizeExpression(expr);
+      this._nodes.push({ type: "OR", expr, para: params });
+      return this;
+    }
+    _toParamString(options = {}) {
+      let totalStr = [];
+      const totalValues = [];
+      for (const node of this._nodes) {
+        const { type, expr, para } = node;
+        const { text, values } = cls.isSquelBuilder(expr) ? expr._toParamString({
+          buildParameterized: options.buildParameterized,
+          nested: true
+        }) : this._buildString(expr, para, {
+          buildParameterized: options.buildParameterized
+        });
+        if (totalStr.length)
+          totalStr.push(type);
+        totalStr.push(text);
+        values.forEach((v) => totalValues.push(v));
+      }
+      totalStr = totalStr.join(" ");
+      return {
+        text: this._applyNestingFormatting(totalStr, !!options.nested),
+        values: totalValues
+      };
+    }
+  };
+  cls.Case = class extends cls.BaseBuilder {
+    _fieldName = null;
+    _cases;
+    _elseValue = null;
+    constructor(fieldName, options = {}) {
+      super(options);
+      let name = null;
+      if (_isPlainObject(fieldName)) {
+        options = fieldName;
+      } else if (fieldName) {
+        name = this._sanitizeField(fieldName);
+      }
+      this._fieldName = name;
+      this.options = _extend(Object.assign({}, cls.DefaultQueryBuilderOptions), options);
+      this._cases = [];
+    }
+    when(expression, ...values) {
+      this._cases.unshift({ expression, values: values || [] });
+      return this;
+    }
+    then(result) {
+      if (this._cases.length === 0) {
+        throw new Error("when() needs to be called first");
+      }
+      this._cases[0].result = result;
+      return this;
+    }
+    else(elseValue) {
+      this._elseValue = elseValue;
+      return this;
+    }
+    _toParamString(options = {}) {
+      let totalStr = "";
+      const totalValues = [];
+      for (const { expression, values, result } of this._cases) {
+        totalStr = _pad(totalStr, " ");
+        const ret = this._buildString(expression, values, {
+          buildParameterized: options.buildParameterized,
+          nested: true
+        });
+        totalStr += `WHEN ${ret.text} THEN ${this._formatValueForQueryString(result)}`;
+        ret.values.forEach((v) => totalValues.push(v));
+      }
+      if (totalStr.length) {
+        totalStr += ` ELSE ${this._formatValueForQueryString(this._elseValue)} END`;
+        if (this._fieldName)
+          totalStr = `${this._fieldName} ${totalStr}`;
+        totalStr = `CASE ${totalStr}`;
+      } else {
+        totalStr = this._formatValueForQueryString(this._elseValue);
+      }
+      return { text: totalStr, values: totalValues };
+    }
+  };
+  cls.Block = class extends cls.BaseBuilder {
+    constructor(options) {
+      super(options);
+    }
+    exposedMethods() {
+      const ret = {};
+      let obj = this;
+      while (obj) {
+        for (const prop of Object.getOwnPropertyNames(obj)) {
+          if (prop !== "constructor" && typeof obj[prop] === "function" && prop.charAt(0) !== "_" && !cls.Block.prototype[prop]) {
+            ret[prop] = obj[prop];
+          }
+        }
+        obj = Object.getPrototypeOf(obj);
+      }
+      return ret;
+    }
+  };
+  cls.StringBlock = class extends cls.Block {
+    _str;
+    constructor(options, str) {
+      super(options);
+      this._str = str;
+    }
+    _toParamString(_options = {}) {
+      return { text: this._str, values: [] };
+    }
+  };
+  cls.FunctionBlock = class extends cls.Block {
+    _strings;
+    _values;
+    constructor(options) {
+      super(options);
+      this._strings = [];
+      this._values = [];
+    }
+    function(str, ...values) {
+      this._strings.push(str);
+      this._values.push(values);
+    }
+    _toParamString(options = {}) {
+      return this._buildManyStrings(this._strings, this._values, options);
+    }
+  };
+  cls.registerValueHandler(cls.FunctionBlock, (value, asParam = false) => {
+    return asParam ? value.toParam() : value.toString();
+  });
+  cls.AbstractTableBlock = class extends cls.Block {
+    _tables;
+    constructor(options, _prefix) {
+      super(options);
+      this._tables = [];
+    }
+    _table(table, alias = null) {
+      alias = alias ? this._sanitizeTableAlias(alias) : alias;
+      table = this._sanitizeTable(table);
+      if (this.options.singleTable)
+        this._tables = [];
+      this._tables.push({ table, alias });
+    }
+    _hasTable() {
+      return this._tables.length > 0;
+    }
+    _toParamString(options = {}) {
+      let totalStr = "";
+      const totalValues = [];
+      if (this._hasTable()) {
+        for (const { table, alias } of this._tables) {
+          totalStr = _pad(totalStr, ", ");
+          let tableStr;
+          if (cls.isSquelBuilder(table)) {
+            const { text, values } = table._toParamString({
+              buildParameterized: options.buildParameterized,
+              nested: true
+            });
+            tableStr = text;
+            values.forEach((v) => totalValues.push(v));
+          } else {
+            tableStr = this._formatTableName(table);
+          }
+          if (alias)
+            tableStr += ` ${this._formatTableAlias(alias)}`;
+          totalStr += tableStr;
+        }
+        if (this.options.prefix)
+          totalStr = `${this.options.prefix} ${totalStr}`;
+      }
+      return { text: totalStr, values: totalValues };
+    }
+  };
+  cls.TargetTableBlock = class extends cls.AbstractTableBlock {
+    target(table) {
+      this._table(table);
+    }
+  };
+  cls.UpdateTableBlock = class extends cls.AbstractTableBlock {
+    table(table, alias = null) {
+      this._table(table, alias);
+    }
+    _toParamString(options = {}) {
+      if (!this._hasTable())
+        throw new Error("table() needs to be called");
+      return super._toParamString(options);
+    }
+  };
+  cls.FromTableBlock = class extends cls.AbstractTableBlock {
+    constructor(options) {
+      super(_extend({}, options, { prefix: "FROM" }));
+    }
+    from(table, alias = null) {
+      this._table(table, alias);
+    }
+  };
+  cls.IntoTableBlock = class extends cls.AbstractTableBlock {
+    constructor(options) {
+      super(_extend({}, options, { prefix: "INTO", singleTable: true }));
+    }
+    into(table) {
+      this._table(table);
+    }
+    _toParamString(options = {}) {
+      if (!this._hasTable())
+        throw new Error("into() needs to be called");
+      return super._toParamString(options);
+    }
+  };
+  cls.GetFieldBlock = class extends cls.Block {
+    _fields;
+    constructor(options) {
+      super(options);
+      this._fields = [];
+    }
+    fields(_fields, options = {}) {
+      if (_isArray(_fields)) {
+        for (const field of _fields) {
+          this.field(field, null, options);
+        }
+      } else {
+        for (const field in _fields) {
+          const alias = _fields[field];
+          this.field(field, alias, options);
+        }
+      }
+    }
+    field(field, alias = null, options = {}) {
+      alias = alias ? this._sanitizeFieldAlias(alias) : alias;
+      field = this._sanitizeField(field);
+      const existingField = this._fields.filter((f) => f.name === field && f.alias === alias);
+      if (existingField.length)
+        return this;
+      this._fields.push({ name: field, alias, options });
+      return;
+    }
+    _toParamString(options = {}) {
+      const { queryBuilder, buildParameterized } = options;
+      let totalStr = "";
+      const totalValues = [];
+      for (const field of this._fields) {
+        totalStr = _pad(totalStr, ", ");
+        const { name, alias, options: fieldOptions } = field;
+        if (typeof name === "string") {
+          totalStr += this._formatFieldName(name, fieldOptions);
+        } else {
+          const ret = name._toParamString({
+            nested: true,
+            buildParameterized
+          });
+          totalStr += ret.text;
+          ret.values.forEach((v) => totalValues.push(v));
+        }
+        if (alias)
+          totalStr += ` AS ${this._formatFieldAlias(alias)}`;
+      }
+      if (!totalStr.length) {
+        const fromTableBlock = queryBuilder?.getBlock(cls.FromTableBlock);
+        if (fromTableBlock && fromTableBlock._hasTable()) {
+          totalStr = "*";
+        }
+      }
+      return { text: totalStr, values: totalValues };
+    }
+  };
+  cls.AbstractSetFieldBlock = class extends cls.Block {
+    _fields;
+    _values;
+    _valueOptions;
+    constructor(options) {
+      super(options);
+      this._fields = [];
+      this._values = [[]];
+      this._valueOptions = [[]];
+    }
+    _reset() {
+      this._fields = [];
+      this._values = [[]];
+      this._valueOptions = [[]];
+    }
+    _set(field, value, valueOptions = {}) {
+      if (this._values.length > 1) {
+        throw new Error("Cannot set multiple rows of fields this way.");
+      }
+      if (typeof value !== "undefined") {
+        value = this._sanitizeValue(value);
+      }
+      field = this._sanitizeField(field);
+      let index = this._fields.indexOf(field);
+      if (index === -1) {
+        this._fields.push(field);
+        index = this._fields.length - 1;
+      }
+      this._values[0][index] = value;
+      this._valueOptions[0][index] = valueOptions;
+    }
+    _setFields(fields, valueOptions = {}) {
+      if (typeof fields !== "object") {
+        throw new Error(`Expected an object but got ${typeof fields}`);
+      }
+      for (const field in fields) {
+        this._set(field, fields[field], valueOptions);
+      }
+    }
+    _setFieldsRows(fieldsRows, valueOptions = {}) {
+      if (!_isArray(fieldsRows)) {
+        throw new Error(`Expected an array of objects but got ${typeof fieldsRows}`);
+      }
+      this._reset();
+      for (let i = 0;fieldsRows.length > i; ++i) {
+        const fieldRow = fieldsRows[i];
+        for (let field in fieldRow) {
+          let value = fieldRow[field];
+          field = this._sanitizeField(field);
+          value = this._sanitizeValue(value);
+          let index = this._fields.indexOf(field);
+          if (i > 0 && index === -1) {
+            throw new Error("All fields in subsequent rows must match the fields in the first row");
+          }
+          if (index === -1) {
+            this._fields.push(field);
+            index = this._fields.length - 1;
+          }
+          if (!_isArray(this._values[i])) {
+            this._values[i] = [];
+            this._valueOptions[i] = [];
+          }
+          this._values[i][index] = value;
+          this._valueOptions[i][index] = valueOptions;
+        }
+      }
+    }
+  };
+  cls.SetFieldBlock = class extends cls.AbstractSetFieldBlock {
+    set(field, value, options) {
+      this._set(field, value, options);
+    }
+    setFields(fields, valueOptions) {
+      this._setFields(fields, valueOptions);
+    }
+    _toParamString(options = {}) {
+      const { buildParameterized } = options;
+      if (this._fields.length <= 0)
+        throw new Error("set() needs to be called");
+      let totalStr = "";
+      const totalValues = [];
+      for (let i = 0;i < this._fields.length; ++i) {
+        totalStr = _pad(totalStr, ", ");
+        let field = this._formatFieldName(this._fields[i]);
+        const value = this._values[0][i];
+        if (field.indexOf("=") < 0) {
+          field = `${field} = ${this.options.parameterCharacter}`;
+        }
+        const ret = this._buildString(field, [value], {
+          buildParameterized,
+          formattingOptions: this._valueOptions[0][i]
+        });
+        totalStr += ret.text;
+        ret.values.forEach((v) => totalValues.push(v));
+      }
+      return { text: `SET ${totalStr}`, values: totalValues };
+    }
+  };
+  cls.InsertFieldValueBlock = class extends cls.AbstractSetFieldBlock {
+    set(field, value, options = {}) {
+      this._set(field, value, options);
+    }
+    setFields(fields, valueOptions) {
+      this._setFields(fields, valueOptions);
+    }
+    setFieldsRows(fieldsRows, valueOptions) {
+      this._setFieldsRows(fieldsRows, valueOptions);
+    }
+    _toParamString(options = {}) {
+      const { buildParameterized } = options;
+      const fieldString = this._fields.map((f) => this._formatFieldName(f)).join(", ");
+      const valueStrings = [];
+      const totalValues = [];
+      for (let i = 0;i < this._values.length; ++i) {
+        valueStrings[i] = "";
+        for (let j = 0;j < this._values[i].length; ++j) {
+          const ret = this._buildString(this.options.parameterCharacter, [this._values[i][j]], {
+            buildParameterized,
+            formattingOptions: this._valueOptions[i][j]
+          });
+          ret.values.forEach((v) => totalValues.push(v));
+          valueStrings[i] = _pad(valueStrings[i], ", ");
+          valueStrings[i] += ret.text;
+        }
+      }
+      return {
+        text: fieldString.length ? `(${fieldString}) VALUES (${valueStrings.join("), (")})` : "",
+        values: totalValues
+      };
+    }
+  };
+  cls.InsertFieldsFromQueryBlock = class extends cls.Block {
+    _fields;
+    _query = null;
+    constructor(options) {
+      super(options);
+      this._fields = [];
+    }
+    fromQuery(fields, selectQuery) {
+      this._fields = fields.map((v) => this._sanitizeField(v));
+      this._query = this._sanitizeBaseBuilder(selectQuery);
+    }
+    _toParamString(options = {}) {
+      let totalStr = "";
+      let totalValues = [];
+      if (this._fields.length && this._query) {
+        const { text, values } = this._query._toParamString({
+          buildParameterized: options.buildParameterized,
+          nested: true
+        });
+        totalStr = `(${this._fields.join(", ")}) ${this._applyNestingFormatting(text)}`;
+        totalValues = values;
+      }
+      return { text: totalStr, values: totalValues };
+    }
+  };
+  cls.DistinctBlock = class extends cls.Block {
+    _useDistinct = false;
+    distinct() {
+      this._useDistinct = true;
+    }
+    _toParamString() {
+      return { text: this._useDistinct ? "DISTINCT" : "", values: [] };
+    }
+  };
+  cls.GroupByBlock = class extends cls.Block {
+    _groups;
+    constructor(options) {
+      super(options);
+      this._groups = [];
+    }
+    group(field) {
+      this._groups.push(this._sanitizeField(field));
+    }
+    _toParamString(_options = {}) {
+      return {
+        text: this._groups.length ? `GROUP BY ${this._groups.join(", ")}` : "",
+        values: []
+      };
+    }
+  };
+  cls.AbstractVerbSingleValueBlock = class extends cls.Block {
+    _value = null;
+    constructor(options) {
+      super(options);
+    }
+    _setValue(value) {
+      this._value = value !== null ? this._sanitizeLimitOffset(value) : value;
+    }
+    _toParamString(options = {}) {
+      const expr = this._value !== null ? `${this.options.verb} ${this.options.parameterCharacter}` : "";
+      const values = this._value !== null ? [this._value] : [];
+      return this._buildString(expr, values, options);
+    }
+  };
+  cls.OffsetBlock = class extends cls.AbstractVerbSingleValueBlock {
+    constructor(options) {
+      super(_extend({}, options, { verb: "OFFSET" }));
+    }
+    offset(start) {
+      this._setValue(start);
+    }
+  };
+  cls.LimitBlock = class extends cls.AbstractVerbSingleValueBlock {
+    constructor(options) {
+      super(_extend({}, options, { verb: "LIMIT" }));
+    }
+    limit(limit) {
+      this._setValue(limit);
+    }
+  };
+  cls.AbstractConditionBlock = class extends cls.Block {
+    _conditions;
+    constructor(options) {
+      super(options);
+      this._conditions = [];
+    }
+    _condition(condition, ...values) {
+      condition = this._sanitizeExpression(condition);
+      this._conditions.push({ expr: condition, values: values || [] });
+    }
+    _toParamString(options = {}) {
+      const parts = [];
+      const totalValues = [];
+      for (const { expr, values } of this._conditions) {
+        const ret = cls.isSquelBuilder(expr) ? expr._toParamString({
+          buildParameterized: options.buildParameterized
+        }) : this._buildString(expr, values, {
+          buildParameterized: options.buildParameterized
+        });
+        if (ret.text.length)
+          parts.push(ret.text);
+        ret.values.forEach((v) => totalValues.push(v));
+      }
+      const totalStr = parts.join(") AND (");
+      return {
+        text: totalStr.length ? `${this.options.verb} (${totalStr})` : "",
+        values: totalValues
+      };
+    }
+  };
+  cls.WhereBlock = class extends cls.AbstractConditionBlock {
+    constructor(options) {
+      super(_extend({}, options, { verb: "WHERE" }));
+    }
+    where(condition, ...values) {
+      this._condition(condition, ...values);
+    }
+  };
+  cls.HavingBlock = class extends cls.AbstractConditionBlock {
+    constructor(options) {
+      super(_extend({}, options, { verb: "HAVING" }));
+    }
+    having(condition, ...values) {
+      this._condition(condition, ...values);
+    }
+  };
+  cls.OrderByBlock = class extends cls.Block {
+    _orders;
+    constructor(options) {
+      super(options);
+      this._orders = [];
+    }
+    order(field, dir, ...values) {
+      field = this._sanitizeField(field);
+      let direction;
+      if (typeof dir === "string") {
+        direction = dir;
+      } else if (dir === undefined) {
+        direction = "ASC";
+      } else if (dir === null) {
+        direction = null;
+      } else {
+        direction = dir ? "ASC" : "DESC";
+      }
+      this._orders.push({ field, dir: direction, values: values || [] });
+    }
+    _toParamString(options = {}) {
+      let totalStr = "";
+      const totalValues = [];
+      for (const { field, dir, values } of this._orders) {
+        totalStr = _pad(totalStr, ", ");
+        const ret = this._buildString(field, values, {
+          buildParameterized: options.buildParameterized
+        });
+        totalStr += ret.text;
+        if (_isArray(ret.values)) {
+          ret.values.forEach((v) => totalValues.push(v));
+        }
+        if (dir !== null)
+          totalStr += ` ${dir}`;
+      }
+      return {
+        text: totalStr.length ? `ORDER BY ${totalStr}` : "",
+        values: totalValues
+      };
+    }
+  };
+  cls.JoinBlock = class extends cls.Block {
+    _joins;
+    constructor(options) {
+      super(options);
+      this._joins = [];
+    }
+    join(table, alias = null, condition = null, type = "INNER") {
+      table = this._sanitizeTable(table, true);
+      alias = alias ? this._sanitizeTableAlias(alias) : alias;
+      condition = condition ? this._sanitizeExpression(condition) : condition;
+      this._joins.push({ type, table, alias, condition });
+    }
+    left_join(table, alias = null, condition = null) {
+      this.join(table, alias, condition, "LEFT");
+    }
+    right_join(table, alias = null, condition = null) {
+      this.join(table, alias, condition, "RIGHT");
+    }
+    outer_join(table, alias = null, condition = null) {
+      this.join(table, alias, condition, "OUTER");
+    }
+    left_outer_join(table, alias = null, condition = null) {
+      this.join(table, alias, condition, "LEFT OUTER");
+    }
+    full_join(table, alias = null, condition = null) {
+      this.join(table, alias, condition, "FULL");
+    }
+    cross_join(table, alias = null, condition = null) {
+      this.join(table, alias, condition, "CROSS");
+    }
+    _toParamString(options = {}) {
+      let totalStr = "";
+      const totalValues = [];
+      for (const { type, table, alias, condition } of this._joins) {
+        totalStr = _pad(totalStr, this.options.separator);
+        let tableStr;
+        if (cls.isSquelBuilder(table)) {
+          const ret = table._toParamString({
+            buildParameterized: options.buildParameterized,
+            nested: true
+          });
+          ret.values.forEach((v) => totalValues.push(v));
+          tableStr = ret.text;
+        } else {
+          tableStr = this._formatTableName(table);
+        }
+        totalStr += `${type} JOIN ${tableStr}`;
+        if (alias)
+          totalStr += ` ${this._formatTableAlias(alias)}`;
+        if (condition) {
+          totalStr += " ON ";
+          let ret;
+          if (cls.isSquelBuilder(condition)) {
+            ret = condition._toParamString({
+              buildParameterized: options.buildParameterized
+            });
+          } else {
+            ret = this._buildString(condition, [], {
+              buildParameterized: options.buildParameterized
+            });
+          }
+          totalStr += this._applyNestingFormatting(ret.text);
+          ret.values.forEach((v) => totalValues.push(v));
+        }
+      }
+      return { text: totalStr, values: totalValues };
+    }
+  };
+  cls.UnionBlock = class extends cls.Block {
+    _unions;
+    constructor(options) {
+      super(options);
+      this._unions = [];
+    }
+    union(table, type = "UNION") {
+      table = this._sanitizeTable(table);
+      this._unions.push({ type, table });
+    }
+    union_all(table) {
+      this.union(table, "UNION ALL");
+    }
+    _toParamString(options = {}) {
+      let totalStr = "";
+      const totalValues = [];
+      for (const { type, table } of this._unions) {
+        totalStr = _pad(totalStr, this.options.separator);
+        let tableStr;
+        if (table instanceof cls.BaseBuilder) {
+          const ret = table._toParamString({
+            buildParameterized: options.buildParameterized,
+            nested: true
+          });
+          tableStr = ret.text;
+          ret.values.forEach((v) => totalValues.push(v));
+        } else {
+          totalStr = this._formatTableName(table);
+          tableStr = "";
+        }
+        totalStr += `${type} ${tableStr}`;
+      }
+      return { text: totalStr, values: totalValues };
+    }
+  };
+  cls.QueryBuilder = class extends cls.BaseBuilder {
+    blocks;
+    constructor(options, blocks) {
+      super(options);
+      this.blocks = blocks || [];
+      for (const block of this.blocks) {
+        const exposedMethods = block.exposedMethods();
+        for (const methodName in exposedMethods) {
+          const methodBody = exposedMethods[methodName];
+          if (this[methodName] !== undefined) {
+            throw new Error(`Builder already has a builder method called: ${methodName}`);
+          }
+          ((b, name, body) => {
+            this[name] = (...args) => {
+              body.call(b, ...args);
+              return this;
+            };
+          })(block, methodName, methodBody);
+        }
+      }
+    }
+    registerValueHandler(type, handler) {
+      for (const block of this.blocks) {
+        block.registerValueHandler(type, handler);
+      }
+      super.registerValueHandler(type, handler);
+      return this;
+    }
+    updateOptions(options) {
+      this.options = _extend(this.options, options);
+      for (const block of this.blocks) {
+        block.options = _extend(block.options, options);
+      }
+    }
+    _toParamString(options = {}) {
+      const opts = _extend({}, this.options, options);
+      const blockResults = this.blocks.map((b) => b._toParamString({
+        buildParameterized: opts.buildParameterized,
+        queryBuilder: this
+      }));
+      const blockTexts = blockResults.map((b) => b.text);
+      const blockValues = blockResults.map((b) => b.values);
+      let totalStr = blockTexts.filter((v) => v.length > 0).join(opts.separator);
+      const totalValues = [];
+      blockValues.forEach((block) => block.forEach((value) => totalValues.push(value)));
+      if (!opts.nested) {
+        if (opts.numberedParameters) {
+          let i = opts.numberedParametersStartAt !== undefined ? opts.numberedParametersStartAt : 1;
+          const regex = opts.parameterCharacter.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+          totalStr = totalStr.replace(new RegExp(regex, "g"), () => {
+            return `${opts.numberedParametersPrefix}${i++}`;
+          });
+        }
+      }
+      return {
+        text: this._applyNestingFormatting(totalStr, !!opts.nested),
+        values: totalValues
+      };
+    }
+    clone() {
+      const blockClones = this.blocks.map((v) => v.clone());
+      return new this.constructor(this.options, blockClones);
+    }
+    getBlock(blockType) {
+      return this.blocks.filter((b) => b instanceof blockType)[0];
+    }
+  };
+  cls.Select = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.StringBlock(options, "SELECT"),
+        new cls.FunctionBlock(options),
+        new cls.DistinctBlock(options),
+        new cls.GetFieldBlock(options),
+        new cls.FromTableBlock(options),
+        new cls.JoinBlock(options),
+        new cls.WhereBlock(options),
+        new cls.GroupByBlock(options),
+        new cls.HavingBlock(options),
+        new cls.OrderByBlock(options),
+        new cls.LimitBlock(options),
+        new cls.OffsetBlock(options),
+        new cls.UnionBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+  cls.Update = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.StringBlock(options, "UPDATE"),
+        new cls.UpdateTableBlock(options),
+        new cls.SetFieldBlock(options),
+        new cls.WhereBlock(options),
+        new cls.OrderByBlock(options),
+        new cls.LimitBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+  cls.Delete = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.StringBlock(options, "DELETE"),
+        new cls.TargetTableBlock(options),
+        new cls.FromTableBlock(_extend({}, options, { singleTable: true })),
+        new cls.JoinBlock(options),
+        new cls.WhereBlock(options),
+        new cls.OrderByBlock(options),
+        new cls.LimitBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+  cls.Insert = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.StringBlock(options, "INSERT"),
+        new cls.IntoTableBlock(options),
+        new cls.InsertFieldValueBlock(options),
+        new cls.InsertFieldsFromQueryBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+  const _squel = {
+    VERSION: package_default.version,
+    flavour,
+    expr: (options) => new cls.Expression(options),
+    case: (name, options) => new cls.Case(name, options),
+    select: (options, blocks) => new cls.Select(options, blocks),
+    update: (options, blocks) => new cls.Update(options, blocks),
+    insert: (options, blocks) => new cls.Insert(options, blocks),
+    delete: (options, blocks) => new cls.Delete(options, blocks),
+    str: (...args) => {
+      const inst = new cls.FunctionBlock;
+      inst.function(...args);
+      return inst;
+    },
+    rstr: (...args) => {
+      const inst = new cls.FunctionBlock({ rawNesting: true });
+      inst.function(...args);
+      return inst;
+    },
+    registerValueHandler: cls.registerValueHandler
+  };
+  _squel.remove = _squel.delete;
+  _squel.cls = cls;
+  return _squel;
+}
+var squel = _buildSquel();
+squel.flavours = {};
+squel.useFlavour = function useFlavour(f = null) {
+  if (!f)
+    return squel;
+  if (squel.flavours[f] instanceof Function) {
+    const s = _buildSquel(f);
+    squel.flavours[f].call(null, s);
+    s.flavours = squel.flavours;
+    s.useFlavour = squel.useFlavour;
+    return s;
+  }
+  throw new Error(`Flavour not available: ${f}`);
+};
+var core_default = squel;
+
+// src/mysql.ts
+squel.flavours.mysql = (_squel) => {
+  const cls = _squel.cls;
+  cls.MysqlOnDuplicateKeyUpdateBlock = class extends cls.AbstractSetFieldBlock {
+    onDupUpdate(field, value, options) {
+      this._set(field, value, options);
+    }
+    _toParamString(options = {}) {
+      let totalStr = "";
+      const totalValues = [];
+      for (let i = 0;i < this._fields.length; ++i) {
+        totalStr = _pad(totalStr, ", ");
+        const field = this._fields[i];
+        const value = this._values[0][i];
+        const valueOptions = this._valueOptions[0][i];
+        if (typeof value === "undefined") {
+          totalStr += field;
+        } else {
+          const ret = this._buildString(`${field} = ${this.options.parameterCharacter}`, [value], {
+            buildParameterized: options.buildParameterized,
+            formattingOptions: valueOptions
+          });
+          totalStr += ret.text;
+          ret.values.forEach((v) => totalValues.push(v));
+        }
+      }
+      return {
+        text: !totalStr.length ? "" : `ON DUPLICATE KEY UPDATE ${totalStr}`,
+        values: totalValues
+      };
+    }
+  };
+  cls.Insert = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.StringBlock(options, "INSERT"),
+        new cls.IntoTableBlock(options),
+        new cls.InsertFieldValueBlock(options),
+        new cls.InsertFieldsFromQueryBlock(options),
+        new cls.MysqlOnDuplicateKeyUpdateBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+  cls.Replace = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.StringBlock(options, "REPLACE"),
+        new cls.IntoTableBlock(options),
+        new cls.InsertFieldValueBlock(options),
+        new cls.InsertFieldsFromQueryBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+  _squel.replace = (options, blocks) => new cls.Replace(options, blocks);
+};
+
+// src/postgres.ts
+squel.flavours.postgres = (_squel) => {
+  const cls = _squel.cls;
+  cls.DefaultQueryBuilderOptions.numberedParameters = true;
+  cls.DefaultQueryBuilderOptions.numberedParametersStartAt = 1;
+  cls.DefaultQueryBuilderOptions.autoQuoteAliasNames = false;
+  cls.DefaultQueryBuilderOptions.useAsForTableAliasNames = true;
+  cls.PostgresOnConflictKeyUpdateBlock = class extends cls.AbstractSetFieldBlock {
+    _onConflict;
+    _dupFields;
+    constructor(options) {
+      super(options);
+      this._onConflict = false;
+      this._dupFields = [];
+    }
+    onConflict(conflictFields, fields) {
+      this._onConflict = true;
+      if (!conflictFields)
+        return;
+      if (!_isArray(conflictFields)) {
+        conflictFields = [conflictFields];
+      }
+      this._dupFields = conflictFields.map(this._sanitizeField.bind(this));
+      if (fields) {
+        Object.keys(fields).forEach((key) => {
+          this._set(key, fields[key]);
+        });
+      }
+    }
+    _toParamString(options = {}) {
+      let totalStr = "";
+      const totalValues = [];
+      for (let i = 0;i < this._fields.length; ++i) {
+        totalStr = _pad(totalStr, ", ");
+        const field = this._fields[i];
+        const value = this._values[0][i];
+        const valueOptions = this._valueOptions[0][i];
+        if (typeof value === "undefined") {
+          totalStr += field;
+        } else {
+          const ret = this._buildString(`${field} = ${this.options.parameterCharacter}`, [value], {
+            buildParameterized: options.buildParameterized,
+            formattingOptions: valueOptions
+          });
+          totalStr += ret.text;
+          ret.values.forEach((v) => totalValues.push(v));
+        }
+      }
+      const returned = { text: "", values: totalValues };
+      if (this._onConflict) {
+        const conflictFields = this._dupFields.length ? `(${this._dupFields.join(", ")}) ` : "";
+        const action = totalStr.length ? `UPDATE SET ${totalStr}` : "NOTHING";
+        returned.text = `ON CONFLICT ${conflictFields}DO ${action}`;
+      }
+      return returned;
+    }
+  };
+  cls.ReturningBlock = class extends cls.Block {
+    _fields;
+    constructor(options) {
+      super(options);
+      this._fields = [];
+    }
+    returning(field, alias = null, options = {}) {
+      alias = alias ? this._sanitizeFieldAlias(alias) : alias;
+      field = this._sanitizeField(field);
+      const existingField = this._fields.filter((f) => f.name === field && f.alias === alias);
+      if (existingField.length)
+        return this;
+      this._fields.push({ name: field, alias, options });
+    }
+    _toParamString(options = {}) {
+      const { buildParameterized } = options;
+      let totalStr = "";
+      const totalValues = [];
+      for (const field of this._fields) {
+        totalStr = _pad(totalStr, ", ");
+        const { name, alias, options: fieldOptions } = field;
+        if (typeof name === "string") {
+          totalStr += this._formatFieldName(name, fieldOptions);
+        } else {
+          const ret = name._toParamString({ nested: true, buildParameterized });
+          totalStr += ret.text;
+          ret.values.forEach((v) => totalValues.push(v));
+        }
+        if (alias)
+          totalStr += ` AS ${this._formatFieldAlias(alias)}`;
+      }
+      return {
+        text: totalStr.length > 0 ? `RETURNING ${totalStr}` : "",
+        values: totalValues
+      };
+    }
+  };
+  cls.WithBlock = class extends cls.Block {
+    _tables;
+    constructor(options) {
+      super(options);
+      this._tables = [];
+    }
+    with(alias, table) {
+      this._tables.push({ alias, table });
+    }
+    _toParamString(options = {}) {
+      const parts = [];
+      const values = [];
+      for (const { alias, table } of this._tables) {
+        const ret = table._toParamString({
+          buildParameterized: options.buildParameterized,
+          nested: true
+        });
+        parts.push(`${alias} AS ${ret.text}`);
+        ret.values.forEach((v) => values.push(v));
+      }
+      return {
+        text: parts.length ? `WITH ${parts.join(", ")}` : "",
+        values
+      };
+    }
+  };
+  cls.DistinctOnBlock = class extends cls.Block {
+    _useDistinct = false;
+    _distinctFields;
+    constructor(options) {
+      super(options);
+      this._distinctFields = [];
+    }
+    distinct(...fields) {
+      this._useDistinct = true;
+      fields.forEach((field) => {
+        this._distinctFields.push(this._sanitizeField(field));
+      });
+    }
+    _toParamString() {
+      let text = "";
+      if (this._useDistinct) {
+        text = "DISTINCT";
+        if (this._distinctFields.length) {
+          text += ` ON (${this._distinctFields.join(", ")})`;
+        }
+      }
+      return { text, values: [] };
+    }
+  };
+  cls.Select = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.WithBlock(options),
+        new cls.StringBlock(options, "SELECT"),
+        new cls.FunctionBlock(options),
+        new cls.DistinctOnBlock(options),
+        new cls.GetFieldBlock(options),
+        new cls.FromTableBlock(options),
+        new cls.JoinBlock(options),
+        new cls.WhereBlock(options),
+        new cls.GroupByBlock(options),
+        new cls.HavingBlock(options),
+        new cls.OrderByBlock(options),
+        new cls.LimitBlock(options),
+        new cls.OffsetBlock(options),
+        new cls.UnionBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+  cls.Insert = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.WithBlock(options),
+        new cls.StringBlock(options, "INSERT"),
+        new cls.IntoTableBlock(options),
+        new cls.InsertFieldValueBlock(options),
+        new cls.InsertFieldsFromQueryBlock(options),
+        new cls.PostgresOnConflictKeyUpdateBlock(options),
+        new cls.ReturningBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+  cls.Update = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.WithBlock(options),
+        new cls.StringBlock(options, "UPDATE"),
+        new cls.UpdateTableBlock(options),
+        new cls.SetFieldBlock(options),
+        new cls.FromTableBlock(options),
+        new cls.WhereBlock(options),
+        new cls.OrderByBlock(options),
+        new cls.LimitBlock(options),
+        new cls.ReturningBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+  cls.Delete = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.WithBlock(options),
+        new cls.StringBlock(options, "DELETE"),
+        new cls.TargetTableBlock(options),
+        new cls.FromTableBlock({ ...options, singleTable: true }),
+        new cls.JoinBlock(options),
+        new cls.WhereBlock(options),
+        new cls.OrderByBlock(options),
+        new cls.LimitBlock(options),
+        new cls.ReturningBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+};
+
+// src/mssql.ts
+squel.flavours.mssql = (_squel) => {
+  const cls = _squel.cls;
+  cls.DefaultQueryBuilderOptions.replaceSingleQuotes = true;
+  cls.DefaultQueryBuilderOptions.autoQuoteAliasNames = false;
+  cls.DefaultQueryBuilderOptions.numberedParametersPrefix = "@";
+  _squel.registerValueHandler(Date, (value) => {
+    const date = value;
+    return `'${date.getUTCFullYear()}-${date.getUTCMonth() + 1}-${date.getUTCDate()} ${date.getUTCHours()}:${date.getUTCMinutes()}:${date.getUTCSeconds()}'`;
+  });
+  cls.MssqlLimitOffsetTopBlock = class extends cls.Block {
+    _limits;
+    _offsets;
+    ParentBlock;
+    LimitBlock;
+    TopBlock;
+    OffsetBlock;
+    constructor(options) {
+      super(options);
+      this._limits = null;
+      this._offsets = null;
+      const _limit = function(max) {
+        max = this._sanitizeLimitOffset(max);
+        this._parent._limits = max;
+      };
+      this.ParentBlock = class extends cls.Block {
+        _parent;
+        constructor(parent) {
+          super(parent.options);
+          this._parent = parent;
+        }
+      };
+      this.LimitBlock = class extends this.ParentBlock {
+        limit;
+        constructor(parent) {
+          super(parent);
+          this.limit = _limit;
+        }
+        _toParamString() {
+          let str = "";
+          if (this._parent._limits && this._parent._offsets) {
+            str = `FETCH NEXT ${this._parent._limits} ROWS ONLY`;
+          }
+          return { text: str, values: [] };
+        }
+      };
+      this.TopBlock = class extends this.ParentBlock {
+        top;
+        constructor(parent) {
+          super(parent);
+          this.top = _limit;
+        }
+        _toParamString() {
+          let str = "";
+          if (this._parent._limits && !this._parent._offsets) {
+            str = `TOP (${this._parent._limits})`;
+          }
+          return { text: str, values: [] };
+        }
+      };
+      this.OffsetBlock = class extends this.ParentBlock {
+        offset(start) {
+          this._parent._offsets = this._sanitizeLimitOffset(start);
+        }
+        _toParamString() {
+          let str = "";
+          if (this._parent._offsets) {
+            str = `OFFSET ${this._parent._offsets} ROWS`;
+          }
+          return { text: str, values: [] };
+        }
+      };
+    }
+    LIMIT() {
+      return new this.LimitBlock(this);
+    }
+    TOP() {
+      return new this.TopBlock(this);
+    }
+    OFFSET() {
+      return new this.OffsetBlock(this);
+    }
+  };
+  cls.MssqlUpdateTopBlock = class extends cls.Block {
+    _limits;
+    limit;
+    top;
+    constructor(options) {
+      super(options);
+      this._limits = null;
+      const setter = (max) => {
+        this._limits = this._sanitizeLimitOffset(max);
+      };
+      this.limit = setter;
+      this.top = setter;
+    }
+    _toParamString() {
+      return {
+        text: this._limits ? `TOP (${this._limits})` : "",
+        values: []
+      };
+    }
+  };
+  cls.MssqlInsertFieldValueBlock = class extends cls.InsertFieldValueBlock {
+    _outputs;
+    constructor(options) {
+      super(options);
+      this._outputs = [];
+    }
+    output(fields) {
+      if (typeof fields === "string") {
+        this._outputs.push(`INSERTED.${this._sanitizeField(fields)}`);
+      } else {
+        fields.forEach((f) => {
+          this._outputs.push(`INSERTED.${this._sanitizeField(f)}`);
+        });
+      }
+    }
+    _toParamString(options) {
+      const ret = super._toParamString(options);
+      if (ret.text.length && this._outputs.length > 0) {
+        const innerStr = `OUTPUT ${this._outputs.join(", ")} `;
+        const valuesPos = ret.text.indexOf("VALUES");
+        ret.text = ret.text.substring(0, valuesPos) + innerStr + ret.text.substring(valuesPos);
+      }
+      return ret;
+    }
+  };
+  cls.MssqlUpdateDeleteOutputBlock = class extends cls.Block {
+    _outputs;
+    constructor(options) {
+      super(options);
+      this._outputs = [];
+    }
+    outputs(outputs) {
+      for (const output in outputs) {
+        this.output(output, outputs[output]);
+      }
+    }
+    output(output, alias = null) {
+      output = this._sanitizeField(output);
+      alias = alias ? this._sanitizeFieldAlias(alias) : alias;
+      this._outputs.push({
+        name: this.options.forDelete ? `DELETED.${output}` : `INSERTED.${output}`,
+        alias
+      });
+    }
+    _toParamString(_queryBuilder) {
+      let totalStr = "";
+      if (this._outputs.length) {
+        for (const output of this._outputs) {
+          totalStr = _pad(totalStr, ", ");
+          totalStr += output.name;
+          if (output.alias) {
+            totalStr += ` AS ${this._formatFieldAlias(output.alias)}`;
+          }
+        }
+        totalStr = `OUTPUT ${totalStr}`;
+      }
+      return { text: totalStr, values: [] };
+    }
+  };
+  cls.Select = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      const limitOffsetTopBlock = new cls.MssqlLimitOffsetTopBlock(options);
+      blocks = blocks || [
+        new cls.StringBlock(options, "SELECT"),
+        new cls.DistinctBlock(options),
+        limitOffsetTopBlock.TOP(),
+        new cls.GetFieldBlock(options),
+        new cls.FromTableBlock(options),
+        new cls.JoinBlock(options),
+        new cls.WhereBlock(options),
+        new cls.GroupByBlock(options),
+        new cls.OrderByBlock(options),
+        limitOffsetTopBlock.OFFSET(),
+        limitOffsetTopBlock.LIMIT(),
+        new cls.UnionBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+  cls.Update = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.StringBlock(options, "UPDATE"),
+        new cls.MssqlUpdateTopBlock(options),
+        new cls.UpdateTableBlock(options),
+        new cls.SetFieldBlock(options),
+        new cls.MssqlUpdateDeleteOutputBlock(options),
+        new cls.WhereBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+  cls.Delete = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.StringBlock(options, "DELETE"),
+        new cls.TargetTableBlock(options),
+        new cls.FromTableBlock(_extend({}, options, { singleTable: true })),
+        new cls.JoinBlock(options),
+        new cls.MssqlUpdateDeleteOutputBlock(_extend({}, options, { forDelete: true })),
+        new cls.WhereBlock(options),
+        new cls.OrderByBlock(options),
+        new cls.LimitBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+  cls.Insert = class extends cls.QueryBuilder {
+    constructor(options, blocks = null) {
+      blocks = blocks || [
+        new cls.StringBlock(options, "INSERT"),
+        new cls.IntoTableBlock(options),
+        new cls.MssqlInsertFieldValueBlock(options),
+        new cls.InsertFieldsFromQueryBlock(options)
+      ];
+      super(options, blocks);
+    }
+  };
+};
+
+// src/index.ts
+var src_default = core_default;
+
+//# debugId=C450E93AEB966A1364756E2164756E21