drizzle-kit 0.20.2 → 0.20.4-d303ac3

package/utils-studio.mjs

@@ -0,0 +1,3410 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/vendor/ansi-styles/index.js
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ANSI_BACKGROUND_OFFSET, wrapAnsi16, wrapAnsi256, wrapAnsi16m, styles, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles, ansi_styles_default;
+var init_ansi_styles = __esm({
+  "node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/vendor/ansi-styles/index.js"() {
+    ANSI_BACKGROUND_OFFSET = 10;
+    wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+    wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+    wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+    styles = {
+      modifier: {
+        reset: [0, 0],
+        // 21 isn't widely supported and 22 does the same thing
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        overline: [53, 55],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29]
+      },
+      color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        // Bright color
+        blackBright: [90, 39],
+        gray: [90, 39],
+        // Alias of `blackBright`
+        grey: [90, 39],
+        // Alias of `blackBright`
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39]
+      },
+      bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        // Bright color
+        bgBlackBright: [100, 49],
+        bgGray: [100, 49],
+        // Alias of `bgBlackBright`
+        bgGrey: [100, 49],
+        // Alias of `bgBlackBright`
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49]
+      }
+    };
+    modifierNames = Object.keys(styles.modifier);
+    foregroundColorNames = Object.keys(styles.color);
+    backgroundColorNames = Object.keys(styles.bgColor);
+    colorNames = [...foregroundColorNames, ...backgroundColorNames];
+    ansiStyles = assembleStyles();
+    ansi_styles_default = ansiStyles;
+  }
+});
+
+// node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/vendor/supports-color/index.js
+import process2 from "node:process";
+import os from "node:os";
+import tty from "node:tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if ("GITHUB_ACTIONS" in env) {
+      return 3;
+    }
+    if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var env, flagForceColor, supportsColor, supports_color_default;
+var init_supports_color = __esm({
+  "node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/vendor/supports-color/index.js"() {
+    ({ env } = process2);
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      flagForceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      flagForceColor = 1;
+    }
+    supportsColor = {
+      stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+      stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+    };
+    supports_color_default = supportsColor;
+  }
+});
+
+// node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+var init_utilities = __esm({
+  "node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/utilities.js"() {
+  }
+});
+
+// node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/index.js
+function createChalk(options) {
+  return chalkFactory(options);
+}
+var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles2, applyOptions, chalkFactory, getModelAnsi, usedModels, proto, createStyler, createBuilder, applyStyle, chalk, chalkStderr;
+var init_source = __esm({
+  "node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/index.js"() {
+    init_ansi_styles();
+    init_supports_color();
+    init_utilities();
+    init_ansi_styles();
+    ({ stdout: stdoutColor, stderr: stderrColor } = supports_color_default);
+    GENERATOR = Symbol("GENERATOR");
+    STYLER = Symbol("STYLER");
+    IS_EMPTY = Symbol("IS_EMPTY");
+    levelMapping = [
+      "ansi",
+      "ansi",
+      "ansi256",
+      "ansi16m"
+    ];
+    styles2 = /* @__PURE__ */ Object.create(null);
+    applyOptions = (object, options = {}) => {
+      if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+        throw new Error("The `level` option should be an integer from 0 to 3");
+      }
+      const colorLevel = stdoutColor ? stdoutColor.level : 0;
+      object.level = options.level === void 0 ? colorLevel : options.level;
+    };
+    chalkFactory = (options) => {
+      const chalk2 = (...strings) => strings.join(" ");
+      applyOptions(chalk2, options);
+      Object.setPrototypeOf(chalk2, createChalk.prototype);
+      return chalk2;
+    };
+    Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+    for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+      styles2[styleName] = {
+        get() {
+          const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+          Object.defineProperty(this, styleName, { value: builder });
+          return builder;
+        }
+      };
+    }
+    styles2.visible = {
+      get() {
+        const builder = createBuilder(this, this[STYLER], true);
+        Object.defineProperty(this, "visible", { value: builder });
+        return builder;
+      }
+    };
+    getModelAnsi = (model, level, type, ...arguments_) => {
+      if (model === "rgb") {
+        if (level === "ansi16m") {
+          return ansi_styles_default[type].ansi16m(...arguments_);
+        }
+        if (level === "ansi256") {
+          return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+        }
+        return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+      }
+      if (model === "hex") {
+        return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+      }
+      return ansi_styles_default[type][model](...arguments_);
+    };
+    usedModels = ["rgb", "hex", "ansi256"];
+    for (const model of usedModels) {
+      styles2[model] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
+      };
+      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+      styles2[bgModel] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
+      };
+    }
+    proto = Object.defineProperties(() => {
+    }, {
+      ...styles2,
+      level: {
+        enumerable: true,
+        get() {
+          return this[GENERATOR].level;
+        },
+        set(level) {
+          this[GENERATOR].level = level;
+        }
+      }
+    });
+    createStyler = (open, close, parent) => {
+      let openAll;
+      let closeAll;
+      if (parent === void 0) {
+        openAll = open;
+        closeAll = close;
+      } else {
+        openAll = parent.openAll + open;
+        closeAll = close + parent.closeAll;
+      }
+      return {
+        open,
+        close,
+        openAll,
+        closeAll,
+        parent
+      };
+    };
+    createBuilder = (self2, _styler, _isEmpty) => {
+      const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+      Object.setPrototypeOf(builder, proto);
+      builder[GENERATOR] = self2;
+      builder[STYLER] = _styler;
+      builder[IS_EMPTY] = _isEmpty;
+      return builder;
+    };
+    applyStyle = (self2, string) => {
+      if (self2.level <= 0 || !string) {
+        return self2[IS_EMPTY] ? "" : string;
+      }
+      let styler = self2[STYLER];
+      if (styler === void 0) {
+        return string;
+      }
+      const { openAll, closeAll } = styler;
+      if (string.includes("\x1B")) {
+        while (styler !== void 0) {
+          string = stringReplaceAll(string, styler.close, styler.open);
+          styler = styler.parent;
+        }
+      }
+      const lfIndex = string.indexOf("\n");
+      if (lfIndex !== -1) {
+        string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+      }
+      return openAll + string + closeAll;
+    };
+    Object.defineProperties(createChalk.prototype, styles2);
+    chalk = createChalk();
+    chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+  }
+});
+
+// src/serializer/index.ts
+import * as glob from "glob";
+var init_serializer = __esm({
+  "src/serializer/index.ts"() {
+    init_source();
+  }
+});
+
+// src/cli/validations/outputs.ts
+var init_outputs = __esm({
+  "src/cli/validations/outputs.ts"() {
+    init_source();
+  }
+});
+
+// src/serializer/pgSerializer.ts
+import {
+  customType,
+  PgBigInt53Builder,
+  PgBigSerial53Builder,
+  PgBooleanBuilder,
+  PgCharBuilder,
+  PgCidrBuilder,
+  PgDateBuilder,
+  PgDialect,
+  PgDoublePrecisionBuilder,
+  PgInetBuilder,
+  PgIntegerBuilder,
+  PgIntervalBuilder,
+  PgJsonbBuilder,
+  PgJsonBuilder,
+  PgMacaddr8Builder,
+  PgMacaddrBuilder,
+  PgNumericBuilder,
+  PgRealBuilder,
+  pgSchema,
+  PgSerialBuilder,
+  PgSmallIntBuilder,
+  PgSmallSerialBuilder,
+  pgTable,
+  PgTextBuilder,
+  PgTimeBuilder,
+  PgTimestampBuilder,
+  PgUUIDBuilder,
+  PgVarcharBuilder,
+  PrimaryKeyBuilder,
+  uniqueKeyName
+} from "drizzle-orm/pg-core";
+import { getTableConfig } from "drizzle-orm/pg-core";
+import { is, SQL, getTableName } from "drizzle-orm";
+var dialect, trimChar, fromDatabase, columnToDefault, defaultForColumn, toDrizzle;
+var init_pgSerializer = __esm({
+  "src/serializer/pgSerializer.ts"() {
+    init_serializer();
+    init_source();
+    init_outputs();
+    dialect = new PgDialect();
+    trimChar = (str, char) => {
+      let start = 0;
+      let end = str.length;
+      while (start < end && str[start] === char)
+        ++start;
+      while (end > start && str[end - 1] === char)
+        --end;
+      return start > 0 || end < str.length ? str.substring(start, end) : str.toString();
+    };
+    fromDatabase = async (db, tablesFilter = (table) => true, schemaFilters, progressCallback) => {
+      const result = {};
+      const internals = { tables: {} };
+      const where = schemaFilters.map((t) => `table_schema = '${t}'`).join(" or ");
+      const allTables = await db.query(
+        `SELECT table_schema, table_name FROM information_schema.tables WHERE ${where};`
+      );
+      const schemas = new Set(allTables.map((it) => it.table_schema));
+      schemas.delete("public");
+      const allSchemas = await db.query(`select s.nspname as table_schema
+  from pg_catalog.pg_namespace s
+  join pg_catalog.pg_user u on u.usesysid = s.nspowner
+  where nspname not in ('information_schema', 'pg_catalog', 'public')
+        and nspname not like 'pg_toast%'
+        and nspname not like 'pg_temp_%'
+  order by table_schema;`);
+      allSchemas.forEach((item) => {
+        if (schemaFilters.includes(item.table_schema)) {
+          schemas.add(item.table_schema);
+        }
+      });
+      let columnsCount = 0;
+      let indexesCount = 0;
+      let foreignKeysCount = 0;
+      let tableCount = 0;
+      const all = allTables.map((row) => {
+        return new Promise(async (res, rej) => {
+          const tableName = row.table_name;
+          if (!tablesFilter(tableName))
+            return res("");
+          tableCount += 1;
+          const tableSchema = row.table_schema;
+          try {
+            const columnToReturn = {};
+            const indexToReturn = {};
+            const foreignKeysToReturn = {};
+            const primaryKeys = {};
+            const uniqueConstrains = {};
+            const tableResponse = await db.query(
+              `SELECT a.attrelid::regclass::text, a.attname, is_nullable, a.attndims as array_dimensions
+        , CASE WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[])
+             AND EXISTS (
+                SELECT FROM pg_attrdef ad
+                WHERE  ad.adrelid = a.attrelid
+                AND    ad.adnum   = a.attnum
+                AND    pg_get_expr(ad.adbin, ad.adrelid)
+                     = 'nextval('''
+                    || (pg_get_serial_sequence (a.attrelid::regclass::text
+                                             , a.attname))::regclass
+                    || '''::regclass)'
+                )
+           THEN CASE a.atttypid
+                   WHEN 'int'::regtype  THEN 'serial'
+                   WHEN 'int8'::regtype THEN 'bigserial'
+                   WHEN 'int2'::regtype THEN 'smallserial'
+                END
+           ELSE format_type(a.atttypid, a.atttypmod)
+           END AS data_type, INFORMATION_SCHEMA.COLUMNS.table_name, INFORMATION_SCHEMA.COLUMNS.column_name, INFORMATION_SCHEMA.COLUMNS.column_default, INFORMATION_SCHEMA.COLUMNS.data_type as additional_dt
+   FROM  pg_attribute  a
+   JOIN INFORMATION_SCHEMA.COLUMNS ON INFORMATION_SCHEMA.COLUMNS.column_name = a.attname
+   WHERE  a.attrelid = '"${tableSchema}"."${tableName}"'::regclass and INFORMATION_SCHEMA.COLUMNS.table_name = '${tableName}'
+   AND    a.attnum > 0
+   AND    NOT a.attisdropped
+   ORDER  BY a.attnum;`
+            );
+            const tableConstraints = await db.query(
+              `SELECT c.column_name, c.data_type, constraint_type, constraint_name, constraint_schema
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.constraint_column_usage AS ccu USING (constraint_schema, constraint_name)
+      JOIN information_schema.columns AS c ON c.table_schema = tc.constraint_schema
+        AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
+      WHERE tc.table_name = '${tableName}' and constraint_schema = '${tableSchema}';`
+            );
+            columnsCount += tableResponse.length;
+            if (progressCallback) {
+              progressCallback("columns", columnsCount, "fetching");
+            }
+            const tableForeignKeys = await db.query(
+              `SELECT
+        tc.table_schema,
+        tc.constraint_name,
+        tc.table_name,
+        kcu.column_name,
+        ccu.table_schema AS foreign_table_schema,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name,
+        rc.delete_rule, rc.update_rule
+    FROM
+        information_schema.table_constraints AS tc
+        JOIN information_schema.key_column_usage AS kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage AS ccu
+          ON ccu.constraint_name = tc.constraint_name
+          AND ccu.table_schema = tc.table_schema
+        JOIN information_schema.referential_constraints AS rc
+          ON ccu.constraint_name = rc.constraint_name
+    WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name='${tableName}' and tc.table_schema='${tableSchema}';`
+            );
+            foreignKeysCount += tableForeignKeys.length;
+            if (progressCallback) {
+              progressCallback("fks", foreignKeysCount, "fetching");
+            }
+            for (const fk of tableForeignKeys) {
+              const columnFrom = fk.column_name;
+              const tableTo = fk.foreign_table_name;
+              const columnTo = fk.foreign_column_name;
+              const foreignKeyName = fk.constraint_name;
+              const onUpdate = fk.update_rule.toLowerCase();
+              const onDelete = fk.delete_rule.toLowerCase();
+              if (typeof foreignKeysToReturn[foreignKeyName] !== "undefined") {
+                foreignKeysToReturn[foreignKeyName].columnsFrom.push(columnFrom);
+                foreignKeysToReturn[foreignKeyName].columnsTo.push(columnTo);
+              } else {
+                foreignKeysToReturn[foreignKeyName] = {
+                  name: foreignKeyName,
+                  tableFrom: tableName,
+                  tableTo,
+                  columnsFrom: [columnFrom],
+                  columnsTo: [columnTo],
+                  onDelete,
+                  onUpdate
+                };
+              }
+              foreignKeysToReturn[foreignKeyName].columnsFrom = [
+                ...new Set(foreignKeysToReturn[foreignKeyName].columnsFrom)
+              ];
+              foreignKeysToReturn[foreignKeyName].columnsTo = [
+                ...new Set(foreignKeysToReturn[foreignKeyName].columnsTo)
+              ];
+            }
+            const uniqueConstrainsRows = tableConstraints.filter(
+              (mapRow) => mapRow.constraint_type === "UNIQUE"
+            );
+            for (const unqs of uniqueConstrainsRows) {
+              const columnName = unqs.column_name;
+              const constraintName = unqs.constraint_name;
+              if (typeof uniqueConstrains[constraintName] !== "undefined") {
+                uniqueConstrains[constraintName].columns.push(columnName);
+              } else {
+                uniqueConstrains[constraintName] = {
+                  columns: [columnName],
+                  nullsNotDistinct: false,
+                  name: constraintName
+                };
+              }
+            }
+            for (const columnResponse of tableResponse) {
+              const columnName = columnResponse.attname;
+              const columnAdditionalDT = columnResponse.additional_dt;
+              const columnDimensions = columnResponse.array_dimensions;
+              let columnType = columnResponse.data_type;
+              const primaryKey = tableConstraints.filter(
+                (mapRow) => columnName === mapRow.column_name && mapRow.constraint_type === "PRIMARY KEY"
+              );
+              const cprimaryKey = tableConstraints.filter(
+                (mapRow) => mapRow.constraint_type === "PRIMARY KEY"
+              );
+              if (cprimaryKey.length > 1) {
+                const tableCompositePkName = await db.query(
+                  `SELECT conname AS primary_key
+                FROM   pg_constraint 
+                WHERE  contype = 'p' 
+                AND    connamespace = '${tableSchema}'::regnamespace  
+                AND    (conrelid::regclass::text = '"${tableName}"' OR conrelid::regclass::text = '${tableName}');`
+                );
+                primaryKeys[`${tableName}_${cprimaryKey.map((pk) => pk.column_name).join("_")}`] = {
+                  name: tableCompositePkName[0].primary_key,
+                  columns: cprimaryKey.map((c) => c.column_name)
+                };
+              }
+              const defaultValue = defaultForColumn(columnResponse);
+              const isSerial = columnType === "serial";
+              let columnTypeMapped = columnType;
+              if (columnTypeMapped.startsWith("numeric(")) {
+                columnTypeMapped = columnTypeMapped.replace(",", ", ");
+              }
+              if (columnAdditionalDT === "ARRAY") {
+                if (typeof internals.tables[tableName] === "undefined") {
+                  internals.tables[tableName] = {
+                    columns: {
+                      [columnName]: {
+                        isArray: true,
+                        dimensions: columnDimensions,
+                        rawType: columnTypeMapped.substring(
+                          0,
+                          columnTypeMapped.length - 2
+                        )
+                      }
+                    }
+                  };
+                } else {
+                  if (typeof internals.tables[tableName].columns[columnName] === "undefined") {
+                    internals.tables[tableName].columns[columnName] = {
+                      isArray: true,
+                      dimensions: columnDimensions,
+                      rawType: columnTypeMapped.substring(
+                        0,
+                        columnTypeMapped.length - 2
+                      )
+                    };
+                  }
+                }
+              }
+              if (columnAdditionalDT === "ARRAY") {
+                for (let i = 1; i < Number(columnDimensions); i++) {
+                  columnTypeMapped += "[]";
+                }
+              }
+              columnTypeMapped = columnTypeMapped.replace("character varying", "varchar").replace(" without time zone", "").replace("character", "char");
+              columnTypeMapped = trimChar(columnTypeMapped, '"');
+              columnToReturn[columnName] = {
+                name: columnName,
+                type: columnTypeMapped,
+                primaryKey: primaryKey.length === 1 && cprimaryKey.length < 2,
+                // default: isSerial ? undefined : defaultValue,
+                notNull: columnResponse.is_nullable === "NO"
+              };
+              if (!isSerial && typeof defaultValue !== "undefined") {
+                columnToReturn[columnName].default = defaultValue;
+              }
+            }
+            const dbIndexes = await db.query(
+              `SELECT t.relname as table_name, i.relname AS index_name, ix.indisunique AS is_unique, a.attname AS column_name
+          FROM pg_class t
+          JOIN pg_index ix ON t.oid = ix.indrelid
+          JOIN pg_class i ON i.oid = ix.indexrelid
+          JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+          JOIN pg_namespace ns ON ns.oid = t.relnamespace
+          WHERE ns.nspname = '${tableSchema}'
+            AND t.relname = '${tableName}'
+            and ix.indisprimary = false;`
+            );
+            const dbIndexFromConstraint = await db.query(
+              `SELECT
+          idx.indexrelname AS index_name,
+          idx.relname AS table_name,
+          schemaname,
+          CASE WHEN con.conname IS NOT NULL THEN 1 ELSE 0 END AS generated_by_constraint
+        FROM
+          pg_stat_user_indexes idx
+        LEFT JOIN
+          pg_constraint con ON con.conindid = idx.indexrelid
+        WHERE idx.relname = '${tableName}' and schemaname = '${tableSchema}'
+        group by index_name, table_name,schemaname, generated_by_constraint;`
+            );
+            const idxsInConsteraint = dbIndexFromConstraint.filter((it) => it.generated_by_constraint === 1).map((it) => it.index_name);
+            for (const dbIndex of dbIndexes) {
+              const indexName2 = dbIndex.index_name;
+              const indexColumnName = dbIndex.column_name;
+              const indexIsUnique = dbIndex.is_unique;
+              if (idxsInConsteraint.includes(indexName2))
+                continue;
+              if (typeof indexToReturn[indexName2] !== "undefined") {
+                indexToReturn[indexName2].columns.push(indexColumnName);
+              } else {
+                indexToReturn[indexName2] = {
+                  name: indexName2,
+                  columns: [indexColumnName],
+                  isUnique: indexIsUnique
+                };
+              }
+            }
+            indexesCount += Object.keys(indexToReturn).length;
+            if (progressCallback) {
+              progressCallback("indexes", indexesCount, "fetching");
+            }
+            result[tableName] = {
+              name: tableName,
+              schema: tableSchema !== "public" ? tableSchema : "",
+              columns: columnToReturn,
+              indexes: indexToReturn,
+              foreignKeys: foreignKeysToReturn,
+              compositePrimaryKeys: primaryKeys,
+              uniqueConstraints: uniqueConstrains
+            };
+          } catch (e) {
+            rej(e);
+            return;
+          }
+          res("");
+        });
+      });
+      if (progressCallback) {
+        progressCallback("tables", tableCount, "done");
+      }
+      for await (const _ of all) {
+      }
+      if (progressCallback) {
+        progressCallback("columns", columnsCount, "done");
+        progressCallback("indexes", indexesCount, "done");
+        progressCallback("fks", foreignKeysCount, "done");
+      }
+      const allEnums = await db.query(
+        `select n.nspname as enum_schema,
+  t.typname as enum_name,
+  e.enumlabel as enum_value
+  from pg_type t
+  join pg_enum e on t.oid = e.enumtypid
+  join pg_catalog.pg_namespace n ON n.oid = t.typnamespace;`
+      );
+      const enumsToReturn = {};
+      for (const dbEnum of allEnums) {
+        const enumName = dbEnum.enum_name;
+        const enumValue = dbEnum.enum_value;
+        if (enumsToReturn[enumName] !== void 0 && enumsToReturn[enumName] !== null) {
+          enumsToReturn[enumName].values[enumValue] = enumValue;
+        } else {
+          enumsToReturn[enumName] = {
+            name: enumName,
+            values: { [enumValue]: enumValue }
+          };
+        }
+      }
+      if (progressCallback) {
+        progressCallback("enums", Object.keys(enumsToReturn).length, "done");
+      }
+      const schemasObject = Object.fromEntries([...schemas].map((it) => [it, it]));
+      return {
+        version: "5",
+        dialect: "pg",
+        tables: result,
+        enums: enumsToReturn,
+        schemas: schemasObject,
+        _meta: {
+          schemas: {},
+          tables: {},
+          columns: {}
+        },
+        internal: internals
+      };
+    };
+    columnToDefault = {
+      "numeric(": "::numeric",
+      // text: "::text",
+      // "character varying": "::character varying",
+      // "double precision": "::double precision",
+      // "time with time zone": "::time with time zone",
+      "time without time zone": "::time without time zone",
+      // "timestamp with time zone": "::timestamp with time zone",
+      "timestamp without time zone": "::timestamp without time zone",
+      // date: "::date",
+      // interval: "::interval",
+      // character: "::bpchar",
+      // macaddr8: "::macaddr8",
+      // macaddr: "::macaddr",
+      // inet: "::inet",
+      // cidr: "::cidr",
+      // jsonb: "::jsonb",
+      // json: "::json",
+      "character(": "::bpchar"
+    };
+    defaultForColumn = (column) => {
+      if (column.data_type === "serial" || column.data_type === "smallserial" || column.data_type === "bigserial") {
+        return void 0;
+      }
+      const hasDifferentDefaultCast = Object.keys(columnToDefault).find(
+        (it) => column.data_type.startsWith(it)
+      );
+      if (column.column_default === null) {
+        return void 0;
+      }
+      const columnDefaultAsString = column.column_default.toString();
+      if (columnDefaultAsString.endsWith(
+        hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : column.data_type
+      )) {
+        const nonPrefixPart = column.column_default.length - (hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column.data_type}`).length - 1;
+        const rt = column.column_default.toString().substring(1, nonPrefixPart);
+        if (/^-?[\d.]+(?:e-?\d+)?$/.test(rt) && !column.data_type.startsWith("numeric")) {
+          return Number(rt);
+        } else if (column.data_type === "json" || column.data_type === "jsonb") {
+          const jsonWithoutSpaces = JSON.stringify(JSON.parse(rt));
+          return `'${jsonWithoutSpaces}'${hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column.data_type}`}`;
+        } else if (column.data_type === "boolean") {
+          return column.column_default === "true";
+        } else {
+          return `'${rt}'`;
+        }
+      } else {
+        if (/^-?[\d.]+(?:e-?\d+)?$/.test(columnDefaultAsString) && !column.data_type.startsWith("numeric")) {
+          return Number(columnDefaultAsString);
+        } else if (column.data_type === "boolean") {
+          return column.column_default === "true";
+        } else {
+          return `${columnDefaultAsString}`;
+        }
+      }
+    };
+    toDrizzle = (schema, schemaName) => {
+      const tables = {};
+      Object.values(schema.tables).forEach((t) => {
+        const columns = {};
+        Object.values(t.columns).forEach((c) => {
+          const columnName = c.name;
+          const type = c.type;
+          let columnBuilder;
+          if (type === "bigint") {
+            columnBuilder = new PgBigInt53Builder(columnName);
+          } else if (type === "bigserial") {
+            columnBuilder = new PgBigSerial53Builder(columnName);
+          } else if (type === "boolean") {
+            columnBuilder = new PgBooleanBuilder(columnName);
+          } else if (type === "cidr") {
+            columnBuilder = new PgCidrBuilder(columnName);
+          } else if (type === "date") {
+            columnBuilder = new PgDateBuilder(columnName);
+          } else if (type === "double precision") {
+            columnBuilder = new PgDoublePrecisionBuilder(columnName);
+          } else if (type === "inet") {
+            columnBuilder = new PgInetBuilder(columnName);
+          } else if (type === "integer") {
+            columnBuilder = new PgIntegerBuilder(columnName);
+          } else if (type === "interval" || type.startsWith("interval ")) {
+            columnBuilder = new PgIntervalBuilder(columnName, {});
+          } else if (type === "json") {
+            columnBuilder = new PgJsonBuilder(columnName);
+          } else if (type === "jsonb") {
+            columnBuilder = new PgJsonbBuilder(columnName);
+          } else if (type === "macaddr") {
+            columnBuilder = new PgMacaddrBuilder(columnName);
+          } else if (type === "macaddr8") {
+            columnBuilder = new PgMacaddr8Builder(columnName);
+          } else if (type === "numeric" || type.startsWith("numeric(")) {
+            columnBuilder = new PgNumericBuilder(columnName);
+          } else if (type === "real") {
+            columnBuilder = new PgRealBuilder(columnName);
+          } else if (type === "serial") {
+            columnBuilder = new PgSerialBuilder(columnName);
+          } else if (type === "smallint") {
+            columnBuilder = new PgSmallIntBuilder(columnName);
+          } else if (type === "smallserial") {
+            columnBuilder = new PgSmallSerialBuilder(columnName);
+          } else if (type === "text") {
+            columnBuilder = new PgTextBuilder(columnName, {});
+          } else if (type === "time" || type.startsWith("time(") || type === "time with time zone") {
+            columnBuilder = new PgTimeBuilder(columnName, false, void 0);
+          } else if (type === "timestamp" || type.startsWith("timestamp(") || type === "timestamp with time zone") {
+            columnBuilder = new PgTimestampBuilder(columnName, false, void 0);
+          } else if (type === "uuid") {
+            columnBuilder = new PgUUIDBuilder(columnName);
+          } else if (type === "varchar" || type.startsWith("varchar(")) {
+            columnBuilder = new PgVarcharBuilder(columnName, {});
+          } else if (type === "char" || type.startsWith("char(")) {
+            columnBuilder = new PgCharBuilder(columnName, {});
+          } else {
+            columnBuilder = customType({
+              dataType() {
+                return type;
+              }
+            })(columnName);
+          }
+          if (c.notNull) {
+            columnBuilder = columnBuilder.notNull();
+          }
+          if (c.default) {
+            columnBuilder = columnBuilder.default(c.default);
+          }
+          if (c.primaryKey) {
+            columnBuilder = columnBuilder.primaryKey();
+          }
+          columns[columnName] = columnBuilder;
+        });
+        if (schemaName === "public") {
+          tables[t.name] = pgTable(t.name, columns, (cb) => {
+            const res = {};
+            Object.values(t.compositePrimaryKeys).forEach((cpk) => {
+              const gh = cpk.columns.map((c) => cb[c]);
+              res[cpk.name] = new PrimaryKeyBuilder(
+                gh,
+                cpk.name
+              );
+            });
+            return res;
+          });
+        } else {
+          tables[t.name] = pgSchema(schemaName).table(t.name, columns, (cb) => {
+            const res = {};
+            Object.values(t.compositePrimaryKeys).forEach((cpk) => {
+              const gh = cpk.columns.map((c) => cb[c]);
+              res[cpk.name] = new PrimaryKeyBuilder(
+                gh,
+                cpk.name
+              );
+            });
+            return res;
+          });
+        }
+      });
+      return tables;
+    };
+  }
+});
+
+// src/serializer/sqliteSerializer.ts
+import { getTableName as getTableName2, is as is2, SQL as SQL2 } from "drizzle-orm";
+import {
+  getTableConfig as getTableConfig2,
+  PrimaryKeyBuilder as PrimaryKeyBuilder2,
+  SQLiteBaseInteger,
+  SQLiteBlobBufferBuilder,
+  SQLiteIntegerBuilder,
+  SQLiteNumericBuilder,
+  SQLiteRealBuilder,
+  SQLiteSyncDialect,
+  sqliteTable,
+  SQLiteTextBuilder,
+  uniqueKeyName as uniqueKeyName2
+} from "drizzle-orm/sqlite-core";
+function mapSqlToSqliteType(sqlType) {
+  if ([
+    "int",
+    "integer",
+    "integer auto_increment",
+    "tinyint",
+    "smallint",
+    "mediumint",
+    "bigint",
+    "unsigned big int",
+    "int2",
+    "int8"
+  ].includes(sqlType.toLowerCase())) {
+    return "integer";
+  } else if ([
+    "character",
+    "varchar",
+    "vatying character",
+    "nchar",
+    "native character",
+    "nvarchar",
+    "text",
+    "clob"
+  ].some((it) => it.startsWith(sqlType.toLowerCase()))) {
+    return "text";
+  } else if (sqlType.toLowerCase() === "blob") {
+    return "blob";
+  } else if (["real", "double", "double precision", "float"].includes(
+    sqlType.toLowerCase()
+  )) {
+    return "real";
+  } else {
+    return "numeric";
+  }
+}
+var dialect2, fromDatabase2, toDrizzle2;
+var init_sqliteSerializer = __esm({
+  "src/serializer/sqliteSerializer.ts"() {
+    init_serializer();
+    init_outputs();
+    init_source();
+    dialect2 = new SQLiteSyncDialect();
+    fromDatabase2 = async (db, tablesFilter = (table) => true, progressCallback) => {
+      const result = {};
+      const columns = await db.query(
+        `SELECT 
+    m.name as "tableName", p.name as "columnName", p.type as "columnType", p."notnull" as "notNull", p.dflt_value as "defaultValue", p.pk as pk
+    FROM sqlite_master AS m JOIN pragma_table_info(m.name) AS p
+    WHERE m.type = 'table' and m.tbl_name != 'sqlite_sequence' and m.tbl_name != 'sqlite_stat1' and m.tbl_name != '_litestream_seq' and m.tbl_name != '_litestream_lock' and m.tbl_name != 'libsql_wasm_func_table';
+    `
+      );
+      const tablesWithSeq = [];
+      const seq = await db.query(
+        `SELECT * FROM sqlite_master WHERE name != 'sqlite_sequence' and name != 'sqlite_stat1' and name != '_litestream_seq' and name != '_litestream_lock' and sql GLOB '*[ *' || CHAR(9) || CHAR(10) || CHAR(13) || ']AUTOINCREMENT[^'']*';`
+      );
+      for (const s of seq) {
+        tablesWithSeq.push(s.name);
+      }
+      let columnsCount = 0;
+      let tablesCount = /* @__PURE__ */ new Set();
+      let indexesCount = 0;
+      let foreignKeysCount = 0;
+      const tableToPk = {};
+      for (const column of columns) {
+        if (!tablesFilter(column.tableName))
+          continue;
+        columnsCount += 1;
+        if (progressCallback) {
+          progressCallback("columns", columnsCount, "fetching");
+        }
+        const tableName = column.tableName;
+        tablesCount.add(tableName);
+        if (progressCallback) {
+          progressCallback("tables", tablesCount.size, "fetching");
+        }
+        const columnName = column.columnName;
+        const isNotNull = column.notNull === 1;
+        const columnType = column.columnType;
+        const isPrimary = column.pk !== 0;
+        const columnDefault = column.defaultValue;
+        const isAutoincrement = isPrimary && tablesWithSeq.includes(tableName);
+        if (isPrimary) {
+          if (typeof tableToPk[tableName] === "undefined") {
+            tableToPk[tableName] = [columnName];
+          } else {
+            tableToPk[tableName].push(columnName);
+          }
+        }
+        const table = result[tableName];
+        const newColumn = {
+          default: columnDefault === null ? void 0 : /^-?[\d.]+(?:e-?\d+)?$/.test(columnDefault) ? Number(columnDefault) : ["CURRENT_TIME", "CURRENT_DATE", "CURRENT_TIMESTAMP"].includes(
+            columnDefault
+          ) ? `(${columnDefault})` : columnDefault === "false" ? false : columnDefault === "true" ? true : columnDefault.startsWith("'") && columnDefault.endsWith("'") ? columnDefault : (
+            // ? columnDefault.substring(1, columnDefault.length - 1)
+            `(${columnDefault})`
+          ),
+          autoincrement: isAutoincrement,
+          name: columnName,
+          type: mapSqlToSqliteType(columnType),
+          primaryKey: false,
+          notNull: isNotNull
+        };
+        if (!table) {
+          result[tableName] = {
+            name: tableName,
+            columns: {
+              [columnName]: newColumn
+            },
+            compositePrimaryKeys: {},
+            indexes: {},
+            foreignKeys: {},
+            uniqueConstraints: {}
+          };
+        } else {
+          result[tableName].columns[columnName] = newColumn;
+        }
+      }
+      for (const [key, value] of Object.entries(tableToPk)) {
+        if (value.length > 1) {
+          value.sort();
+          result[key].compositePrimaryKeys = {
+            [`${key}_${value.join("_")}_pk`]: {
+              columns: value,
+              name: `${key}_${value.join("_")}_pk`
+            }
+          };
+        } else if (value.length === 1) {
+          result[key].columns[value[0]].primaryKey = true;
+        } else {
+        }
+      }
+      if (progressCallback) {
+        progressCallback("columns", columnsCount, "done");
+        progressCallback("tables", tablesCount.size, "done");
+      }
+      try {
+        const fks = await db.query(
+          `SELECT m.name as "tableFrom", f.id as "id", f."table" as "tableTo", f."from", f."to", f."on_update" as "onUpdate", f."on_delete" as "onDelete", f.seq as "seq"
+      FROM sqlite_master m, pragma_foreign_key_list(m.name) as f;`
+        );
+        const fkByTableName = {};
+        for (const fkRow of fks) {
+          foreignKeysCount += 1;
+          if (progressCallback) {
+            progressCallback("fks", foreignKeysCount, "fetching");
+          }
+          const tableName = fkRow.tableFrom;
+          const columnName = fkRow.from;
+          const refTableName = fkRow.tableTo;
+          const refColumnName = fkRow.to;
+          const updateRule = fkRow.onUpdate;
+          const deleteRule = fkRow.onDelete;
+          const sequence = fkRow.seq;
+          const id = fkRow.id;
+          const tableInResult = result[tableName];
+          if (typeof tableInResult === "undefined")
+            continue;
+          if (typeof fkByTableName[`${tableName}_${id}`] !== "undefined") {
+            fkByTableName[`${tableName}_${id}`].columnsFrom.push(columnName);
+            fkByTableName[`${tableName}_${id}`].columnsTo.push(refColumnName);
+          } else {
+            fkByTableName[`${tableName}_${id}`] = {
+              name: "",
+              tableFrom: tableName,
+              tableTo: refTableName,
+              columnsFrom: [columnName],
+              columnsTo: [refColumnName],
+              onDelete: deleteRule == null ? void 0 : deleteRule.toLowerCase(),
+              onUpdate: updateRule == null ? void 0 : updateRule.toLowerCase()
+            };
+          }
+          const columnsFrom = fkByTableName[`${tableName}_${id}`].columnsFrom;
+          const columnsTo = fkByTableName[`${tableName}_${id}`].columnsTo;
+          fkByTableName[`${tableName}_${id}`].name = `${tableName}_${columnsFrom.join(
+            "_"
+          )}_${refTableName}_${columnsTo.join("_")}_fk`;
+        }
+        for (const idx of Object.keys(fkByTableName)) {
+          const value = fkByTableName[idx];
+          result[value.tableFrom].foreignKeys[value.name] = value;
+        }
+      } catch (e) {
+      }
+      if (progressCallback) {
+        progressCallback("fks", foreignKeysCount, "done");
+      }
+      const idxs = await db.query(
+        `SELECT 
+    m.tbl_name as tableName,
+    il.name as indexName,
+    ii.name as columnName,
+    il.[unique] as isUnique,
+    il.seq as seq
+FROM sqlite_master AS m,
+    pragma_index_list(m.name) AS il,
+    pragma_index_info(il.name) AS ii
+WHERE 
+    m.type = 'table' and il.name NOT LIKE 'sqlite_autoindex_%';`
+      );
+      for (const idxRow of idxs) {
+        const tableName = idxRow.tableName;
+        const constraintName = idxRow.indexName;
+        const columnName = idxRow.columnName;
+        const isUnique = idxRow.isUnique === 1;
+        const tableInResult = result[tableName];
+        if (typeof tableInResult === "undefined")
+          continue;
+        indexesCount += 1;
+        if (progressCallback) {
+          progressCallback("indexes", indexesCount, "fetching");
+        }
+        if (typeof tableInResult.indexes[constraintName] !== "undefined") {
+          tableInResult.indexes[constraintName].columns.push(columnName);
+        } else {
+          tableInResult.indexes[constraintName] = {
+            name: constraintName,
+            columns: [columnName],
+            isUnique
+          };
+        }
+      }
+      if (progressCallback) {
+        progressCallback("indexes", indexesCount, "done");
+        progressCallback("enums", 0, "done");
+      }
+      return {
+        version: "5",
+        dialect: "sqlite",
+        tables: result,
+        enums: {},
+        _meta: {
+          tables: {},
+          columns: {}
+        }
+      };
+    };
+    toDrizzle2 = (schema) => {
+      const tables = {};
+      Object.values(schema.tables).forEach((t) => {
+        const columns = {};
+        Object.values(t.columns).forEach((c) => {
+          const columnName = c.name;
+          const type = c.type;
+          let columnBuilder;
+          if (type === "integer") {
+            columnBuilder = new SQLiteIntegerBuilder(columnName);
+          } else if (type === "text") {
+            columnBuilder = new SQLiteTextBuilder(columnName, {});
+          } else if (type === "blob") {
+            columnBuilder = new SQLiteBlobBufferBuilder(columnName);
+          } else if (type === "real") {
+            columnBuilder = new SQLiteRealBuilder(columnName);
+          } else {
+            columnBuilder = new SQLiteNumericBuilder(columnName);
+          }
+          if (c.notNull) {
+            columnBuilder = columnBuilder.notNull();
+          }
+          if (c.default) {
+            columnBuilder = columnBuilder.default(c.default);
+          }
+          if (c.primaryKey) {
+            columnBuilder = columnBuilder.primaryKey();
+          }
+          columns[columnName] = columnBuilder;
+        });
+        tables[t.name] = sqliteTable(t.name, columns, (cb) => {
+          const res = {};
+          Object.values(t.compositePrimaryKeys).forEach((cpk) => {
+            const gh = cpk.columns.map((c) => cb[c]);
+            res[cpk.name] = new PrimaryKeyBuilder2(
+              gh,
+              cpk.name
+            );
+          });
+          return res;
+        });
+      });
+      return tables;
+    };
+  }
+});
+
+// node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/readline.js
+var require_readline = __commonJS({
+  "node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/readline.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.prepareReadLine = void 0;
+    var prepareReadLine = () => {
+      const stdin = process.stdin;
+      const stdout = process.stdout;
+      const readline = __require("readline");
+      const rl = readline.createInterface({
+        input: stdin,
+        escapeCodeTimeout: 50
+      });
+      readline.emitKeypressEvents(stdin, rl);
+      return {
+        stdin,
+        stdout,
+        closable: rl
+      };
+    };
+    exports.prepareReadLine = prepareReadLine;
+  }
+});
+
+// node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js"(exports, module) {
+    "use strict";
+    var ESC = "\x1B";
+    var CSI = `${ESC}[`;
+    var beep = "\x07";
+    var cursor = {
+      to(x, y) {
+        if (!y)
+          return `${CSI}${x + 1}G`;
+        return `${CSI}${y + 1};${x + 1}H`;
+      },
+      move(x, y) {
+        let ret = "";
+        if (x < 0)
+          ret += `${CSI}${-x}D`;
+        else if (x > 0)
+          ret += `${CSI}${x}C`;
+        if (y < 0)
+          ret += `${CSI}${-y}A`;
+        else if (y > 0)
+          ret += `${CSI}${y}B`;
+        return ret;
+      },
+      up: (count = 1) => `${CSI}${count}A`,
+      down: (count = 1) => `${CSI}${count}B`,
+      forward: (count = 1) => `${CSI}${count}C`,
+      backward: (count = 1) => `${CSI}${count}D`,
+      nextLine: (count = 1) => `${CSI}E`.repeat(count),
+      prevLine: (count = 1) => `${CSI}F`.repeat(count),
+      left: `${CSI}G`,
+      hide: `${CSI}?25l`,
+      show: `${CSI}?25h`,
+      save: `${ESC}7`,
+      restore: `${ESC}8`
+    };
+    var scroll = {
+      up: (count = 1) => `${CSI}S`.repeat(count),
+      down: (count = 1) => `${CSI}T`.repeat(count)
+    };
+    var erase = {
+      screen: `${CSI}2J`,
+      up: (count = 1) => `${CSI}1J`.repeat(count),
+      down: (count = 1) => `${CSI}J`.repeat(count),
+      line: `${CSI}2K`,
+      lineEnd: `${CSI}K`,
+      lineStart: `${CSI}1K`,
+      lines(count) {
+        let clear = "";
+        for (let i = 0; i < count; i++)
+          clear += this.line + (i < count - 1 ? cursor.up() : "");
+        if (count)
+          clear += cursor.left;
+        return clear;
+      }
+    };
+    module.exports = { cursor, scroll, erase, beep };
+  }
+});
+
+// node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/utils.js
+var require_utils = __commonJS({
+  "node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.clear = void 0;
+    var sisteransi_1 = require_src();
+    var strip = (str) => {
+      const pattern = [
+        "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+        "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))"
+      ].join("|");
+      const RGX = new RegExp(pattern, "g");
+      return typeof str === "string" ? str.replace(RGX, "") : str;
+    };
+    var stringWidth = (str) => [...strip(str)].length;
+    var clear = function(prompt, perLine) {
+      if (!perLine)
+        return sisteransi_1.erase.line + sisteransi_1.cursor.to(0);
+      let rows = 0;
+      const lines = prompt.split(/\r?\n/);
+      for (let line of lines) {
+        rows += 1 + Math.floor(Math.max(stringWidth(line) - 1, 0) / perLine);
+      }
+      return sisteransi_1.erase.lines(rows);
+    };
+    exports.clear = clear;
+  }
+});
+
+// node_modules/.pnpm/lodash.throttle@4.1.1/node_modules/lodash.throttle/index.js
+var require_lodash = __commonJS({
+  "node_modules/.pnpm/lodash.throttle@4.1.1/node_modules/lodash.throttle/index.js"(exports, module) {
+    var FUNC_ERROR_TEXT = "Expected a function";
+    var NAN = 0 / 0;
+    var symbolTag = "[object Symbol]";
+    var reTrim = /^\s+|\s+$/g;
+    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+    var reIsBinary = /^0b[01]+$/i;
+    var reIsOctal = /^0o[0-7]+$/i;
+    var freeParseInt = parseInt;
+    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+    var root = freeGlobal || freeSelf || Function("return this")();
+    var objectProto = Object.prototype;
+    var objectToString = objectProto.toString;
+    var nativeMax = Math.max;
+    var nativeMin = Math.min;
+    var now = function() {
+      return root.Date.now();
+    };
+    function debounce(func, wait, options) {
+      var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+      if (typeof func != "function") {
+        throw new TypeError(FUNC_ERROR_TEXT);
+      }
+      wait = toNumber(wait) || 0;
+      if (isObject(options)) {
+        leading = !!options.leading;
+        maxing = "maxWait" in options;
+        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+        trailing = "trailing" in options ? !!options.trailing : trailing;
+      }
+      function invokeFunc(time) {
+        var args = lastArgs, thisArg = lastThis;
+        lastArgs = lastThis = void 0;
+        lastInvokeTime = time;
+        result = func.apply(thisArg, args);
+        return result;
+      }
+      function leadingEdge(time) {
+        lastInvokeTime = time;
+        timerId = setTimeout(timerExpired, wait);
+        return leading ? invokeFunc(time) : result;
+      }
+      function remainingWait(time) {
+        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, result2 = wait - timeSinceLastCall;
+        return maxing ? nativeMin(result2, maxWait - timeSinceLastInvoke) : result2;
+      }
+      function shouldInvoke(time) {
+        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+        return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+      }
+      function timerExpired() {
+        var time = now();
+        if (shouldInvoke(time)) {
+          return trailingEdge(time);
+        }
+        timerId = setTimeout(timerExpired, remainingWait(time));
+      }
+      function trailingEdge(time) {
+        timerId = void 0;
+        if (trailing && lastArgs) {
+          return invokeFunc(time);
+        }
+        lastArgs = lastThis = void 0;
+        return result;
+      }
+      function cancel() {
+        if (timerId !== void 0) {
+          clearTimeout(timerId);
+        }
+        lastInvokeTime = 0;
+        lastArgs = lastCallTime = lastThis = timerId = void 0;
+      }
+      function flush() {
+        return timerId === void 0 ? result : trailingEdge(now());
+      }
+      function debounced() {
+        var time = now(), isInvoking = shouldInvoke(time);
+        lastArgs = arguments;
+        lastThis = this;
+        lastCallTime = time;
+        if (isInvoking) {
+          if (timerId === void 0) {
+            return leadingEdge(lastCallTime);
+          }
+          if (maxing) {
+            timerId = setTimeout(timerExpired, wait);
+            return invokeFunc(lastCallTime);
+          }
+        }
+        if (timerId === void 0) {
+          timerId = setTimeout(timerExpired, wait);
+        }
+        return result;
+      }
+      debounced.cancel = cancel;
+      debounced.flush = flush;
+      return debounced;
+    }
+    function throttle(func, wait, options) {
+      var leading = true, trailing = true;
+      if (typeof func != "function") {
+        throw new TypeError(FUNC_ERROR_TEXT);
+      }
+      if (isObject(options)) {
+        leading = "leading" in options ? !!options.leading : leading;
+        trailing = "trailing" in options ? !!options.trailing : trailing;
+      }
+      return debounce(func, wait, {
+        "leading": leading,
+        "maxWait": wait,
+        "trailing": trailing
+      });
+    }
+    function isObject(value) {
+      var type = typeof value;
+      return !!value && (type == "object" || type == "function");
+    }
+    function isObjectLike(value) {
+      return !!value && typeof value == "object";
+    }
+    function isSymbol(value) {
+      return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
+    }
+    function toNumber(value) {
+      if (typeof value == "number") {
+        return value;
+      }
+      if (isSymbol(value)) {
+        return NAN;
+      }
+      if (isObject(value)) {
+        var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+        value = isObject(other) ? other + "" : other;
+      }
+      if (typeof value != "string") {
+        return value === 0 ? value : +value;
+      }
+      value = value.replace(reTrim, "");
+      var isBinary = reIsBinary.test(value);
+      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+    }
+    module.exports = throttle;
+  }
+});
+
+// node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/index.js
+var require_hanji = __commonJS({
+  "node_modules/.pnpm/hanji@0.0.5/node_modules/hanji/index.js"(exports) {
+    "use strict";
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.onTerminate = exports.renderWithTask = exports.render = exports.TaskTerminal = exports.TaskView = exports.Terminal = exports.deferred = exports.SelectState = exports.Prompt = void 0;
+    var readline_1 = require_readline();
+    var sisteransi_1 = require_src();
+    var utils_1 = require_utils();
+    var lodash_throttle_1 = __importDefault(require_lodash());
+    var Prompt2 = class {
+      constructor() {
+        this.attachCallbacks = [];
+        this.detachCallbacks = [];
+        this.inputCallbacks = [];
+      }
+      requestLayout() {
+        this.terminal.requestLayout();
+      }
+      on(type, callback) {
+        if (type === "attach") {
+          this.attachCallbacks.push(callback);
+        } else if (type === "detach") {
+          this.detachCallbacks.push(callback);
+        } else if (type === "input") {
+          this.inputCallbacks.push(callback);
+        }
+      }
+      attach(terminal) {
+        this.terminal = terminal;
+        this.attachCallbacks.forEach((it) => it(terminal));
+      }
+      detach(terminal) {
+        this.detachCallbacks.forEach((it) => it(terminal));
+        this.terminal = void 0;
+      }
+      input(str, key) {
+        this.inputCallbacks.forEach((it) => it(str, key));
+      }
+    };
+    exports.Prompt = Prompt2;
+    var SelectState2 = class {
+      constructor(items) {
+        this.items = items;
+        this.selectedIdx = 0;
+      }
+      bind(prompt) {
+        prompt.on("input", (str, key) => {
+          const invalidate = this.consume(str, key);
+          if (invalidate)
+            prompt.requestLayout();
+        });
+      }
+      consume(str, key) {
+        if (!key)
+          return false;
+        if (key.name === "down") {
+          this.selectedIdx = (this.selectedIdx + 1) % this.items.length;
+          return true;
+        }
+        if (key.name === "up") {
+          this.selectedIdx -= 1;
+          this.selectedIdx = this.selectedIdx < 0 ? this.items.length - 1 : this.selectedIdx;
+          return true;
+        }
+        return false;
+      }
+    };
+    exports.SelectState = SelectState2;
+    var deferred = () => {
+      let resolve;
+      let reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      return {
+        resolve,
+        reject,
+        promise
+      };
+    };
+    exports.deferred = deferred;
+    var Terminal = class {
+      constructor(view, stdin, stdout, closable) {
+        this.view = view;
+        this.stdin = stdin;
+        this.stdout = stdout;
+        this.closable = closable;
+        this.text = "";
+        this.status = "idle";
+        if (this.stdin.isTTY)
+          this.stdin.setRawMode(true);
+        const keypress = (str, key) => {
+          if (key.name === "c" && key.ctrl === true) {
+            this.requestLayout();
+            this.view.detach(this);
+            this.tearDown(keypress);
+            if (terminateHandler) {
+              terminateHandler(this.stdin, this.stdout);
+              return;
+            }
+            this.stdout.write(`
+^C
+`);
+            process.exit(1);
+          }
+          if (key.name === "escape") {
+            this.status = "aborted";
+            this.requestLayout();
+            this.view.detach(this);
+            this.tearDown(keypress);
+            this.resolve({ status: "aborted", data: void 0 });
+            return;
+          }
+          if (key.name === "return") {
+            this.status = "submitted";
+            this.requestLayout();
+            this.view.detach(this);
+            this.tearDown(keypress);
+            this.resolve({ status: "submitted", data: this.view.result() });
+            return;
+          }
+          view.input(str, key);
+        };
+        this.stdin.on("keypress", keypress);
+        this.view.attach(this);
+        const { resolve, promise } = (0, exports.deferred)();
+        this.resolve = resolve;
+        this.promise = promise;
+        this.renderFunc = (0, lodash_throttle_1.default)((str) => {
+          this.stdout.write(str);
+        });
+      }
+      tearDown(keypress) {
+        this.stdout.write(sisteransi_1.cursor.show);
+        this.stdin.removeListener("keypress", keypress);
+        if (this.stdin.isTTY)
+          this.stdin.setRawMode(false);
+        this.closable.close();
+      }
+      result() {
+        return this.promise;
+      }
+      toggleCursor(state) {
+        if (state === "hide") {
+          this.stdout.write(sisteransi_1.cursor.hide);
+        } else {
+          this.stdout.write(sisteransi_1.cursor.show);
+        }
+      }
+      requestLayout() {
+        const string = this.view.render(this.status);
+        const clearPrefix = this.text ? (0, utils_1.clear)(this.text, this.stdout.columns) : "";
+        this.text = string;
+        this.renderFunc(`${clearPrefix}${string}`);
+      }
+    };
+    exports.Terminal = Terminal;
+    var TaskView2 = class {
+      constructor() {
+        this.attachCallbacks = [];
+        this.detachCallbacks = [];
+      }
+      requestLayout() {
+        this.terminal.requestLayout();
+      }
+      attach(terminal) {
+        this.terminal = terminal;
+        this.attachCallbacks.forEach((it) => it(terminal));
+      }
+      detach(terminal) {
+        this.detachCallbacks.forEach((it) => it(terminal));
+        this.terminal = void 0;
+      }
+      on(type, callback) {
+        if (type === "attach") {
+          this.attachCallbacks.push(callback);
+        } else if (type === "detach") {
+          this.detachCallbacks.push(callback);
+        }
+      }
+    };
+    exports.TaskView = TaskView2;
+    var TaskTerminal = class {
+      constructor(view, stdout) {
+        this.view = view;
+        this.stdout = stdout;
+        this.text = "";
+        this.view.attach(this);
+      }
+      requestLayout() {
+        const string = this.view.render("pending");
+        const clearPrefix = this.text ? (0, utils_1.clear)(this.text, this.stdout.columns) : "";
+        this.text = string;
+        this.stdout.write(`${clearPrefix}${string}`);
+      }
+      clear() {
+        const string = this.view.render("done");
+        this.view.detach(this);
+        const clearPrefix = this.text ? (0, utils_1.clear)(this.text, this.stdout.columns) : "";
+        this.stdout.write(`${clearPrefix}${string}`);
+      }
+    };
+    exports.TaskTerminal = TaskTerminal;
+    function render2(view) {
+      const { stdin, stdout, closable } = (0, readline_1.prepareReadLine)();
+      if (view instanceof Prompt2) {
+        const terminal = new Terminal(view, stdin, stdout, closable);
+        terminal.requestLayout();
+        return terminal.result();
+      }
+      stdout.write(`${view}
+`);
+      closable.close();
+      return;
+    }
+    exports.render = render2;
+    function renderWithTask3(view, task) {
+      return __awaiter(this, void 0, void 0, function* () {
+        const terminal = new TaskTerminal(view, process.stdout);
+        terminal.requestLayout();
+        const result = yield task;
+        terminal.clear();
+        return result;
+      });
+    }
+    exports.renderWithTask = renderWithTask3;
+    var terminateHandler;
+    function onTerminate(callback) {
+      terminateHandler = callback;
+    }
+    exports.onTerminate = onTerminate;
+  }
+});
+
+// src/cli/views.ts
+var import_hanji;
+var init_views = __esm({
+  "src/cli/views.ts"() {
+    init_source();
+    import_hanji = __toESM(require_hanji());
+  }
+});
+
+// node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
+var require_balanced_match = __commonJS({
+  "node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js"(exports, module) {
+    "use strict";
+    module.exports = balanced;
+    function balanced(a, b, str) {
+      if (a instanceof RegExp)
+        a = maybeMatch(a, str);
+      if (b instanceof RegExp)
+        b = maybeMatch(b, str);
+      var r = range(a, b, str);
+      return r && {
+        start: r[0],
+        end: r[1],
+        pre: str.slice(0, r[0]),
+        body: str.slice(r[0] + a.length, r[1]),
+        post: str.slice(r[1] + b.length)
+      };
+    }
+    function maybeMatch(reg, str) {
+      var m = str.match(reg);
+      return m ? m[0] : null;
+    }
+    balanced.range = range;
+    function range(a, b, str) {
+      var begs, beg, left, right, result;
+      var ai = str.indexOf(a);
+      var bi = str.indexOf(b, ai + 1);
+      var i = ai;
+      if (ai >= 0 && bi > 0) {
+        if (a === b) {
+          return [ai, bi];
+        }
+        begs = [];
+        left = str.length;
+        while (i >= 0 && !result) {
+          if (i == ai) {
+            begs.push(i);
+            ai = str.indexOf(a, i + 1);
+          } else if (begs.length == 1) {
+            result = [begs.pop(), bi];
+          } else {
+            beg = begs.pop();
+            if (beg < left) {
+              left = beg;
+              right = bi;
+            }
+            bi = str.indexOf(b, i + 1);
+          }
+          i = ai < bi && ai >= 0 ? ai : bi;
+        }
+        if (begs.length) {
+          result = [left, right];
+        }
+      }
+      return result;
+    }
+  }
+});
+
+// node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js
+var require_brace_expansion = __commonJS({
+  "node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js"(exports, module) {
+    var balanced = require_balanced_match();
+    module.exports = expandTop;
+    var escSlash = "\0SLASH" + Math.random() + "\0";
+    var escOpen = "\0OPEN" + Math.random() + "\0";
+    var escClose = "\0CLOSE" + Math.random() + "\0";
+    var escComma = "\0COMMA" + Math.random() + "\0";
+    var escPeriod = "\0PERIOD" + Math.random() + "\0";
+    function numeric(str) {
+      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+    }
+    function escapeBraces(str) {
+      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+    }
+    function unescapeBraces(str) {
+      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+    }
+    function parseCommaParts(str) {
+      if (!str)
+        return [""];
+      var parts = [];
+      var m = balanced("{", "}", str);
+      if (!m)
+        return str.split(",");
+      var pre = m.pre;
+      var body = m.body;
+      var post = m.post;
+      var p = pre.split(",");
+      p[p.length - 1] += "{" + body + "}";
+      var postParts = parseCommaParts(post);
+      if (post.length) {
+        p[p.length - 1] += postParts.shift();
+        p.push.apply(p, postParts);
+      }
+      parts.push.apply(parts, p);
+      return parts;
+    }
+    function expandTop(str) {
+      if (!str)
+        return [];
+      if (str.substr(0, 2) === "{}") {
+        str = "\\{\\}" + str.substr(2);
+      }
+      return expand2(escapeBraces(str), true).map(unescapeBraces);
+    }
+    function embrace(str) {
+      return "{" + str + "}";
+    }
+    function isPadded(el) {
+      return /^-?0\d/.test(el);
+    }
+    function lte(i, y) {
+      return i <= y;
+    }
+    function gte(i, y) {
+      return i >= y;
+    }
+    function expand2(str, isTop) {
+      var expansions = [];
+      var m = balanced("{", "}", str);
+      if (!m)
+        return [str];
+      var pre = m.pre;
+      var post = m.post.length ? expand2(m.post, false) : [""];
+      if (/\$$/.test(m.pre)) {
+        for (var k = 0; k < post.length; k++) {
+          var expansion = pre + "{" + m.body + "}" + post[k];
+          expansions.push(expansion);
+        }
+      } else {
+        var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+        var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+        var isSequence = isNumericSequence || isAlphaSequence;
+        var isOptions = m.body.indexOf(",") >= 0;
+        if (!isSequence && !isOptions) {
+          if (m.post.match(/,.*\}/)) {
+            str = m.pre + "{" + m.body + escClose + m.post;
+            return expand2(str);
+          }
+          return [str];
+        }
+        var n;
+        if (isSequence) {
+          n = m.body.split(/\.\./);
+        } else {
+          n = parseCommaParts(m.body);
+          if (n.length === 1) {
+            n = expand2(n[0], false).map(embrace);
+            if (n.length === 1) {
+              return post.map(function(p) {
+                return m.pre + n[0] + p;
+              });
+            }
+          }
+        }
+        var N;
+        if (isSequence) {
+          var x = numeric(n[0]);
+          var y = numeric(n[1]);
+          var width = Math.max(n[0].length, n[1].length);
+          var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
+          var test = lte;
+          var reverse = y < x;
+          if (reverse) {
+            incr *= -1;
+            test = gte;
+          }
+          var pad = n.some(isPadded);
+          N = [];
+          for (var i = x; test(i, y); i += incr) {
+            var c;
+            if (isAlphaSequence) {
+              c = String.fromCharCode(i);
+              if (c === "\\")
+                c = "";
+            } else {
+              c = String(i);
+              if (pad) {
+                var need = width - c.length;
+                if (need > 0) {
+                  var z = new Array(need + 1).join("0");
+                  if (i < 0)
+                    c = "-" + z + c.slice(1);
+                  else
+                    c = z + c;
+                }
+              }
+            }
+            N.push(c);
+          }
+        } else {
+          N = [];
+          for (var j = 0; j < n.length; j++) {
+            N.push.apply(N, expand2(n[j], false));
+          }
+        }
+        for (var j = 0; j < N.length; j++) {
+          for (var k = 0; k < post.length; k++) {
+            var expansion = pre + N[j] + post[k];
+            if (!isTop || isSequence || expansion)
+              expansions.push(expansion);
+          }
+        }
+      }
+      return expansions;
+    }
+  }
+});
+
+// src/drivers/index.ts
+import { sql } from "drizzle-orm";
+var DrizzleDbClient, DrizzleORMPgClient, TursoSqlite;
+var init_drivers = __esm({
+  "src/drivers/index.ts"() {
+    DrizzleDbClient = class {
+      constructor(db) {
+        this.db = db;
+      }
+    };
+    DrizzleORMPgClient = class extends DrizzleDbClient {
+      async query(query, values) {
+        const res = await this.db.execute(sql.raw(query));
+        return res.rows;
+      }
+      async run(query) {
+        const res = await this.db.execute(sql.raw(query));
+        return res.rows;
+      }
+    };
+    TursoSqlite = class extends DrizzleDbClient {
+      async run(query) {
+        await this.db.execute(query);
+      }
+      async query(query) {
+        const res = await this.db.execute(query);
+        return res.rows;
+      }
+    };
+  }
+});
+
+// src/utils-studio.ts
+init_pgSerializer();
+init_sqliteSerializer();
+
+// src/cli/commands/sqliteIntrospect.ts
+init_views();
+
+// src/global.ts
+var originUUID = "00000000-0000-0000-0000-000000000000";
+
+// src/cli/commands/sqliteIntrospect.ts
+init_sqliteSerializer();
+
+// node_modules/.pnpm/camelcase@7.0.1/node_modules/camelcase/index.js
+var UPPERCASE = /[\p{Lu}]/u;
+var LOWERCASE = /[\p{Ll}]/u;
+var LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
+var IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
+var SEPARATORS = /[_.\- ]+/;
+var LEADING_SEPARATORS = new RegExp("^" + SEPARATORS.source);
+var SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, "gu");
+var NUMBERS_AND_IDENTIFIER = new RegExp("\\d+" + IDENTIFIER.source, "gu");
+var preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUppercase2) => {
+  let isLastCharLower = false;
+  let isLastCharUpper = false;
+  let isLastLastCharUpper = false;
+  let isLastLastCharPreserved = false;
+  for (let index = 0; index < string.length; index++) {
+    const character = string[index];
+    isLastLastCharPreserved = index > 2 ? string[index - 3] === "-" : true;
+    if (isLastCharLower && UPPERCASE.test(character)) {
+      string = string.slice(0, index) + "-" + string.slice(index);
+      isLastCharLower = false;
+      isLastLastCharUpper = isLastCharUpper;
+      isLastCharUpper = true;
+      index++;
+    } else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character) && (!isLastLastCharPreserved || preserveConsecutiveUppercase2)) {
+      string = string.slice(0, index - 1) + "-" + string.slice(index - 1);
+      isLastLastCharUpper = isLastCharUpper;
+      isLastCharUpper = false;
+      isLastCharLower = true;
+    } else {
+      isLastCharLower = toLowerCase(character) === character && toUpperCase(character) !== character;
+      isLastLastCharUpper = isLastCharUpper;
+      isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character;
+    }
+  }
+  return string;
+};
+var preserveConsecutiveUppercase = (input, toLowerCase) => {
+  LEADING_CAPITAL.lastIndex = 0;
+  return input.replace(LEADING_CAPITAL, (m1) => toLowerCase(m1));
+};
+var postProcess = (input, toUpperCase) => {
+  SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
+  NUMBERS_AND_IDENTIFIER.lastIndex = 0;
+  return input.replace(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier)).replace(NUMBERS_AND_IDENTIFIER, (m) => toUpperCase(m));
+};
+function camelCase(input, options) {
+  if (!(typeof input === "string" || Array.isArray(input))) {
+    throw new TypeError("Expected the input to be `string | string[]`");
+  }
+  options = {
+    pascalCase: false,
+    preserveConsecutiveUppercase: false,
+    ...options
+  };
+  if (Array.isArray(input)) {
+    input = input.map((x) => x.trim()).filter((x) => x.length).join("-");
+  } else {
+    input = input.trim();
+  }
+  if (input.length === 0) {
+    return "";
+  }
+  const toLowerCase = options.locale === false ? (string) => string.toLowerCase() : (string) => string.toLocaleLowerCase(options.locale);
+  const toUpperCase = options.locale === false ? (string) => string.toUpperCase() : (string) => string.toLocaleUpperCase(options.locale);
+  if (input.length === 1) {
+    if (SEPARATORS.test(input)) {
+      return "";
+    }
+    return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
+  }
+  const hasUpperCase = input !== toLowerCase(input);
+  if (hasUpperCase) {
+    input = preserveCamelCase(input, toLowerCase, toUpperCase, options.preserveConsecutiveUppercase);
+  }
+  input = input.replace(LEADING_SEPARATORS, "");
+  input = options.preserveConsecutiveUppercase ? preserveConsecutiveUppercase(input, toLowerCase) : toLowerCase(input);
+  if (options.pascalCase) {
+    input = toUpperCase(input.charAt(0)) + input.slice(1);
+  }
+  return postProcess(input, toUpperCase);
+}
+
+// src/@types/utils.ts
+String.prototype.trimChar = function(char) {
+  let start = 0;
+  let end = this.length;
+  while (start < end && this[start] === char)
+    ++start;
+  while (end > start && this[end - 1] === char)
+    --end;
+  return start > 0 || end < this.length ? this.substring(start, end) : this.toString();
+};
+String.prototype.squashSpaces = function() {
+  return this.replace(/  +/g, " ").trim();
+};
+String.prototype.camelCase = function() {
+  return camelCase(String(this));
+};
+String.prototype.concatIf = function(it, condition) {
+  return condition ? `${this}${it}` : this;
+};
+Array.prototype.random = function() {
+  return this[~~(Math.random() * this.length)];
+};
+
+// node_modules/.pnpm/minimatch@7.4.3/node_modules/minimatch/dist/mjs/index.js
+var import_brace_expansion = __toESM(require_brace_expansion(), 1);
+
+// node_modules/.pnpm/minimatch@7.4.3/node_modules/minimatch/dist/mjs/brace-expressions.js
+var posixClasses = {
+  "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
+  "[:alpha:]": ["\\p{L}\\p{Nl}", true],
+  "[:ascii:]": ["\\x00-\\x7f", false],
+  "[:blank:]": ["\\p{Zs}\\t", true],
+  "[:cntrl:]": ["\\p{Cc}", true],
+  "[:digit:]": ["\\p{Nd}", true],
+  "[:graph:]": ["\\p{Z}\\p{C}", true, true],
+  "[:lower:]": ["\\p{Ll}", true],
+  "[:print:]": ["\\p{C}", true],
+  "[:punct:]": ["\\p{P}", true],
+  "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
+  "[:upper:]": ["\\p{Lu}", true],
+  "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
+  "[:xdigit:]": ["A-Fa-f0-9", false]
+};
+var braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
+var regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var rangesToString = (ranges) => ranges.join("");
+var parseClass = (glob2, position) => {
+  const pos = position;
+  if (glob2.charAt(pos) !== "[") {
+    throw new Error("not in a brace expression");
+  }
+  const ranges = [];
+  const negs = [];
+  let i = pos + 1;
+  let sawStart = false;
+  let uflag = false;
+  let escaping = false;
+  let negate = false;
+  let endPos = pos;
+  let rangeStart = "";
+  WHILE:
+    while (i < glob2.length) {
+      const c = glob2.charAt(i);
+      if ((c === "!" || c === "^") && i === pos + 1) {
+        negate = true;
+        i++;
+        continue;
+      }
+      if (c === "]" && sawStart && !escaping) {
+        endPos = i + 1;
+        break;
+      }
+      sawStart = true;
+      if (c === "\\") {
+        if (!escaping) {
+          escaping = true;
+          i++;
+          continue;
+        }
+      }
+      if (c === "[" && !escaping) {
+        for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
+          if (glob2.startsWith(cls, i)) {
+            if (rangeStart) {
+              return ["$.", false, glob2.length - pos, true];
+            }
+            i += cls.length;
+            if (neg)
+              negs.push(unip);
+            else
+              ranges.push(unip);
+            uflag = uflag || u;
+            continue WHILE;
+          }
+        }
+      }
+      escaping = false;
+      if (rangeStart) {
+        if (c > rangeStart) {
+          ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
+        } else if (c === rangeStart) {
+          ranges.push(braceEscape(c));
+        }
+        rangeStart = "";
+        i++;
+        continue;
+      }
+      if (glob2.startsWith("-]", i + 1)) {
+        ranges.push(braceEscape(c + "-"));
+        i += 2;
+        continue;
+      }
+      if (glob2.startsWith("-", i + 1)) {
+        rangeStart = c;
+        i += 2;
+        continue;
+      }
+      ranges.push(braceEscape(c));
+      i++;
+    }
+  if (endPos < i) {
+    return ["", false, 0, false];
+  }
+  if (!ranges.length && !negs.length) {
+    return ["$.", false, glob2.length - pos, true];
+  }
+  if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
+    const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
+    return [regexpEscape(r), false, endPos - pos, false];
+  }
+  const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
+  const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
+  const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
+  return [comb, uflag, endPos - pos, true];
+};
+
+// node_modules/.pnpm/minimatch@7.4.3/node_modules/minimatch/dist/mjs/escape.js
+var escape = (s, { windowsPathsNoEscape = false } = {}) => {
+  return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
+};
+
+// node_modules/.pnpm/minimatch@7.4.3/node_modules/minimatch/dist/mjs/unescape.js
+var unescape = (s, { windowsPathsNoEscape = false } = {}) => {
+  return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+};
+
+// node_modules/.pnpm/minimatch@7.4.3/node_modules/minimatch/dist/mjs/index.js
+var minimatch = (p, pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (!options.nocomment && pattern.charAt(0) === "#") {
+    return false;
+  }
+  return new Minimatch(pattern, options).match(p);
+};
+var starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
+var starDotExtTest = (ext2) => (f) => !f.startsWith(".") && f.endsWith(ext2);
+var starDotExtTestDot = (ext2) => (f) => f.endsWith(ext2);
+var starDotExtTestNocase = (ext2) => {
+  ext2 = ext2.toLowerCase();
+  return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext2);
+};
+var starDotExtTestNocaseDot = (ext2) => {
+  ext2 = ext2.toLowerCase();
+  return (f) => f.toLowerCase().endsWith(ext2);
+};
+var starDotStarRE = /^\*+\.\*+$/;
+var starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
+var starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
+var dotStarRE = /^\.\*+$/;
+var dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
+var starRE = /^\*+$/;
+var starTest = (f) => f.length !== 0 && !f.startsWith(".");
+var starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
+var qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
+var qmarksTestNocase = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  if (!ext2)
+    return noext;
+  ext2 = ext2.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+};
+var qmarksTestNocaseDot = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  if (!ext2)
+    return noext;
+  ext2 = ext2.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+};
+var qmarksTestDot = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+};
+var qmarksTest = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+};
+var qmarksTestNoExt = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && !f.startsWith(".");
+};
+var qmarksTestNoExtDot = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && f !== "." && f !== "..";
+};
+var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+var path = {
+  win32: { sep: "\\" },
+  posix: { sep: "/" }
+};
+var sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
+minimatch.sep = sep;
+var GLOBSTAR = Symbol("globstar **");
+minimatch.GLOBSTAR = GLOBSTAR;
+var plTypes = {
+  "!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
+  "?": { open: "(?:", close: ")?" },
+  "+": { open: "(?:", close: ")+" },
+  "*": { open: "(?:", close: ")*" },
+  "@": { open: "(?:", close: ")" }
+};
+var qmark = "[^/]";
+var star = qmark + "*?";
+var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+var charSet = (s) => s.split("").reduce((set, c) => {
+  set[c] = true;
+  return set;
+}, {});
+var reSpecials = charSet("().*{}+?[]^$\\!");
+var addPatternStartSet = charSet("[.(");
+var filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
+minimatch.filter = filter;
+var ext = (a, b = {}) => Object.assign({}, a, b);
+var defaults = (def) => {
+  if (!def || typeof def !== "object" || !Object.keys(def).length) {
+    return minimatch;
+  }
+  const orig = minimatch;
+  const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
+  return Object.assign(m, {
+    Minimatch: class Minimatch extends orig.Minimatch {
+      constructor(pattern, options = {}) {
+        super(pattern, ext(def, options));
+      }
+      static defaults(options) {
+        return orig.defaults(ext(def, options)).Minimatch;
+      }
+    },
+    unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
+    escape: (s, options = {}) => orig.escape(s, ext(def, options)),
+    filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
+    defaults: (options) => orig.defaults(ext(def, options)),
+    makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
+    braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
+    match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
+    sep: orig.sep,
+    GLOBSTAR
+  });
+};
+minimatch.defaults = defaults;
+var braceExpand = (pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+    return [pattern];
+  }
+  return (0, import_brace_expansion.default)(pattern);
+};
+minimatch.braceExpand = braceExpand;
+var MAX_PATTERN_LENGTH = 1024 * 64;
+var assertValidPattern = (pattern) => {
+  if (typeof pattern !== "string") {
+    throw new TypeError("invalid pattern");
+  }
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    throw new TypeError("pattern is too long");
+  }
+};
+var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
+minimatch.makeRe = makeRe;
+var match = (list, pattern, options = {}) => {
+  const mm = new Minimatch(pattern, options);
+  list = list.filter((f) => mm.match(f));
+  if (mm.options.nonull && !list.length) {
+    list.push(pattern);
+  }
+  return list;
+};
+minimatch.match = match;
+var globUnescape = (s) => s.replace(/\\(.)/g, "$1");
+var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
+var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var Minimatch = class {
+  options;
+  set;
+  pattern;
+  windowsPathsNoEscape;
+  nonegate;
+  negate;
+  comment;
+  empty;
+  preserveMultipleSlashes;
+  partial;
+  globSet;
+  globParts;
+  nocase;
+  isWindows;
+  platform;
+  windowsNoMagicRoot;
+  regexp;
+  constructor(pattern, options = {}) {
+    assertValidPattern(pattern);
+    options = options || {};
+    this.options = options;
+    this.pattern = pattern;
+    this.platform = options.platform || defaultPlatform;
+    this.isWindows = this.platform === "win32";
+    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+    if (this.windowsPathsNoEscape) {
+      this.pattern = this.pattern.replace(/\\/g, "/");
+    }
+    this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
+    this.regexp = null;
+    this.negate = false;
+    this.nonegate = !!options.nonegate;
+    this.comment = false;
+    this.empty = false;
+    this.partial = !!options.partial;
+    this.nocase = !!this.options.nocase;
+    this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
+    this.globSet = [];
+    this.globParts = [];
+    this.set = [];
+    this.make();
+  }
+  hasMagic() {
+    if (this.options.magicalBraces && this.set.length > 1) {
+      return true;
+    }
+    for (const pattern of this.set) {
+      for (const part of pattern) {
+        if (typeof part !== "string")
+          return true;
+      }
+    }
+    return false;
+  }
+  debug(..._) {
+  }
+  make() {
+    const pattern = this.pattern;
+    const options = this.options;
+    if (!options.nocomment && pattern.charAt(0) === "#") {
+      this.comment = true;
+      return;
+    }
+    if (!pattern) {
+      this.empty = true;
+      return;
+    }
+    this.parseNegate();
+    this.globSet = [...new Set(this.braceExpand())];
+    if (options.debug) {
+      this.debug = (...args) => console.error(...args);
+    }
+    this.debug(this.pattern, this.globSet);
+    const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
+    this.globParts = this.preprocess(rawGlobParts);
+    this.debug(this.pattern, this.globParts);
+    let set = this.globParts.map((s, _, __) => {
+      if (this.isWindows && this.windowsNoMagicRoot) {
+        const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
+        const isDrive = /^[a-z]:/i.test(s[0]);
+        if (isUNC) {
+          return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
+        } else if (isDrive) {
+          return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
+        }
+      }
+      return s.map((ss) => this.parse(ss));
+    });
+    this.debug(this.pattern, set);
+    this.set = set.filter((s) => s.indexOf(false) === -1);
+    if (this.isWindows) {
+      for (let i = 0; i < this.set.length; i++) {
+        const p = this.set[i];
+        if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) {
+          p[2] = "?";
+        }
+      }
+    }
+    this.debug(this.pattern, this.set);
+  }
+  // various transforms to equivalent pattern sets that are
+  // faster to process in a filesystem walk.  The goal is to
+  // eliminate what we can, and push all ** patterns as far
+  // to the right as possible, even if it increases the number
+  // of patterns that we have to process.
+  preprocess(globParts) {
+    if (this.options.noglobstar) {
+      for (let i = 0; i < globParts.length; i++) {
+        for (let j = 0; j < globParts[i].length; j++) {
+          if (globParts[i][j] === "**") {
+            globParts[i][j] = "*";
+          }
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      globParts = this.firstPhasePreProcess(globParts);
+      globParts = this.secondPhasePreProcess(globParts);
+    } else if (optimizationLevel >= 1) {
+      globParts = this.levelOneOptimize(globParts);
+    } else {
+      globParts = this.adjascentGlobstarOptimize(globParts);
+    }
+    return globParts;
+  }
+  // just get rid of adjascent ** portions
+  adjascentGlobstarOptimize(globParts) {
+    return globParts.map((parts) => {
+      let gs = -1;
+      while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+        let i = gs;
+        while (parts[i + 1] === "**") {
+          i++;
+        }
+        if (i !== gs) {
+          parts.splice(gs, i - gs);
+        }
+      }
+      return parts;
+    });
+  }
+  // get rid of adjascent ** and resolve .. portions
+  levelOneOptimize(globParts) {
+    return globParts.map((parts) => {
+      parts = parts.reduce((set, part) => {
+        const prev = set[set.length - 1];
+        if (part === "**" && prev === "**") {
+          return set;
+        }
+        if (part === "..") {
+          if (prev && prev !== ".." && prev !== "." && prev !== "**") {
+            set.pop();
+            return set;
+          }
+        }
+        set.push(part);
+        return set;
+      }, []);
+      return parts.length === 0 ? [""] : parts;
+    });
+  }
+  levelTwoFileOptimize(parts) {
+    if (!Array.isArray(parts)) {
+      parts = this.slashSplit(parts);
+    }
+    let didSomething = false;
+    do {
+      didSomething = false;
+      if (!this.preserveMultipleSlashes) {
+        for (let i = 1; i < parts.length - 1; i++) {
+          const p = parts[i];
+          if (i === 1 && p === "" && parts[0] === "")
+            continue;
+          if (p === "." || p === "") {
+            didSomething = true;
+            parts.splice(i, 1);
+            i--;
+          }
+        }
+        if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+          didSomething = true;
+          parts.pop();
+        }
+      }
+      let dd = 0;
+      while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+        const p = parts[dd - 1];
+        if (p && p !== "." && p !== ".." && p !== "**") {
+          didSomething = true;
+          parts.splice(dd - 1, 2);
+          dd -= 2;
+        }
+      }
+    } while (didSomething);
+    return parts.length === 0 ? [""] : parts;
+  }
+  // First phase: single-pattern processing
+  // <pre> is 1 or more portions
+  // <rest> is 1 or more portions
+  // <p> is any portion other than ., .., '', or **
+  // <e> is . or ''
+  //
+  // **/.. is *brutal* for filesystem walking performance, because
+  // it effectively resets the recursive walk each time it occurs,
+  // and ** cannot be reduced out by a .. pattern part like a regexp
+  // or most strings (other than .., ., and '') can be.
+  //
+  // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
+  // <pre>/<e>/<rest> -> <pre>/<rest>
+  // <pre>/<p>/../<rest> -> <pre>/<rest>
+  // **/**/<rest> -> **/<rest>
+  //
+  // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
+  // this WOULD be allowed if ** did follow symlinks, or * didn't
+  firstPhasePreProcess(globParts) {
+    let didSomething = false;
+    do {
+      didSomething = false;
+      for (let parts of globParts) {
+        let gs = -1;
+        while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+          let gss = gs;
+          while (parts[gss + 1] === "**") {
+            gss++;
+          }
+          if (gss > gs) {
+            parts.splice(gs + 1, gss - gs);
+          }
+          let next = parts[gs + 1];
+          const p = parts[gs + 2];
+          const p2 = parts[gs + 3];
+          if (next !== "..")
+            continue;
+          if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") {
+            continue;
+          }
+          didSomething = true;
+          parts.splice(gs, 1);
+          const other = parts.slice(0);
+          other[gs] = "**";
+          globParts.push(other);
+          gs--;
+        }
+        if (!this.preserveMultipleSlashes) {
+          for (let i = 1; i < parts.length - 1; i++) {
+            const p = parts[i];
+            if (i === 1 && p === "" && parts[0] === "")
+              continue;
+            if (p === "." || p === "") {
+              didSomething = true;
+              parts.splice(i, 1);
+              i--;
+            }
+          }
+          if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+            didSomething = true;
+            parts.pop();
+          }
+        }
+        let dd = 0;
+        while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+          const p = parts[dd - 1];
+          if (p && p !== "." && p !== ".." && p !== "**") {
+            didSomething = true;
+            const needDot = dd === 1 && parts[dd + 1] === "**";
+            const splin = needDot ? ["."] : [];
+            parts.splice(dd - 1, 2, ...splin);
+            if (parts.length === 0)
+              parts.push("");
+            dd -= 2;
+          }
+        }
+      }
+    } while (didSomething);
+    return globParts;
+  }
+  // second phase: multi-pattern dedupes
+  // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
+  // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
+  // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
+  //
+  // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
+  // ^-- not valid because ** doens't follow symlinks
+  secondPhasePreProcess(globParts) {
+    for (let i = 0; i < globParts.length - 1; i++) {
+      for (let j = i + 1; j < globParts.length; j++) {
+        const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
+        if (!matched)
+          continue;
+        globParts[i] = matched;
+        globParts[j] = [];
+      }
+    }
+    return globParts.filter((gs) => gs.length);
+  }
+  partsMatch(a, b, emptyGSMatch = false) {
+    let ai = 0;
+    let bi = 0;
+    let result = [];
+    let which = "";
+    while (ai < a.length && bi < b.length) {
+      if (a[ai] === b[bi]) {
+        result.push(which === "b" ? b[bi] : a[ai]);
+        ai++;
+        bi++;
+      } else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
+        result.push(a[ai]);
+        ai++;
+      } else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
+        result.push(b[bi]);
+        bi++;
+      } else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
+        if (which === "b")
+          return false;
+        which = "a";
+        result.push(a[ai]);
+        ai++;
+        bi++;
+      } else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
+        if (which === "a")
+          return false;
+        which = "b";
+        result.push(b[bi]);
+        ai++;
+        bi++;
+      } else {
+        return false;
+      }
+    }
+    return a.length === b.length && result;
+  }
+  parseNegate() {
+    if (this.nonegate)
+      return;
+    const pattern = this.pattern;
+    let negate = false;
+    let negateOffset = 0;
+    for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
+      negate = !negate;
+      negateOffset++;
+    }
+    if (negateOffset)
+      this.pattern = pattern.slice(negateOffset);
+    this.negate = negate;
+  }
+  // set partial to true to test if, for example,
+  // "/a/b" matches the start of "/*/b/*/d"
+  // Partial means, if you run out of file before you run
+  // out of pattern, then that's fine, as long as all
+  // the parts match.
+  matchOne(file, pattern, partial = false) {
+    const options = this.options;
+    if (this.isWindows) {
+      const fileUNC = file[0] === "" && file[1] === "" && file[2] === "?" && typeof file[3] === "string" && /^[a-z]:$/i.test(file[3]);
+      const patternUNC = pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
+      if (fileUNC && patternUNC) {
+        const fd = file[3];
+        const pd = pattern[3];
+        if (fd.toLowerCase() === pd.toLowerCase()) {
+          file[3] = pd;
+        }
+      } else if (patternUNC && typeof file[0] === "string") {
+        const pd = pattern[3];
+        const fd = file[0];
+        if (pd.toLowerCase() === fd.toLowerCase()) {
+          pattern[3] = fd;
+          pattern = pattern.slice(3);
+        }
+      } else if (fileUNC && typeof pattern[0] === "string") {
+        const fd = file[3];
+        if (fd.toLowerCase() === pattern[0].toLowerCase()) {
+          pattern[0] = fd;
+          file = file.slice(3);
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      file = this.levelTwoFileOptimize(file);
+    }
+    this.debug("matchOne", this, { file, pattern });
+    this.debug("matchOne", file.length, pattern.length);
+    for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+      this.debug("matchOne loop");
+      var p = pattern[pi];
+      var f = file[fi];
+      this.debug(pattern, p, f);
+      if (p === false) {
+        return false;
+      }
+      if (p === GLOBSTAR) {
+        this.debug("GLOBSTAR", [pattern, p, f]);
+        var fr = fi;
+        var pr = pi + 1;
+        if (pr === pl) {
+          this.debug("** at the end");
+          for (; fi < fl; fi++) {
+            if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
+              return false;
+          }
+          return true;
+        }
+        while (fr < fl) {
+          var swallowee = file[fr];
+          this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
+          if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+            this.debug("globstar found match!", fr, fl, swallowee);
+            return true;
+          } else {
+            if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
+              this.debug("dot detected!", file, fr, pattern, pr);
+              break;
+            }
+            this.debug("globstar swallow a segment, and continue");
+            fr++;
+          }
+        }
+        if (partial) {
+          this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
+          if (fr === fl) {
+            return true;
+          }
+        }
+        return false;
+      }
+      let hit;
+      if (typeof p === "string") {
+        hit = f === p;
+        this.debug("string match", p, f, hit);
+      } else {
+        hit = p.test(f);
+        this.debug("pattern match", p, f, hit);
+      }
+      if (!hit)
+        return false;
+    }
+    if (fi === fl && pi === pl) {
+      return true;
+    } else if (fi === fl) {
+      return partial;
+    } else if (pi === pl) {
+      return fi === fl - 1 && file[fi] === "";
+    } else {
+      throw new Error("wtf?");
+    }
+  }
+  braceExpand() {
+    return braceExpand(this.pattern, this.options);
+  }
+  parse(pattern) {
+    assertValidPattern(pattern);
+    const options = this.options;
+    if (pattern === "**")
+      return GLOBSTAR;
+    if (pattern === "")
+      return "";
+    let m;
+    let fastTest = null;
+    if (m = pattern.match(starRE)) {
+      fastTest = options.dot ? starTestDot : starTest;
+    } else if (m = pattern.match(starDotExtRE)) {
+      fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
+    } else if (m = pattern.match(qmarksRE)) {
+      fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
+    } else if (m = pattern.match(starDotStarRE)) {
+      fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
+    } else if (m = pattern.match(dotStarRE)) {
+      fastTest = dotStarTest;
+    }
+    let re = "";
+    let hasMagic = false;
+    let escaping = false;
+    const patternListStack = [];
+    const negativeLists = [];
+    let stateChar = false;
+    let uflag = false;
+    let pl;
+    let dotTravAllowed = pattern.charAt(0) === ".";
+    let dotFileAllowed = options.dot || dotTravAllowed;
+    const patternStart = () => dotTravAllowed ? "" : dotFileAllowed ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
+    const subPatternStart = (p) => p.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
+    const clearStateChar = () => {
+      if (stateChar) {
+        switch (stateChar) {
+          case "*":
+            re += star;
+            hasMagic = true;
+            break;
+          case "?":
+            re += qmark;
+            hasMagic = true;
+            break;
+          default:
+            re += "\\" + stateChar;
+            break;
+        }
+        this.debug("clearStateChar %j %j", stateChar, re);
+        stateChar = false;
+      }
+    };
+    for (let i = 0, c; i < pattern.length && (c = pattern.charAt(i)); i++) {
+      this.debug("%s	%s %s %j", pattern, i, re, c);
+      if (escaping) {
+        if (c === "/") {
+          return false;
+        }
+        if (reSpecials[c]) {
+          re += "\\";
+        }
+        re += c;
+        escaping = false;
+        continue;
+      }
+      switch (c) {
+        case "/": {
+          return false;
+        }
+        case "\\":
+          clearStateChar();
+          escaping = true;
+          continue;
+        case "?":
+        case "*":
+        case "+":
+        case "@":
+        case "!":
+          this.debug("%s	%s %s %j <-- stateChar", pattern, i, re, c);
+          this.debug("call clearStateChar %j", stateChar);
+          clearStateChar();
+          stateChar = c;
+          if (options.noext)
+            clearStateChar();
+          continue;
+        case "(": {
+          if (!stateChar) {
+            re += "\\(";
+            continue;
+          }
+          const plEntry = {
+            type: stateChar,
+            start: i - 1,
+            reStart: re.length,
+            open: plTypes[stateChar].open,
+            close: plTypes[stateChar].close
+          };
+          this.debug(this.pattern, "	", plEntry);
+          patternListStack.push(plEntry);
+          re += plEntry.open;
+          if (plEntry.start === 0 && plEntry.type !== "!") {
+            dotTravAllowed = true;
+            re += subPatternStart(pattern.slice(i + 1));
+          }
+          this.debug("plType %j %j", stateChar, re);
+          stateChar = false;
+          continue;
+        }
+        case ")": {
+          const plEntry = patternListStack[patternListStack.length - 1];
+          if (!plEntry) {
+            re += "\\)";
+            continue;
+          }
+          patternListStack.pop();
+          clearStateChar();
+          hasMagic = true;
+          pl = plEntry;
+          re += pl.close;
+          if (pl.type === "!") {
+            negativeLists.push(Object.assign(pl, { reEnd: re.length }));
+          }
+          continue;
+        }
+        case "|": {
+          const plEntry = patternListStack[patternListStack.length - 1];
+          if (!plEntry) {
+            re += "\\|";
+            continue;
+          }
+          clearStateChar();
+          re += "|";
+          if (plEntry.start === 0 && plEntry.type !== "!") {
+            dotTravAllowed = true;
+            re += subPatternStart(pattern.slice(i + 1));
+          }
+          continue;
+        }
+        case "[":
+          clearStateChar();
+          const [src, needUflag, consumed, magic] = parseClass(pattern, i);
+          if (consumed) {
+            re += src;
+            uflag = uflag || needUflag;
+            i += consumed - 1;
+            hasMagic = hasMagic || magic;
+          } else {
+            re += "\\[";
+          }
+          continue;
+        case "]":
+          re += "\\" + c;
+          continue;
+        default:
+          clearStateChar();
+          re += regExpEscape(c);
+          break;
+      }
+    }
+    for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+      let tail;
+      tail = re.slice(pl.reStart + pl.open.length);
+      this.debug(this.pattern, "setting tail", re, pl);
+      tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_, $1, $2) => {
+        if (!$2) {
+          $2 = "\\";
+        }
+        return $1 + $1 + $2 + "|";
+      });
+      this.debug("tail=%j\n   %s", tail, tail, pl, re);
+      const t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
+      hasMagic = true;
+      re = re.slice(0, pl.reStart) + t + "\\(" + tail;
+    }
+    clearStateChar();
+    if (escaping) {
+      re += "\\\\";
+    }
+    const addPatternStart = addPatternStartSet[re.charAt(0)];
+    for (let n = negativeLists.length - 1; n > -1; n--) {
+      const nl = negativeLists[n];
+      const nlBefore = re.slice(0, nl.reStart);
+      const nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+      let nlAfter = re.slice(nl.reEnd);
+      const nlLast = re.slice(nl.reEnd - 8, nl.reEnd) + nlAfter;
+      const closeParensBefore = nlBefore.split(")").length;
+      const openParensBefore = nlBefore.split("(").length - closeParensBefore;
+      let cleanAfter = nlAfter;
+      for (let i = 0; i < openParensBefore; i++) {
+        cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
+      }
+      nlAfter = cleanAfter;
+      const dollar = nlAfter === "" ? "(?:$|\\/)" : "";
+      re = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+    }
+    if (re !== "" && hasMagic) {
+      re = "(?=.)" + re;
+    }
+    if (addPatternStart) {
+      re = patternStart() + re;
+    }
+    if (options.nocase && !hasMagic && !options.nocaseMagicOnly) {
+      hasMagic = pattern.toUpperCase() !== pattern.toLowerCase();
+    }
+    if (!hasMagic) {
+      return globUnescape(re);
+    }
+    const flags = (options.nocase ? "i" : "") + (uflag ? "u" : "");
+    try {
+      const ext2 = fastTest ? {
+        _glob: pattern,
+        _src: re,
+        test: fastTest
+      } : {
+        _glob: pattern,
+        _src: re
+      };
+      return Object.assign(new RegExp("^" + re + "$", flags), ext2);
+    } catch (er) {
+      this.debug("invalid regexp", er);
+      return new RegExp("$.");
+    }
+  }
+  makeRe() {
+    if (this.regexp || this.regexp === false)
+      return this.regexp;
+    const set = this.set;
+    if (!set.length) {
+      this.regexp = false;
+      return this.regexp;
+    }
+    const options = this.options;
+    const twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
+    const flags = options.nocase ? "i" : "";
+    let re = set.map((pattern) => {
+      const pp = pattern.map((p) => typeof p === "string" ? regExpEscape(p) : p === GLOBSTAR ? GLOBSTAR : p._src);
+      pp.forEach((p, i) => {
+        const next = pp[i + 1];
+        const prev = pp[i - 1];
+        if (p !== GLOBSTAR || prev === GLOBSTAR) {
+          return;
+        }
+        if (prev === void 0) {
+          if (next !== void 0 && next !== GLOBSTAR) {
+            pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
+          } else {
+            pp[i] = twoStar;
+          }
+        } else if (next === void 0) {
+          pp[i - 1] = prev + "(?:\\/|" + twoStar + ")?";
+        } else if (next !== GLOBSTAR) {
+          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
+          pp[i + 1] = GLOBSTAR;
+        }
+      });
+      return pp.filter((p) => p !== GLOBSTAR).join("/");
+    }).join("|");
+    re = "^(?:" + re + ")$";
+    if (this.negate)
+      re = "^(?!" + re + ").*$";
+    try {
+      this.regexp = new RegExp(re, flags);
+    } catch (ex) {
+      this.regexp = false;
+    }
+    return this.regexp;
+  }
+  slashSplit(p) {
+    if (this.preserveMultipleSlashes) {
+      return p.split("/");
+    } else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
+      return ["", ...p.split(/\/+/)];
+    } else {
+      return p.split(/\/+/);
+    }
+  }
+  match(f, partial = this.partial) {
+    this.debug("match", f, this.pattern);
+    if (this.comment) {
+      return false;
+    }
+    if (this.empty) {
+      return f === "";
+    }
+    if (f === "/" && partial) {
+      return true;
+    }
+    const options = this.options;
+    if (this.isWindows) {
+      f = f.split("\\").join("/");
+    }
+    const ff = this.slashSplit(f);
+    this.debug(this.pattern, "split", ff);
+    const set = this.set;
+    this.debug(this.pattern, "set", set);
+    let filename = ff[ff.length - 1];
+    if (!filename) {
+      for (let i = ff.length - 2; !filename && i >= 0; i--) {
+        filename = ff[i];
+      }
+    }
+    for (let i = 0; i < set.length; i++) {
+      const pattern = set[i];
+      let file = ff;
+      if (options.matchBase && pattern.length === 1) {
+        file = [filename];
+      }
+      const hit = this.matchOne(file, pattern, partial);
+      if (hit) {
+        if (options.flipNegate) {
+          return true;
+        }
+        return !this.negate;
+      }
+    }
+    if (options.flipNegate) {
+      return false;
+    }
+    return this.negate;
+  }
+  static defaults(def) {
+    return minimatch.defaults(def).Minimatch;
+  }
+};
+minimatch.Minimatch = Minimatch;
+minimatch.escape = escape;
+minimatch.unescape = unescape;
+
+// src/cli/commands/sqliteIntrospect.ts
+var import_hanji2 = __toESM(require_hanji());
+var sqlitePushIntrospect = async (client, filters) => {
+  const matchers = filters.map((it) => {
+    return new Minimatch(it);
+  });
+  const filter2 = (tableName) => {
+    if (matchers.length === 0)
+      return true;
+    for (let i = 0; i < matchers.length; i++) {
+      const matcher = matchers[i];
+      if (matcher.match(tableName))
+        return true;
+    }
+    return false;
+  };
+  const res = await fromDatabase2(client, filter2);
+  const schema = { id: originUUID, prevId: "", ...res };
+  return { schema };
+};
+
+// src/cli/commands/pgIntrospect.ts
+var import_hanji3 = __toESM(require_hanji());
+init_views();
+init_pgSerializer();
+
+// src/introspect-pg.ts
+init_pgSerializer();
+
+// src/cli/commands/pgIntrospect.ts
+var pgPushIntrospect = async (connection, filters, schemaFilters) => {
+  const { client } = connection;
+  const matchers = filters.map((it) => {
+    return new Minimatch(it);
+  });
+  const filter2 = (tableName) => {
+    if (matchers.length === 0)
+      return true;
+    for (let i = 0; i < matchers.length; i++) {
+      const matcher = matchers[i];
+      if (matcher.match(tableName))
+        return true;
+    }
+    return false;
+  };
+  const res = await fromDatabase(client, filter2, schemaFilters);
+  const schema = { id: originUUID, prevId: "", ...res };
+  const { internal, ...schemaWithoutInternals } = schema;
+  return { schema: schemaWithoutInternals };
+};
+
+// src/utils-studio.ts
+init_drivers();
+export {
+  DrizzleORMPgClient,
+  TursoSqlite,
+  toDrizzle as drizzleSchemaPg,
+  toDrizzle2 as drizzleSchemaSQLite,
+  pgPushIntrospect,
+  sqlitePushIntrospect
+};